// @ts-nocheck

// node_modules/dexie/dist/modern/dexie.mjs
var _global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
var keys = Object.keys;
var isArray = Array.isArray;
if (typeof Promise !== "undefined" && !_global.Promise) {
  _global.Promise = Promise;
}
function extend(obj, extension) {
  if (typeof extension !== "object")
    return obj;
  keys(extension).forEach(function(key) {
    obj[key] = extension[key];
  });
  return obj;
}
var getProto = Object.getPrototypeOf;
var _hasOwn = {}.hasOwnProperty;
function hasOwn(obj, prop) {
  return _hasOwn.call(obj, prop);
}
function props(proto, extension) {
  if (typeof extension === "function")
    extension = extension(getProto(proto));
  (typeof Reflect === "undefined" ? keys : Reflect.ownKeys)(extension).forEach((key) => {
    setProp(proto, key, extension[key]);
  });
}
var defineProperty = Object.defineProperty;
function setProp(obj, prop, functionOrGetSet, options) {
  defineProperty(obj, prop, extend(functionOrGetSet && hasOwn(functionOrGetSet, "get") && typeof functionOrGetSet.get === "function" ? { get: functionOrGetSet.get, set: functionOrGetSet.set, configurable: true } : { value: functionOrGetSet, configurable: true, writable: true }, options));
}
function derive(Child) {
  return {
    from: function(Parent) {
      Child.prototype = Object.create(Parent.prototype);
      setProp(Child.prototype, "constructor", Child);
      return {
        extend: props.bind(null, Child.prototype)
      };
    }
  };
}
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
function getPropertyDescriptor(obj, prop) {
  const pd = getOwnPropertyDescriptor(obj, prop);
  let proto;
  return pd || (proto = getProto(obj)) && getPropertyDescriptor(proto, prop);
}
var _slice = [].slice;
function slice(args, start, end) {
  return _slice.call(args, start, end);
}
function override(origFunc, overridedFactory) {
  return overridedFactory(origFunc);
}
function assert(b) {
  if (!b)
    throw new Error("Assertion Failed");
}
function asap$1(fn) {
  if (_global.setImmediate)
    setImmediate(fn);
  else
    setTimeout(fn, 0);
}
function arrayToObject(array, extractor) {
  return array.reduce((result, item, i) => {
    var nameAndValue = extractor(item, i);
    if (nameAndValue)
      result[nameAndValue[0]] = nameAndValue[1];
    return result;
  }, {});
}
function tryCatch(fn, onerror, args) {
  try {
    fn.apply(null, args);
  } catch (ex) {
    onerror && onerror(ex);
  }
}
function getByKeyPath(obj, keyPath) {
  if (typeof keyPath === "string" && hasOwn(obj, keyPath))
    return obj[keyPath];
  if (!keyPath)
    return obj;
  if (typeof keyPath !== "string") {
    var rv = [];
    for (var i = 0, l = keyPath.length; i < l; ++i) {
      var val = getByKeyPath(obj, keyPath[i]);
      rv.push(val);
    }
    return rv;
  }
  var period = keyPath.indexOf(".");
  if (period !== -1) {
    var innerObj = obj[keyPath.substr(0, period)];
    return innerObj === void 0 ? void 0 : getByKeyPath(innerObj, keyPath.substr(period + 1));
  }
  return void 0;
}
function setByKeyPath(obj, keyPath, value) {
  if (!obj || keyPath === void 0)
    return;
  if ("isFrozen" in Object && Object.isFrozen(obj))
    return;
  if (typeof keyPath !== "string" && "length" in keyPath) {
    assert(typeof value !== "string" && "length" in value);
    for (var i = 0, l = keyPath.length; i < l; ++i) {
      setByKeyPath(obj, keyPath[i], value[i]);
    }
  } else {
    var period = keyPath.indexOf(".");
    if (period !== -1) {
      var currentKeyPath = keyPath.substr(0, period);
      var remainingKeyPath = keyPath.substr(period + 1);
      if (remainingKeyPath === "")
        if (value === void 0) {
          if (isArray(obj) && !isNaN(parseInt(currentKeyPath)))
            obj.splice(currentKeyPath, 1);
          else
            delete obj[currentKeyPath];
        } else
          obj[currentKeyPath] = value;
      else {
        var innerObj = obj[currentKeyPath];
        if (!innerObj || !hasOwn(obj, currentKeyPath))
          innerObj = obj[currentKeyPath] = {};
        setByKeyPath(innerObj, remainingKeyPath, value);
      }
    } else {
      if (value === void 0) {
        if (isArray(obj) && !isNaN(parseInt(keyPath)))
          obj.splice(keyPath, 1);
        else
          delete obj[keyPath];
      } else
        obj[keyPath] = value;
    }
  }
}
function delByKeyPath(obj, keyPath) {
  if (typeof keyPath === "string")
    setByKeyPath(obj, keyPath, void 0);
  else if ("length" in keyPath)
    [].map.call(keyPath, function(kp) {
      setByKeyPath(obj, kp, void 0);
    });
}
function shallowClone(obj) {
  var rv = {};
  for (var m in obj) {
    if (hasOwn(obj, m))
      rv[m] = obj[m];
  }
  return rv;
}
var concat = [].concat;
function flatten(a) {
  return concat.apply([], a);
}
var intrinsicTypeNames = "BigUint64Array,BigInt64Array,Array,Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,FileSystemDirectoryHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey".split(",").concat(flatten([8, 16, 32, 64].map((num) => ["Int", "Uint", "Float"].map((t) => t + num + "Array")))).filter((t) => _global[t]);
var intrinsicTypes = intrinsicTypeNames.map((t) => _global[t]);
arrayToObject(intrinsicTypeNames, (x) => [x, true]);
var circularRefs = null;
function deepClone(any) {
  circularRefs = typeof WeakMap !== "undefined" && /* @__PURE__ */ new WeakMap();
  const rv = innerDeepClone(any);
  circularRefs = null;
  return rv;
}
function innerDeepClone(any) {
  if (!any || typeof any !== "object")
    return any;
  let rv = circularRefs && circularRefs.get(any);
  if (rv)
    return rv;
  if (isArray(any)) {
    rv = [];
    circularRefs && circularRefs.set(any, rv);
    for (var i = 0, l = any.length; i < l; ++i) {
      rv.push(innerDeepClone(any[i]));
    }
  } else if (intrinsicTypes.indexOf(any.constructor) >= 0) {
    rv = any;
  } else {
    const proto = getProto(any);
    rv = proto === Object.prototype ? {} : Object.create(proto);
    circularRefs && circularRefs.set(any, rv);
    for (var prop in any) {
      if (hasOwn(any, prop)) {
        rv[prop] = innerDeepClone(any[prop]);
      }
    }
  }
  return rv;
}
var { toString } = {};
function toStringTag(o) {
  return toString.call(o).slice(8, -1);
}
var iteratorSymbol = typeof Symbol !== "undefined" ? Symbol.iterator : "@@iterator";
var getIteratorOf = typeof iteratorSymbol === "symbol" ? function(x) {
  var i;
  return x != null && (i = x[iteratorSymbol]) && i.apply(x);
} : function() {
  return null;
};
var NO_CHAR_ARRAY = {};
function getArrayOf(arrayLike) {
  var i, a, x, it;
  if (arguments.length === 1) {
    if (isArray(arrayLike))
      return arrayLike.slice();
    if (this === NO_CHAR_ARRAY && typeof arrayLike === "string")
      return [arrayLike];
    if (it = getIteratorOf(arrayLike)) {
      a = [];
      while (x = it.next(), !x.done)
        a.push(x.value);
      return a;
    }
    if (arrayLike == null)
      return [arrayLike];
    i = arrayLike.length;
    if (typeof i === "number") {
      a = new Array(i);
      while (i--)
        a[i] = arrayLike[i];
      return a;
    }
    return [arrayLike];
  }
  i = arguments.length;
  a = new Array(i);
  while (i--)
    a[i] = arguments[i];
  return a;
}
var isAsyncFunction = typeof Symbol !== "undefined" ? (fn) => fn[Symbol.toStringTag] === "AsyncFunction" : () => false;
var debug = typeof location !== "undefined" && /^(http|https):\/\/(localhost|127\.0\.0\.1)/.test(location.href);
function setDebug(value, filter) {
  debug = value;
  libraryFilter = filter;
}
var libraryFilter = () => true;
var NEEDS_THROW_FOR_STACK = !new Error("").stack;
function getErrorWithStack() {
  if (NEEDS_THROW_FOR_STACK)
    try {
      getErrorWithStack.arguments;
      throw new Error();
    } catch (e) {
      return e;
    }
  return new Error();
}
function prettyStack(exception, numIgnoredFrames) {
  var stack = exception.stack;
  if (!stack)
    return "";
  numIgnoredFrames = numIgnoredFrames || 0;
  if (stack.indexOf(exception.name) === 0)
    numIgnoredFrames += (exception.name + exception.message).split("\n").length;
  return stack.split("\n").slice(numIgnoredFrames).filter(libraryFilter).map((frame) => "\n" + frame).join("");
}
var dexieErrorNames = [
  "Modify",
  "Bulk",
  "OpenFailed",
  "VersionChange",
  "Schema",
  "Upgrade",
  "InvalidTable",
  "MissingAPI",
  "NoSuchDatabase",
  "InvalidArgument",
  "SubTransaction",
  "Unsupported",
  "Internal",
  "DatabaseClosed",
  "PrematureCommit",
  "ForeignAwait"
];
var idbDomErrorNames = [
  "Unknown",
  "Constraint",
  "Data",
  "TransactionInactive",
  "ReadOnly",
  "Version",
  "NotFound",
  "InvalidState",
  "InvalidAccess",
  "Abort",
  "Timeout",
  "QuotaExceeded",
  "Syntax",
  "DataClone"
];
var errorList = dexieErrorNames.concat(idbDomErrorNames);
var defaultTexts = {
  VersionChanged: "Database version changed by other database connection",
  DatabaseClosed: "Database has been closed",
  Abort: "Transaction aborted",
  TransactionInactive: "Transaction has already completed or failed",
  MissingAPI: "IndexedDB API missing. Please visit https://tinyurl.com/y2uuvskb"
};
function DexieError(name, msg) {
  this._e = getErrorWithStack();
  this.name = name;
  this.message = msg;
}
derive(DexieError).from(Error).extend({
  stack: {
    get: function() {
      return this._stack || (this._stack = this.name + ": " + this.message + prettyStack(this._e, 2));
    }
  },
  toString: function() {
    return this.name + ": " + this.message;
  }
});
function getMultiErrorMessage(msg, failures) {
  return msg + ". Errors: " + Object.keys(failures).map((key) => failures[key].toString()).filter((v, i, s) => s.indexOf(v) === i).join("\n");
}
function ModifyError(msg, failures, successCount, failedKeys) {
  this._e = getErrorWithStack();
  this.failures = failures;
  this.failedKeys = failedKeys;
  this.successCount = successCount;
  this.message = getMultiErrorMessage(msg, failures);
}
derive(ModifyError).from(DexieError);
function BulkError(msg, failures) {
  this._e = getErrorWithStack();
  this.name = "BulkError";
  this.failures = Object.keys(failures).map((pos) => failures[pos]);
  this.failuresByPos = failures;
  this.message = getMultiErrorMessage(msg, failures);
}
derive(BulkError).from(DexieError);
var errnames = errorList.reduce((obj, name) => (obj[name] = name + "Error", obj), {});
var BaseException = DexieError;
var exceptions = errorList.reduce((obj, name) => {
  var fullName = name + "Error";
  function DexieError2(msgOrInner, inner) {
    this._e = getErrorWithStack();
    this.name = fullName;
    if (!msgOrInner) {
      this.message = defaultTexts[name] || fullName;
      this.inner = null;
    } else if (typeof msgOrInner === "string") {
      this.message = `${msgOrInner}${!inner ? "" : "\n " + inner}`;
      this.inner = inner || null;
    } else if (typeof msgOrInner === "object") {
      this.message = `${msgOrInner.name} ${msgOrInner.message}`;
      this.inner = msgOrInner;
    }
  }
  derive(DexieError2).from(BaseException);
  obj[name] = DexieError2;
  return obj;
}, {});
exceptions.Syntax = SyntaxError;
exceptions.Type = TypeError;
exceptions.Range = RangeError;
var exceptionMap = idbDomErrorNames.reduce((obj, name) => {
  obj[name + "Error"] = exceptions[name];
  return obj;
}, {});
function mapError(domError, message) {
  if (!domError || domError instanceof DexieError || domError instanceof TypeError || domError instanceof SyntaxError || !domError.name || !exceptionMap[domError.name])
    return domError;
  var rv = new exceptionMap[domError.name](message || domError.message, domError);
  if ("stack" in domError) {
    setProp(rv, "stack", { get: function() {
      return this.inner.stack;
    } });
  }
  return rv;
}
var fullNameExceptions = errorList.reduce((obj, name) => {
  if (["Syntax", "Type", "Range"].indexOf(name) === -1)
    obj[name + "Error"] = exceptions[name];
  return obj;
}, {});
fullNameExceptions.ModifyError = ModifyError;
fullNameExceptions.DexieError = DexieError;
fullNameExceptions.BulkError = BulkError;
function nop() {
}
function mirror(val) {
  return val;
}
function pureFunctionChain(f1, f2) {
  if (f1 == null || f1 === mirror)
    return f2;
  return function(val) {
    return f2(f1(val));
  };
}
function callBoth(on1, on2) {
  return function() {
    on1.apply(this, arguments);
    on2.apply(this, arguments);
  };
}
function hookCreatingChain(f1, f2) {
  if (f1 === nop)
    return f2;
  return function() {
    var res = f1.apply(this, arguments);
    if (res !== void 0)
      arguments[0] = res;
    var onsuccess = this.onsuccess, onerror = this.onerror;
    this.onsuccess = null;
    this.onerror = null;
    var res2 = f2.apply(this, arguments);
    if (onsuccess)
      this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
    if (onerror)
      this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
    return res2 !== void 0 ? res2 : res;
  };
}
function hookDeletingChain(f1, f2) {
  if (f1 === nop)
    return f2;
  return function() {
    f1.apply(this, arguments);
    var onsuccess = this.onsuccess, onerror = this.onerror;
    this.onsuccess = this.onerror = null;
    f2.apply(this, arguments);
    if (onsuccess)
      this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
    if (onerror)
      this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
  };
}
function hookUpdatingChain(f1, f2) {
  if (f1 === nop)
    return f2;
  return function(modifications) {
    var res = f1.apply(this, arguments);
    extend(modifications, res);
    var onsuccess = this.onsuccess, onerror = this.onerror;
    this.onsuccess = null;
    this.onerror = null;
    var res2 = f2.apply(this, arguments);
    if (onsuccess)
      this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
    if (onerror)
      this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
    return res === void 0 ? res2 === void 0 ? void 0 : res2 : extend(res, res2);
  };
}
function reverseStoppableEventChain(f1, f2) {
  if (f1 === nop)
    return f2;
  return function() {
    if (f2.apply(this, arguments) === false)
      return false;
    return f1.apply(this, arguments);
  };
}
function promisableChain(f1, f2) {
  if (f1 === nop)
    return f2;
  return function() {
    var res = f1.apply(this, arguments);
    if (res && typeof res.then === "function") {
      var thiz = this, i = arguments.length, args = new Array(i);
      while (i--)
        args[i] = arguments[i];
      return res.then(function() {
        return f2.apply(thiz, args);
      });
    }
    return f2.apply(this, arguments);
  };
}
var INTERNAL = {};
var LONG_STACKS_CLIP_LIMIT = 100;
var MAX_LONG_STACKS = 20;
var ZONE_ECHO_LIMIT = 100;
var [resolvedNativePromise, nativePromiseProto, resolvedGlobalPromise] = typeof Promise === "undefined" ? [] : (() => {
  let globalP = Promise.resolve();
  if (typeof crypto === "undefined" || !crypto.subtle)
    return [globalP, getProto(globalP), globalP];
  const nativeP = crypto.subtle.digest("SHA-512", new Uint8Array([0]));
  return [
    nativeP,
    getProto(nativeP),
    globalP
  ];
})();
var nativePromiseThen = nativePromiseProto && nativePromiseProto.then;
var NativePromise = resolvedNativePromise && resolvedNativePromise.constructor;
var patchGlobalPromise = !!resolvedGlobalPromise;
var stack_being_generated = false;
var schedulePhysicalTick = resolvedGlobalPromise ? () => {
  resolvedGlobalPromise.then(physicalTick);
} : _global.setImmediate ? setImmediate.bind(null, physicalTick) : _global.MutationObserver ? () => {
  var hiddenDiv = document.createElement("div");
  new MutationObserver(() => {
    physicalTick();
    hiddenDiv = null;
  }).observe(hiddenDiv, { attributes: true });
  hiddenDiv.setAttribute("i", "1");
} : () => {
  setTimeout(physicalTick, 0);
};
var asap = function(callback, args) {
  microtickQueue.push([callback, args]);
  if (needsNewPhysicalTick) {
    schedulePhysicalTick();
    needsNewPhysicalTick = false;
  }
};
var isOutsideMicroTick = true;
var needsNewPhysicalTick = true;
var unhandledErrors = [];
var rejectingErrors = [];
var currentFulfiller = null;
var rejectionMapper = mirror;
var globalPSD = {
  id: "global",
  global: true,
  ref: 0,
  unhandleds: [],
  onunhandled: globalError,
  pgp: false,
  env: {},
  finalize: function() {
    this.unhandleds.forEach((uh) => {
      try {
        globalError(uh[0], uh[1]);
      } catch (e) {
      }
    });
  }
};
var PSD = globalPSD;
var microtickQueue = [];
var numScheduledCalls = 0;
var tickFinalizers = [];
function DexiePromise(fn) {
  if (typeof this !== "object")
    throw new TypeError("Promises must be constructed via new");
  this._listeners = [];
  this.onuncatched = nop;
  this._lib = false;
  var psd = this._PSD = PSD;
  if (debug) {
    this._stackHolder = getErrorWithStack();
    this._prev = null;
    this._numPrev = 0;
  }
  if (typeof fn !== "function") {
    if (fn !== INTERNAL)
      throw new TypeError("Not a function");
    this._state = arguments[1];
    this._value = arguments[2];
    if (this._state === false)
      handleRejection(this, this._value);
    return;
  }
  this._state = null;
  this._value = null;
  ++psd.ref;
  executePromiseTask(this, fn);
}
var thenProp = {
  get: function() {
    var psd = PSD, microTaskId = totalEchoes;
    function then(onFulfilled, onRejected) {
      var possibleAwait = !psd.global && (psd !== PSD || microTaskId !== totalEchoes);
      const cleanup = possibleAwait && !decrementExpectedAwaits();
      var rv = new DexiePromise((resolve, reject) => {
        propagateToListener(this, new Listener(nativeAwaitCompatibleWrap(onFulfilled, psd, possibleAwait, cleanup), nativeAwaitCompatibleWrap(onRejected, psd, possibleAwait, cleanup), resolve, reject, psd));
      });
      debug && linkToPreviousPromise(rv, this);
      return rv;
    }
    then.prototype = INTERNAL;
    return then;
  },
  set: function(value) {
    setProp(this, "then", value && value.prototype === INTERNAL ? thenProp : {
      get: function() {
        return value;
      },
      set: thenProp.set
    });
  }
};
props(DexiePromise.prototype, {
  then: thenProp,
  _then: function(onFulfilled, onRejected) {
    propagateToListener(this, new Listener(null, null, onFulfilled, onRejected, PSD));
  },
  catch: function(onRejected) {
    if (arguments.length === 1)
      return this.then(null, onRejected);
    var type2 = arguments[0], handler = arguments[1];
    return typeof type2 === "function" ? this.then(null, (err) => err instanceof type2 ? handler(err) : PromiseReject(err)) : this.then(null, (err) => err && err.name === type2 ? handler(err) : PromiseReject(err));
  },
  finally: function(onFinally) {
    return this.then((value) => {
      onFinally();
      return value;
    }, (err) => {
      onFinally();
      return PromiseReject(err);
    });
  },
  stack: {
    get: function() {
      if (this._stack)
        return this._stack;
      try {
        stack_being_generated = true;
        var stacks = getStack(this, [], MAX_LONG_STACKS);
        var stack = stacks.join("\nFrom previous: ");
        if (this._state !== null)
          this._stack = stack;
        return stack;
      } finally {
        stack_being_generated = false;
      }
    }
  },
  timeout: function(ms, msg) {
    return ms < Infinity ? new DexiePromise((resolve, reject) => {
      var handle = setTimeout(() => reject(new exceptions.Timeout(msg)), ms);
      this.then(resolve, reject).finally(clearTimeout.bind(null, handle));
    }) : this;
  }
});
if (typeof Symbol !== "undefined" && Symbol.toStringTag)
  setProp(DexiePromise.prototype, Symbol.toStringTag, "Dexie.Promise");
globalPSD.env = snapShot();
function Listener(onFulfilled, onRejected, resolve, reject, zone) {
  this.onFulfilled = typeof onFulfilled === "function" ? onFulfilled : null;
  this.onRejected = typeof onRejected === "function" ? onRejected : null;
  this.resolve = resolve;
  this.reject = reject;
  this.psd = zone;
}
props(DexiePromise, {
  all: function() {
    var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
    return new DexiePromise(function(resolve, reject) {
      if (values.length === 0)
        resolve([]);
      var remaining = values.length;
      values.forEach((a, i) => DexiePromise.resolve(a).then((x) => {
        values[i] = x;
        if (!--remaining)
          resolve(values);
      }, reject));
    });
  },
  resolve: (value) => {
    if (value instanceof DexiePromise)
      return value;
    if (value && typeof value.then === "function")
      return new DexiePromise((resolve, reject) => {
        value.then(resolve, reject);
      });
    var rv = new DexiePromise(INTERNAL, true, value);
    linkToPreviousPromise(rv, currentFulfiller);
    return rv;
  },
  reject: PromiseReject,
  race: function() {
    var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
    return new DexiePromise((resolve, reject) => {
      values.map((value) => DexiePromise.resolve(value).then(resolve, reject));
    });
  },
  PSD: {
    get: () => PSD,
    set: (value) => PSD = value
  },
  totalEchoes: { get: () => totalEchoes },
  newPSD: newScope,
  usePSD,
  scheduler: {
    get: () => asap,
    set: (value) => {
      asap = value;
    }
  },
  rejectionMapper: {
    get: () => rejectionMapper,
    set: (value) => {
      rejectionMapper = value;
    }
  },
  follow: (fn, zoneProps) => {
    return new DexiePromise((resolve, reject) => {
      return newScope((resolve2, reject2) => {
        var psd = PSD;
        psd.unhandleds = [];
        psd.onunhandled = reject2;
        psd.finalize = callBoth(function() {
          run_at_end_of_this_or_next_physical_tick(() => {
            this.unhandleds.length === 0 ? resolve2() : reject2(this.unhandleds[0]);
          });
        }, psd.finalize);
        fn();
      }, zoneProps, resolve, reject);
    });
  }
});
if (NativePromise) {
  if (NativePromise.allSettled)
    setProp(DexiePromise, "allSettled", function() {
      const possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
      return new DexiePromise((resolve) => {
        if (possiblePromises.length === 0)
          resolve([]);
        let remaining = possiblePromises.length;
        const results = new Array(remaining);
        possiblePromises.forEach((p, i) => DexiePromise.resolve(p).then((value) => results[i] = { status: "fulfilled", value }, (reason) => results[i] = { status: "rejected", reason }).then(() => --remaining || resolve(results)));
      });
    });
  if (NativePromise.any && typeof AggregateError !== "undefined")
    setProp(DexiePromise, "any", function() {
      const possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
      return new DexiePromise((resolve, reject) => {
        if (possiblePromises.length === 0)
          reject(new AggregateError([]));
        let remaining = possiblePromises.length;
        const failures = new Array(remaining);
        possiblePromises.forEach((p, i) => DexiePromise.resolve(p).then((value) => resolve(value), (failure) => {
          failures[i] = failure;
          if (!--remaining)
            reject(new AggregateError(failures));
        }));
      });
    });
}
function executePromiseTask(promise, fn) {
  try {
    fn((value) => {
      if (promise._state !== null)
        return;
      if (value === promise)
        throw new TypeError("A promise cannot be resolved with itself.");
      var shouldExecuteTick = promise._lib && beginMicroTickScope();
      if (value && typeof value.then === "function") {
        executePromiseTask(promise, (resolve, reject) => {
          value instanceof DexiePromise ? value._then(resolve, reject) : value.then(resolve, reject);
        });
      } else {
        promise._state = true;
        promise._value = value;
        propagateAllListeners(promise);
      }
      if (shouldExecuteTick)
        endMicroTickScope();
    }, handleRejection.bind(null, promise));
  } catch (ex) {
    handleRejection(promise, ex);
  }
}
function handleRejection(promise, reason) {
  rejectingErrors.push(reason);
  if (promise._state !== null)
    return;
  var shouldExecuteTick = promise._lib && beginMicroTickScope();
  reason = rejectionMapper(reason);
  promise._state = false;
  promise._value = reason;
  debug && reason !== null && typeof reason === "object" && !reason._promise && tryCatch(() => {
    var origProp = getPropertyDescriptor(reason, "stack");
    reason._promise = promise;
    setProp(reason, "stack", {
      get: () => stack_being_generated ? origProp && (origProp.get ? origProp.get.apply(reason) : origProp.value) : promise.stack
    });
  });
  addPossiblyUnhandledError(promise);
  propagateAllListeners(promise);
  if (shouldExecuteTick)
    endMicroTickScope();
}
function propagateAllListeners(promise) {
  var listeners = promise._listeners;
  promise._listeners = [];
  for (var i = 0, len = listeners.length; i < len; ++i) {
    propagateToListener(promise, listeners[i]);
  }
  var psd = promise._PSD;
  --psd.ref || psd.finalize();
  if (numScheduledCalls === 0) {
    ++numScheduledCalls;
    asap(() => {
      if (--numScheduledCalls === 0)
        finalizePhysicalTick();
    }, []);
  }
}
function propagateToListener(promise, listener) {
  if (promise._state === null) {
    promise._listeners.push(listener);
    return;
  }
  var cb = promise._state ? listener.onFulfilled : listener.onRejected;
  if (cb === null) {
    return (promise._state ? listener.resolve : listener.reject)(promise._value);
  }
  ++listener.psd.ref;
  ++numScheduledCalls;
  asap(callListener, [cb, promise, listener]);
}
function callListener(cb, promise, listener) {
  try {
    currentFulfiller = promise;
    var ret, value = promise._value;
    if (promise._state) {
      ret = cb(value);
    } else {
      if (rejectingErrors.length)
        rejectingErrors = [];
      ret = cb(value);
      if (rejectingErrors.indexOf(value) === -1)
        markErrorAsHandled(promise);
    }
    listener.resolve(ret);
  } catch (e) {
    listener.reject(e);
  } finally {
    currentFulfiller = null;
    if (--numScheduledCalls === 0)
      finalizePhysicalTick();
    --listener.psd.ref || listener.psd.finalize();
  }
}
function getStack(promise, stacks, limit) {
  if (stacks.length === limit)
    return stacks;
  var stack = "";
  if (promise._state === false) {
    var failure = promise._value, errorName, message;
    if (failure != null) {
      errorName = failure.name || "Error";
      message = failure.message || failure;
      stack = prettyStack(failure, 0);
    } else {
      errorName = failure;
      message = "";
    }
    stacks.push(errorName + (message ? ": " + message : "") + stack);
  }
  if (debug) {
    stack = prettyStack(promise._stackHolder, 2);
    if (stack && stacks.indexOf(stack) === -1)
      stacks.push(stack);
    if (promise._prev)
      getStack(promise._prev, stacks, limit);
  }
  return stacks;
}
function linkToPreviousPromise(promise, prev) {
  var numPrev = prev ? prev._numPrev + 1 : 0;
  if (numPrev < LONG_STACKS_CLIP_LIMIT) {
    promise._prev = prev;
    promise._numPrev = numPrev;
  }
}
function physicalTick() {
  beginMicroTickScope() && endMicroTickScope();
}
function beginMicroTickScope() {
  var wasRootExec = isOutsideMicroTick;
  isOutsideMicroTick = false;
  needsNewPhysicalTick = false;
  return wasRootExec;
}
function endMicroTickScope() {
  var callbacks, i, l;
  do {
    while (microtickQueue.length > 0) {
      callbacks = microtickQueue;
      microtickQueue = [];
      l = callbacks.length;
      for (i = 0; i < l; ++i) {
        var item = callbacks[i];
        item[0].apply(null, item[1]);
      }
    }
  } while (microtickQueue.length > 0);
  isOutsideMicroTick = true;
  needsNewPhysicalTick = true;
}
function finalizePhysicalTick() {
  var unhandledErrs = unhandledErrors;
  unhandledErrors = [];
  unhandledErrs.forEach((p) => {
    p._PSD.onunhandled.call(null, p._value, p);
  });
  var finalizers = tickFinalizers.slice(0);
  var i = finalizers.length;
  while (i)
    finalizers[--i]();
}
function run_at_end_of_this_or_next_physical_tick(fn) {
  function finalizer() {
    fn();
    tickFinalizers.splice(tickFinalizers.indexOf(finalizer), 1);
  }
  tickFinalizers.push(finalizer);
  ++numScheduledCalls;
  asap(() => {
    if (--numScheduledCalls === 0)
      finalizePhysicalTick();
  }, []);
}
function addPossiblyUnhandledError(promise) {
  if (!unhandledErrors.some((p) => p._value === promise._value))
    unhandledErrors.push(promise);
}
function markErrorAsHandled(promise) {
  var i = unhandledErrors.length;
  while (i)
    if (unhandledErrors[--i]._value === promise._value) {
      unhandledErrors.splice(i, 1);
      return;
    }
}
function PromiseReject(reason) {
  return new DexiePromise(INTERNAL, false, reason);
}
function wrap(fn, errorCatcher) {
  var psd = PSD;
  return function() {
    var wasRootExec = beginMicroTickScope(), outerScope = PSD;
    try {
      switchToZone(psd, true);
      return fn.apply(this, arguments);
    } catch (e) {
      errorCatcher && errorCatcher(e);
    } finally {
      switchToZone(outerScope, false);
      if (wasRootExec)
        endMicroTickScope();
    }
  };
}
var task = { awaits: 0, echoes: 0, id: 0 };
var taskCounter = 0;
var zoneStack = [];
var zoneEchoes = 0;
var totalEchoes = 0;
var zone_id_counter = 0;
function newScope(fn, props2, a1, a2) {
  var parent = PSD, psd = Object.create(parent);
  psd.parent = parent;
  psd.ref = 0;
  psd.global = false;
  psd.id = ++zone_id_counter;
  var globalEnv = globalPSD.env;
  psd.env = patchGlobalPromise ? {
    Promise: DexiePromise,
    PromiseProp: { value: DexiePromise, configurable: true, writable: true },
    all: DexiePromise.all,
    race: DexiePromise.race,
    allSettled: DexiePromise.allSettled,
    any: DexiePromise.any,
    resolve: DexiePromise.resolve,
    reject: DexiePromise.reject,
    nthen: getPatchedPromiseThen(globalEnv.nthen, psd),
    gthen: getPatchedPromiseThen(globalEnv.gthen, psd)
  } : {};
  if (props2)
    extend(psd, props2);
  ++parent.ref;
  psd.finalize = function() {
    --this.parent.ref || this.parent.finalize();
  };
  var rv = usePSD(psd, fn, a1, a2);
  if (psd.ref === 0)
    psd.finalize();
  return rv;
}
function incrementExpectedAwaits() {
  if (!task.id)
    task.id = ++taskCounter;
  ++task.awaits;
  task.echoes += ZONE_ECHO_LIMIT;
  return task.id;
}
function decrementExpectedAwaits() {
  if (!task.awaits)
    return false;
  if (--task.awaits === 0)
    task.id = 0;
  task.echoes = task.awaits * ZONE_ECHO_LIMIT;
  return true;
}
if (("" + nativePromiseThen).indexOf("[native code]") === -1) {
  incrementExpectedAwaits = decrementExpectedAwaits = nop;
}
function onPossibleParallellAsync(possiblePromise) {
  if (task.echoes && possiblePromise && possiblePromise.constructor === NativePromise) {
    incrementExpectedAwaits();
    return possiblePromise.then((x) => {
      decrementExpectedAwaits();
      return x;
    }, (e) => {
      decrementExpectedAwaits();
      return rejection(e);
    });
  }
  return possiblePromise;
}
function zoneEnterEcho(targetZone) {
  ++totalEchoes;
  if (!task.echoes || --task.echoes === 0) {
    task.echoes = task.id = 0;
  }
  zoneStack.push(PSD);
  switchToZone(targetZone, true);
}
function zoneLeaveEcho() {
  var zone = zoneStack[zoneStack.length - 1];
  zoneStack.pop();
  switchToZone(zone, false);
}
function switchToZone(targetZone, bEnteringZone) {
  var currentZone = PSD;
  if (bEnteringZone ? task.echoes && (!zoneEchoes++ || targetZone !== PSD) : zoneEchoes && (!--zoneEchoes || targetZone !== PSD)) {
    enqueueNativeMicroTask(bEnteringZone ? zoneEnterEcho.bind(null, targetZone) : zoneLeaveEcho);
  }
  if (targetZone === PSD)
    return;
  PSD = targetZone;
  if (currentZone === globalPSD)
    globalPSD.env = snapShot();
  if (patchGlobalPromise) {
    var GlobalPromise = globalPSD.env.Promise;
    var targetEnv = targetZone.env;
    nativePromiseProto.then = targetEnv.nthen;
    GlobalPromise.prototype.then = targetEnv.gthen;
    if (currentZone.global || targetZone.global) {
      Object.defineProperty(_global, "Promise", targetEnv.PromiseProp);
      GlobalPromise.all = targetEnv.all;
      GlobalPromise.race = targetEnv.race;
      GlobalPromise.resolve = targetEnv.resolve;
      GlobalPromise.reject = targetEnv.reject;
      if (targetEnv.allSettled)
        GlobalPromise.allSettled = targetEnv.allSettled;
      if (targetEnv.any)
        GlobalPromise.any = targetEnv.any;
    }
  }
}
function snapShot() {
  var GlobalPromise = _global.Promise;
  return patchGlobalPromise ? {
    Promise: GlobalPromise,
    PromiseProp: Object.getOwnPropertyDescriptor(_global, "Promise"),
    all: GlobalPromise.all,
    race: GlobalPromise.race,
    allSettled: GlobalPromise.allSettled,
    any: GlobalPromise.any,
    resolve: GlobalPromise.resolve,
    reject: GlobalPromise.reject,
    nthen: nativePromiseProto.then,
    gthen: GlobalPromise.prototype.then
  } : {};
}
function usePSD(psd, fn, a1, a2, a3) {
  var outerScope = PSD;
  try {
    switchToZone(psd, true);
    return fn(a1, a2, a3);
  } finally {
    switchToZone(outerScope, false);
  }
}
function enqueueNativeMicroTask(job) {
  nativePromiseThen.call(resolvedNativePromise, job);
}
function nativeAwaitCompatibleWrap(fn, zone, possibleAwait, cleanup) {
  return typeof fn !== "function" ? fn : function() {
    var outerZone = PSD;
    if (possibleAwait)
      incrementExpectedAwaits();
    switchToZone(zone, true);
    try {
      return fn.apply(this, arguments);
    } finally {
      switchToZone(outerZone, false);
      if (cleanup)
        enqueueNativeMicroTask(decrementExpectedAwaits);
    }
  };
}
function getPatchedPromiseThen(origThen, zone) {
  return function(onResolved, onRejected) {
    return origThen.call(this, nativeAwaitCompatibleWrap(onResolved, zone), nativeAwaitCompatibleWrap(onRejected, zone));
  };
}
var UNHANDLEDREJECTION = "unhandledrejection";
function globalError(err, promise) {
  var rv;
  try {
    rv = promise.onuncatched(err);
  } catch (e) {
  }
  if (rv !== false)
    try {
      var event, eventData = { promise, reason: err };
      if (_global.document && document.createEvent) {
        event = document.createEvent("Event");
        event.initEvent(UNHANDLEDREJECTION, true, true);
        extend(event, eventData);
      } else if (_global.CustomEvent) {
        event = new CustomEvent(UNHANDLEDREJECTION, { detail: eventData });
        extend(event, eventData);
      }
      if (event && _global.dispatchEvent) {
        dispatchEvent(event);
        if (!_global.PromiseRejectionEvent && _global.onunhandledrejection)
          try {
            _global.onunhandledrejection(event);
          } catch (_) {
          }
      }
      if (debug && event && !event.defaultPrevented) {
        console.warn(`Unhandled rejection: ${err.stack || err}`);
      }
    } catch (e) {
    }
}
var rejection = DexiePromise.reject;
function tempTransaction(db, mode, storeNames, fn) {
  if (!db.idbdb || !db._state.openComplete && (!PSD.letThrough && !db._vip)) {
    if (db._state.openComplete) {
      return rejection(new exceptions.DatabaseClosed(db._state.dbOpenError));
    }
    if (!db._state.isBeingOpened) {
      if (!db._options.autoOpen)
        return rejection(new exceptions.DatabaseClosed());
      db.open().catch(nop);
    }
    return db._state.dbReadyPromise.then(() => tempTransaction(db, mode, storeNames, fn));
  } else {
    var trans = db._createTransaction(mode, storeNames, db._dbSchema);
    try {
      trans.create();
      db._state.PR1398_maxLoop = 3;
    } catch (ex) {
      if (ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) {
        console.warn("Dexie: Need to reopen db");
        db._close();
        return db.open().then(() => tempTransaction(db, mode, storeNames, fn));
      }
      return rejection(ex);
    }
    return trans._promise(mode, (resolve, reject) => {
      return newScope(() => {
        PSD.trans = trans;
        return fn(resolve, reject, trans);
      });
    }).then((result) => {
      return trans._completion.then(() => result);
    });
  }
}
var DEXIE_VERSION = "3.2.5";
var maxString = String.fromCharCode(65535);
var minKey = -Infinity;
var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
var STRING_EXPECTED = "String expected.";
var connections = [];
var isIEOrEdge = typeof navigator !== "undefined" && /(MSIE|Trident|Edge)/.test(navigator.userAgent);
var hasIEDeleteObjectStoreBug = isIEOrEdge;
var hangsOnDeleteLargeKeyRange = isIEOrEdge;
var dexieStackFrameFilter = (frame) => !/(dexie\.js|dexie\.min\.js)/.test(frame);
var DBNAMES_DB = "__dbnames";
var READONLY = "readonly";
var READWRITE = "readwrite";
function combine(filter1, filter2) {
  return filter1 ? filter2 ? function() {
    return filter1.apply(this, arguments) && filter2.apply(this, arguments);
  } : filter1 : filter2;
}
var AnyRange = {
  type: 3,
  lower: -Infinity,
  lowerOpen: false,
  upper: [[]],
  upperOpen: false
};
function workaroundForUndefinedPrimKey(keyPath) {
  return typeof keyPath === "string" && !/\./.test(keyPath) ? (obj) => {
    if (obj[keyPath] === void 0 && keyPath in obj) {
      obj = deepClone(obj);
      delete obj[keyPath];
    }
    return obj;
  } : (obj) => obj;
}
var Table = class {
  _trans(mode, fn, writeLocked) {
    const trans = this._tx || PSD.trans;
    const tableName = this.name;
    function checkTableInTransaction(resolve, reject, trans2) {
      if (!trans2.schema[tableName])
        throw new exceptions.NotFound("Table " + tableName + " not part of transaction");
      return fn(trans2.idbtrans, trans2);
    }
    const wasRootExec = beginMicroTickScope();
    try {
      return trans && trans.db === this.db ? trans === PSD.trans ? trans._promise(mode, checkTableInTransaction, writeLocked) : newScope(() => trans._promise(mode, checkTableInTransaction, writeLocked), { trans, transless: PSD.transless || PSD }) : tempTransaction(this.db, mode, [this.name], checkTableInTransaction);
    } finally {
      if (wasRootExec)
        endMicroTickScope();
    }
  }
  get(keyOrCrit, cb) {
    if (keyOrCrit && keyOrCrit.constructor === Object)
      return this.where(keyOrCrit).first(cb);
    return this._trans("readonly", (trans) => {
      return this.core.get({ trans, key: keyOrCrit }).then((res) => this.hook.reading.fire(res));
    }).then(cb);
  }
  where(indexOrCrit) {
    if (typeof indexOrCrit === "string")
      return new this.db.WhereClause(this, indexOrCrit);
    if (isArray(indexOrCrit))
      return new this.db.WhereClause(this, `[${indexOrCrit.join("+")}]`);
    const keyPaths = keys(indexOrCrit);
    if (keyPaths.length === 1)
      return this.where(keyPaths[0]).equals(indexOrCrit[keyPaths[0]]);
    const compoundIndex = this.schema.indexes.concat(this.schema.primKey).filter((ix) => {
      if (ix.compound && keyPaths.every((keyPath) => ix.keyPath.indexOf(keyPath) >= 0)) {
        for (let i = 0; i < keyPaths.length; ++i) {
          if (keyPaths.indexOf(ix.keyPath[i]) === -1)
            return false;
        }
        return true;
      }
      return false;
    }).sort((a, b) => a.keyPath.length - b.keyPath.length)[0];
    if (compoundIndex && this.db._maxKey !== maxString) {
      const keyPathsInValidOrder = compoundIndex.keyPath.slice(0, keyPaths.length);
      return this.where(keyPathsInValidOrder).equals(keyPathsInValidOrder.map((kp) => indexOrCrit[kp]));
    }
    if (!compoundIndex && debug)
      console.warn(`The query ${JSON.stringify(indexOrCrit)} on ${this.name} would benefit of a compound index [${keyPaths.join("+")}]`);
    const { idxByName } = this.schema;
    const idb = this.db._deps.indexedDB;
    function equals(a, b) {
      try {
        return idb.cmp(a, b) === 0;
      } catch (e) {
        return false;
      }
    }
    const [idx, filterFunction] = keyPaths.reduce(([prevIndex, prevFilterFn], keyPath) => {
      const index = idxByName[keyPath];
      const value = indexOrCrit[keyPath];
      return [
        prevIndex || index,
        prevIndex || !index ? combine(prevFilterFn, index && index.multi ? (x) => {
          const prop = getByKeyPath(x, keyPath);
          return isArray(prop) && prop.some((item) => equals(value, item));
        } : (x) => equals(value, getByKeyPath(x, keyPath))) : prevFilterFn
      ];
    }, [null, null]);
    return idx ? this.where(idx.name).equals(indexOrCrit[idx.keyPath]).filter(filterFunction) : compoundIndex ? this.filter(filterFunction) : this.where(keyPaths).equals("");
  }
  filter(filterFunction) {
    return this.toCollection().and(filterFunction);
  }
  count(thenShortcut) {
    return this.toCollection().count(thenShortcut);
  }
  offset(offset) {
    return this.toCollection().offset(offset);
  }
  limit(numRows) {
    return this.toCollection().limit(numRows);
  }
  each(callback) {
    return this.toCollection().each(callback);
  }
  toArray(thenShortcut) {
    return this.toCollection().toArray(thenShortcut);
  }
  toCollection() {
    return new this.db.Collection(new this.db.WhereClause(this));
  }
  orderBy(index) {
    return new this.db.Collection(new this.db.WhereClause(this, isArray(index) ? `[${index.join("+")}]` : index));
  }
  reverse() {
    return this.toCollection().reverse();
  }
  mapToClass(constructor) {
    this.schema.mappedClass = constructor;
    const readHook = (obj) => {
      if (!obj)
        return obj;
      const res = Object.create(constructor.prototype);
      for (var m in obj)
        if (hasOwn(obj, m))
          try {
            res[m] = obj[m];
          } catch (_) {
          }
      return res;
    };
    if (this.schema.readHook) {
      this.hook.reading.unsubscribe(this.schema.readHook);
    }
    this.schema.readHook = readHook;
    this.hook("reading", readHook);
    return constructor;
  }
  defineClass() {
    function Class(content) {
      extend(this, content);
    }
    return this.mapToClass(Class);
  }
  add(obj, key) {
    const { auto, keyPath } = this.schema.primKey;
    let objToAdd = obj;
    if (keyPath && auto) {
      objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);
    }
    return this._trans("readwrite", (trans) => {
      return this.core.mutate({ trans, type: "add", keys: key != null ? [key] : null, values: [objToAdd] });
    }).then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult).then((lastResult) => {
      if (keyPath) {
        try {
          setByKeyPath(obj, keyPath, lastResult);
        } catch (_) {
        }
      }
      return lastResult;
    });
  }
  update(keyOrObject, modifications) {
    if (typeof keyOrObject === "object" && !isArray(keyOrObject)) {
      const key = getByKeyPath(keyOrObject, this.schema.primKey.keyPath);
      if (key === void 0)
        return rejection(new exceptions.InvalidArgument("Given object does not contain its primary key"));
      try {
        if (typeof modifications !== "function") {
          keys(modifications).forEach((keyPath) => {
            setByKeyPath(keyOrObject, keyPath, modifications[keyPath]);
          });
        } else {
          modifications(keyOrObject, { value: keyOrObject, primKey: key });
        }
      } catch (_a) {
      }
      return this.where(":id").equals(key).modify(modifications);
    } else {
      return this.where(":id").equals(keyOrObject).modify(modifications);
    }
  }
  put(obj, key) {
    const { auto, keyPath } = this.schema.primKey;
    let objToAdd = obj;
    if (keyPath && auto) {
      objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);
    }
    return this._trans("readwrite", (trans) => this.core.mutate({ trans, type: "put", values: [objToAdd], keys: key != null ? [key] : null })).then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult).then((lastResult) => {
      if (keyPath) {
        try {
          setByKeyPath(obj, keyPath, lastResult);
        } catch (_) {
        }
      }
      return lastResult;
    });
  }
  delete(key) {
    return this._trans("readwrite", (trans) => this.core.mutate({ trans, type: "delete", keys: [key] })).then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : void 0);
  }
  clear() {
    return this._trans("readwrite", (trans) => this.core.mutate({ trans, type: "deleteRange", range: AnyRange })).then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : void 0);
  }
  bulkGet(keys2) {
    return this._trans("readonly", (trans) => {
      return this.core.getMany({
        keys: keys2,
        trans
      }).then((result) => result.map((res) => this.hook.reading.fire(res)));
    });
  }
  bulkAdd(objects, keysOrOptions, options) {
    const keys2 = Array.isArray(keysOrOptions) ? keysOrOptions : void 0;
    options = options || (keys2 ? void 0 : keysOrOptions);
    const wantResults = options ? options.allKeys : void 0;
    return this._trans("readwrite", (trans) => {
      const { auto, keyPath } = this.schema.primKey;
      if (keyPath && keys2)
        throw new exceptions.InvalidArgument("bulkAdd(): keys argument invalid on tables with inbound keys");
      if (keys2 && keys2.length !== objects.length)
        throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length");
      const numObjects = objects.length;
      let objectsToAdd = keyPath && auto ? objects.map(workaroundForUndefinedPrimKey(keyPath)) : objects;
      return this.core.mutate({ trans, type: "add", keys: keys2, values: objectsToAdd, wantResults }).then(({ numFailures, results, lastResult, failures }) => {
        const result = wantResults ? results : lastResult;
        if (numFailures === 0)
          return result;
        throw new BulkError(`${this.name}.bulkAdd(): ${numFailures} of ${numObjects} operations failed`, failures);
      });
    });
  }
  bulkPut(objects, keysOrOptions, options) {
    const keys2 = Array.isArray(keysOrOptions) ? keysOrOptions : void 0;
    options = options || (keys2 ? void 0 : keysOrOptions);
    const wantResults = options ? options.allKeys : void 0;
    return this._trans("readwrite", (trans) => {
      const { auto, keyPath } = this.schema.primKey;
      if (keyPath && keys2)
        throw new exceptions.InvalidArgument("bulkPut(): keys argument invalid on tables with inbound keys");
      if (keys2 && keys2.length !== objects.length)
        throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length");
      const numObjects = objects.length;
      let objectsToPut = keyPath && auto ? objects.map(workaroundForUndefinedPrimKey(keyPath)) : objects;
      return this.core.mutate({ trans, type: "put", keys: keys2, values: objectsToPut, wantResults }).then(({ numFailures, results, lastResult, failures }) => {
        const result = wantResults ? results : lastResult;
        if (numFailures === 0)
          return result;
        throw new BulkError(`${this.name}.bulkPut(): ${numFailures} of ${numObjects} operations failed`, failures);
      });
    });
  }
  bulkDelete(keys2) {
    const numKeys = keys2.length;
    return this._trans("readwrite", (trans) => {
      return this.core.mutate({ trans, type: "delete", keys: keys2 });
    }).then(({ numFailures, lastResult, failures }) => {
      if (numFailures === 0)
        return lastResult;
      throw new BulkError(`${this.name}.bulkDelete(): ${numFailures} of ${numKeys} operations failed`, failures);
    });
  }
};
function Events(ctx) {
  var evs = {};
  var rv = function(eventName, subscriber) {
    if (subscriber) {
      var i2 = arguments.length, args = new Array(i2 - 1);
      while (--i2)
        args[i2 - 1] = arguments[i2];
      evs[eventName].subscribe.apply(null, args);
      return ctx;
    } else if (typeof eventName === "string") {
      return evs[eventName];
    }
  };
  rv.addEventType = add;
  for (var i = 1, l = arguments.length; i < l; ++i) {
    add(arguments[i]);
  }
  return rv;
  function add(eventName, chainFunction, defaultFunction) {
    if (typeof eventName === "object")
      return addConfiguredEvents(eventName);
    if (!chainFunction)
      chainFunction = reverseStoppableEventChain;
    if (!defaultFunction)
      defaultFunction = nop;
    var context = {
      subscribers: [],
      fire: defaultFunction,
      subscribe: function(cb) {
        if (context.subscribers.indexOf(cb) === -1) {
          context.subscribers.push(cb);
          context.fire = chainFunction(context.fire, cb);
        }
      },
      unsubscribe: function(cb) {
        context.subscribers = context.subscribers.filter(function(fn) {
          return fn !== cb;
        });
        context.fire = context.subscribers.reduce(chainFunction, defaultFunction);
      }
    };
    evs[eventName] = rv[eventName] = context;
    return context;
  }
  function addConfiguredEvents(cfg) {
    keys(cfg).forEach(function(eventName) {
      var args = cfg[eventName];
      if (isArray(args)) {
        add(eventName, cfg[eventName][0], cfg[eventName][1]);
      } else if (args === "asap") {
        var context = add(eventName, mirror, function fire() {
          var i2 = arguments.length, args2 = new Array(i2);
          while (i2--)
            args2[i2] = arguments[i2];
          context.subscribers.forEach(function(fn) {
            asap$1(function fireEvent() {
              fn.apply(null, args2);
            });
          });
        });
      } else
        throw new exceptions.InvalidArgument("Invalid event config");
    });
  }
}
function makeClassConstructor(prototype, constructor) {
  derive(constructor).from({ prototype });
  return constructor;
}
function createTableConstructor(db) {
  return makeClassConstructor(Table.prototype, function Table2(name, tableSchema, trans) {
    this.db = db;
    this._tx = trans;
    this.name = name;
    this.schema = tableSchema;
    this.hook = db._allTables[name] ? db._allTables[name].hook : Events(null, {
      "creating": [hookCreatingChain, nop],
      "reading": [pureFunctionChain, mirror],
      "updating": [hookUpdatingChain, nop],
      "deleting": [hookDeletingChain, nop]
    });
  });
}
function isPlainKeyRange(ctx, ignoreLimitFilter) {
  return !(ctx.filter || ctx.algorithm || ctx.or) && (ignoreLimitFilter ? ctx.justLimit : !ctx.replayFilter);
}
function addFilter(ctx, fn) {
  ctx.filter = combine(ctx.filter, fn);
}
function addReplayFilter(ctx, factory, isLimitFilter) {
  var curr = ctx.replayFilter;
  ctx.replayFilter = curr ? () => combine(curr(), factory()) : factory;
  ctx.justLimit = isLimitFilter && !curr;
}
function addMatchFilter(ctx, fn) {
  ctx.isMatch = combine(ctx.isMatch, fn);
}
function getIndexOrStore(ctx, coreSchema) {
  if (ctx.isPrimKey)
    return coreSchema.primaryKey;
  const index = coreSchema.getIndexByKeyPath(ctx.index);
  if (!index)
    throw new exceptions.Schema("KeyPath " + ctx.index + " on object store " + coreSchema.name + " is not indexed");
  return index;
}
function openCursor(ctx, coreTable, trans) {
  const index = getIndexOrStore(ctx, coreTable.schema);
  return coreTable.openCursor({
    trans,
    values: !ctx.keysOnly,
    reverse: ctx.dir === "prev",
    unique: !!ctx.unique,
    query: {
      index,
      range: ctx.range
    }
  });
}
function iter(ctx, fn, coreTrans, coreTable) {
  const filter = ctx.replayFilter ? combine(ctx.filter, ctx.replayFilter()) : ctx.filter;
  if (!ctx.or) {
    return iterate(openCursor(ctx, coreTable, coreTrans), combine(ctx.algorithm, filter), fn, !ctx.keysOnly && ctx.valueMapper);
  } else {
    const set = {};
    const union = (item, cursor, advance) => {
      if (!filter || filter(cursor, advance, (result) => cursor.stop(result), (err) => cursor.fail(err))) {
        var primaryKey = cursor.primaryKey;
        var key = "" + primaryKey;
        if (key === "[object ArrayBuffer]")
          key = "" + new Uint8Array(primaryKey);
        if (!hasOwn(set, key)) {
          set[key] = true;
          fn(item, cursor, advance);
        }
      }
    };
    return Promise.all([
      ctx.or._iterate(union, coreTrans),
      iterate(openCursor(ctx, coreTable, coreTrans), ctx.algorithm, union, !ctx.keysOnly && ctx.valueMapper)
    ]);
  }
}
function iterate(cursorPromise, filter, fn, valueMapper) {
  var mappedFn = valueMapper ? (x, c, a) => fn(valueMapper(x), c, a) : fn;
  var wrappedFn = wrap(mappedFn);
  return cursorPromise.then((cursor) => {
    if (cursor) {
      return cursor.start(() => {
        var c = () => cursor.continue();
        if (!filter || filter(cursor, (advancer) => c = advancer, (val) => {
          cursor.stop(val);
          c = nop;
        }, (e) => {
          cursor.fail(e);
          c = nop;
        }))
          wrappedFn(cursor.value, cursor, (advancer) => c = advancer);
        c();
      });
    }
  });
}
function cmp(a, b) {
  try {
    const ta = type(a);
    const tb = type(b);
    if (ta !== tb) {
      if (ta === "Array")
        return 1;
      if (tb === "Array")
        return -1;
      if (ta === "binary")
        return 1;
      if (tb === "binary")
        return -1;
      if (ta === "string")
        return 1;
      if (tb === "string")
        return -1;
      if (ta === "Date")
        return 1;
      if (tb !== "Date")
        return NaN;
      return -1;
    }
    switch (ta) {
      case "number":
      case "Date":
      case "string":
        return a > b ? 1 : a < b ? -1 : 0;
      case "binary": {
        return compareUint8Arrays(getUint8Array(a), getUint8Array(b));
      }
      case "Array":
        return compareArrays(a, b);
    }
  } catch (_a) {
  }
  return NaN;
}
function compareArrays(a, b) {
  const al = a.length;
  const bl = b.length;
  const l = al < bl ? al : bl;
  for (let i = 0; i < l; ++i) {
    const res = cmp(a[i], b[i]);
    if (res !== 0)
      return res;
  }
  return al === bl ? 0 : al < bl ? -1 : 1;
}
function compareUint8Arrays(a, b) {
  const al = a.length;
  const bl = b.length;
  const l = al < bl ? al : bl;
  for (let i = 0; i < l; ++i) {
    if (a[i] !== b[i])
      return a[i] < b[i] ? -1 : 1;
  }
  return al === bl ? 0 : al < bl ? -1 : 1;
}
function type(x) {
  const t = typeof x;
  if (t !== "object")
    return t;
  if (ArrayBuffer.isView(x))
    return "binary";
  const tsTag = toStringTag(x);
  return tsTag === "ArrayBuffer" ? "binary" : tsTag;
}
function getUint8Array(a) {
  if (a instanceof Uint8Array)
    return a;
  if (ArrayBuffer.isView(a))
    return new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
  return new Uint8Array(a);
}
var Collection = class {
  _read(fn, cb) {
    var ctx = this._ctx;
    return ctx.error ? ctx.table._trans(null, rejection.bind(null, ctx.error)) : ctx.table._trans("readonly", fn).then(cb);
  }
  _write(fn) {
    var ctx = this._ctx;
    return ctx.error ? ctx.table._trans(null, rejection.bind(null, ctx.error)) : ctx.table._trans("readwrite", fn, "locked");
  }
  _addAlgorithm(fn) {
    var ctx = this._ctx;
    ctx.algorithm = combine(ctx.algorithm, fn);
  }
  _iterate(fn, coreTrans) {
    return iter(this._ctx, fn, coreTrans, this._ctx.table.core);
  }
  clone(props2) {
    var rv = Object.create(this.constructor.prototype), ctx = Object.create(this._ctx);
    if (props2)
      extend(ctx, props2);
    rv._ctx = ctx;
    return rv;
  }
  raw() {
    this._ctx.valueMapper = null;
    return this;
  }
  each(fn) {
    var ctx = this._ctx;
    return this._read((trans) => iter(ctx, fn, trans, ctx.table.core));
  }
  count(cb) {
    return this._read((trans) => {
      const ctx = this._ctx;
      const coreTable = ctx.table.core;
      if (isPlainKeyRange(ctx, true)) {
        return coreTable.count({
          trans,
          query: {
            index: getIndexOrStore(ctx, coreTable.schema),
            range: ctx.range
          }
        }).then((count2) => Math.min(count2, ctx.limit));
      } else {
        var count = 0;
        return iter(ctx, () => {
          ++count;
          return false;
        }, trans, coreTable).then(() => count);
      }
    }).then(cb);
  }
  sortBy(keyPath, cb) {
    const parts = keyPath.split(".").reverse(), lastPart = parts[0], lastIndex = parts.length - 1;
    function getval(obj, i) {
      if (i)
        return getval(obj[parts[i]], i - 1);
      return obj[lastPart];
    }
    var order = this._ctx.dir === "next" ? 1 : -1;
    function sorter(a, b) {
      var aVal = getval(a, lastIndex), bVal = getval(b, lastIndex);
      return aVal < bVal ? -order : aVal > bVal ? order : 0;
    }
    return this.toArray(function(a) {
      return a.sort(sorter);
    }).then(cb);
  }
  toArray(cb) {
    return this._read((trans) => {
      var ctx = this._ctx;
      if (ctx.dir === "next" && isPlainKeyRange(ctx, true) && ctx.limit > 0) {
        const { valueMapper } = ctx;
        const index = getIndexOrStore(ctx, ctx.table.core.schema);
        return ctx.table.core.query({
          trans,
          limit: ctx.limit,
          values: true,
          query: {
            index,
            range: ctx.range
          }
        }).then(({ result }) => valueMapper ? result.map(valueMapper) : result);
      } else {
        const a = [];
        return iter(ctx, (item) => a.push(item), trans, ctx.table.core).then(() => a);
      }
    }, cb);
  }
  offset(offset) {
    var ctx = this._ctx;
    if (offset <= 0)
      return this;
    ctx.offset += offset;
    if (isPlainKeyRange(ctx)) {
      addReplayFilter(ctx, () => {
        var offsetLeft = offset;
        return (cursor, advance) => {
          if (offsetLeft === 0)
            return true;
          if (offsetLeft === 1) {
            --offsetLeft;
            return false;
          }
          advance(() => {
            cursor.advance(offsetLeft);
            offsetLeft = 0;
          });
          return false;
        };
      });
    } else {
      addReplayFilter(ctx, () => {
        var offsetLeft = offset;
        return () => --offsetLeft < 0;
      });
    }
    return this;
  }
  limit(numRows) {
    this._ctx.limit = Math.min(this._ctx.limit, numRows);
    addReplayFilter(this._ctx, () => {
      var rowsLeft = numRows;
      return function(cursor, advance, resolve) {
        if (--rowsLeft <= 0)
          advance(resolve);
        return rowsLeft >= 0;
      };
    }, true);
    return this;
  }
  until(filterFunction, bIncludeStopEntry) {
    addFilter(this._ctx, function(cursor, advance, resolve) {
      if (filterFunction(cursor.value)) {
        advance(resolve);
        return bIncludeStopEntry;
      } else {
        return true;
      }
    });
    return this;
  }
  first(cb) {
    return this.limit(1).toArray(function(a) {
      return a[0];
    }).then(cb);
  }
  last(cb) {
    return this.reverse().first(cb);
  }
  filter(filterFunction) {
    addFilter(this._ctx, function(cursor) {
      return filterFunction(cursor.value);
    });
    addMatchFilter(this._ctx, filterFunction);
    return this;
  }
  and(filter) {
    return this.filter(filter);
  }
  or(indexName) {
    return new this.db.WhereClause(this._ctx.table, indexName, this);
  }
  reverse() {
    this._ctx.dir = this._ctx.dir === "prev" ? "next" : "prev";
    if (this._ondirectionchange)
      this._ondirectionchange(this._ctx.dir);
    return this;
  }
  desc() {
    return this.reverse();
  }
  eachKey(cb) {
    var ctx = this._ctx;
    ctx.keysOnly = !ctx.isMatch;
    return this.each(function(val, cursor) {
      cb(cursor.key, cursor);
    });
  }
  eachUniqueKey(cb) {
    this._ctx.unique = "unique";
    return this.eachKey(cb);
  }
  eachPrimaryKey(cb) {
    var ctx = this._ctx;
    ctx.keysOnly = !ctx.isMatch;
    return this.each(function(val, cursor) {
      cb(cursor.primaryKey, cursor);
    });
  }
  keys(cb) {
    var ctx = this._ctx;
    ctx.keysOnly = !ctx.isMatch;
    var a = [];
    return this.each(function(item, cursor) {
      a.push(cursor.key);
    }).then(function() {
      return a;
    }).then(cb);
  }
  primaryKeys(cb) {
    var ctx = this._ctx;
    if (ctx.dir === "next" && isPlainKeyRange(ctx, true) && ctx.limit > 0) {
      return this._read((trans) => {
        var index = getIndexOrStore(ctx, ctx.table.core.schema);
        return ctx.table.core.query({
          trans,
          values: false,
          limit: ctx.limit,
          query: {
            index,
            range: ctx.range
          }
        });
      }).then(({ result }) => result).then(cb);
    }
    ctx.keysOnly = !ctx.isMatch;
    var a = [];
    return this.each(function(item, cursor) {
      a.push(cursor.primaryKey);
    }).then(function() {
      return a;
    }).then(cb);
  }
  uniqueKeys(cb) {
    this._ctx.unique = "unique";
    return this.keys(cb);
  }
  firstKey(cb) {
    return this.limit(1).keys(function(a) {
      return a[0];
    }).then(cb);
  }
  lastKey(cb) {
    return this.reverse().firstKey(cb);
  }
  distinct() {
    var ctx = this._ctx, idx = ctx.index && ctx.table.schema.idxByName[ctx.index];
    if (!idx || !idx.multi)
      return this;
    var set = {};
    addFilter(this._ctx, function(cursor) {
      var strKey = cursor.primaryKey.toString();
      var found = hasOwn(set, strKey);
      set[strKey] = true;
      return !found;
    });
    return this;
  }
  modify(changes) {
    var ctx = this._ctx;
    return this._write((trans) => {
      var modifyer;
      if (typeof changes === "function") {
        modifyer = changes;
      } else {
        var keyPaths = keys(changes);
        var numKeys = keyPaths.length;
        modifyer = function(item) {
          var anythingModified = false;
          for (var i = 0; i < numKeys; ++i) {
            var keyPath = keyPaths[i], val = changes[keyPath];
            if (getByKeyPath(item, keyPath) !== val) {
              setByKeyPath(item, keyPath, val);
              anythingModified = true;
            }
          }
          return anythingModified;
        };
      }
      const coreTable = ctx.table.core;
      const { outbound, extractKey } = coreTable.schema.primaryKey;
      const limit = this.db._options.modifyChunkSize || 200;
      const totalFailures = [];
      let successCount = 0;
      const failedKeys = [];
      const applyMutateResult = (expectedCount, res) => {
        const { failures, numFailures } = res;
        successCount += expectedCount - numFailures;
        for (let pos of keys(failures)) {
          totalFailures.push(failures[pos]);
        }
      };
      return this.clone().primaryKeys().then((keys2) => {
        const nextChunk = (offset) => {
          const count = Math.min(limit, keys2.length - offset);
          return coreTable.getMany({
            trans,
            keys: keys2.slice(offset, offset + count),
            cache: "immutable"
          }).then((values) => {
            const addValues = [];
            const putValues = [];
            const putKeys = outbound ? [] : null;
            const deleteKeys = [];
            for (let i = 0; i < count; ++i) {
              const origValue = values[i];
              const ctx2 = {
                value: deepClone(origValue),
                primKey: keys2[offset + i]
              };
              if (modifyer.call(ctx2, ctx2.value, ctx2) !== false) {
                if (ctx2.value == null) {
                  deleteKeys.push(keys2[offset + i]);
                } else if (!outbound && cmp(extractKey(origValue), extractKey(ctx2.value)) !== 0) {
                  deleteKeys.push(keys2[offset + i]);
                  addValues.push(ctx2.value);
                } else {
                  putValues.push(ctx2.value);
                  if (outbound)
                    putKeys.push(keys2[offset + i]);
                }
              }
            }
            const criteria = isPlainKeyRange(ctx) && ctx.limit === Infinity && (typeof changes !== "function" || changes === deleteCallback) && {
              index: ctx.index,
              range: ctx.range
            };
            return Promise.resolve(addValues.length > 0 && coreTable.mutate({ trans, type: "add", values: addValues }).then((res) => {
              for (let pos in res.failures) {
                deleteKeys.splice(parseInt(pos), 1);
              }
              applyMutateResult(addValues.length, res);
            })).then(() => (putValues.length > 0 || criteria && typeof changes === "object") && coreTable.mutate({
              trans,
              type: "put",
              keys: putKeys,
              values: putValues,
              criteria,
              changeSpec: typeof changes !== "function" && changes
            }).then((res) => applyMutateResult(putValues.length, res))).then(() => (deleteKeys.length > 0 || criteria && changes === deleteCallback) && coreTable.mutate({
              trans,
              type: "delete",
              keys: deleteKeys,
              criteria
            }).then((res) => applyMutateResult(deleteKeys.length, res))).then(() => {
              return keys2.length > offset + count && nextChunk(offset + limit);
            });
          });
        };
        return nextChunk(0).then(() => {
          if (totalFailures.length > 0)
            throw new ModifyError("Error modifying one or more objects", totalFailures, successCount, failedKeys);
          return keys2.length;
        });
      });
    });
  }
  delete() {
    var ctx = this._ctx, range = ctx.range;
    if (isPlainKeyRange(ctx) && (ctx.isPrimKey && !hangsOnDeleteLargeKeyRange || range.type === 3)) {
      return this._write((trans) => {
        const { primaryKey } = ctx.table.core.schema;
        const coreRange = range;
        return ctx.table.core.count({ trans, query: { index: primaryKey, range: coreRange } }).then((count) => {
          return ctx.table.core.mutate({ trans, type: "deleteRange", range: coreRange }).then(({ failures, lastResult, results, numFailures }) => {
            if (numFailures)
              throw new ModifyError("Could not delete some values", Object.keys(failures).map((pos) => failures[pos]), count - numFailures);
            return count - numFailures;
          });
        });
      });
    }
    return this.modify(deleteCallback);
  }
};
var deleteCallback = (value, ctx) => ctx.value = null;
function createCollectionConstructor(db) {
  return makeClassConstructor(Collection.prototype, function Collection2(whereClause, keyRangeGenerator) {
    this.db = db;
    let keyRange = AnyRange, error = null;
    if (keyRangeGenerator)
      try {
        keyRange = keyRangeGenerator();
      } catch (ex) {
        error = ex;
      }
    const whereCtx = whereClause._ctx;
    const table = whereCtx.table;
    const readingHook = table.hook.reading.fire;
    this._ctx = {
      table,
      index: whereCtx.index,
      isPrimKey: !whereCtx.index || table.schema.primKey.keyPath && whereCtx.index === table.schema.primKey.name,
      range: keyRange,
      keysOnly: false,
      dir: "next",
      unique: "",
      algorithm: null,
      filter: null,
      replayFilter: null,
      justLimit: true,
      isMatch: null,
      offset: 0,
      limit: Infinity,
      error,
      or: whereCtx.or,
      valueMapper: readingHook !== mirror ? readingHook : null
    };
  });
}
function simpleCompare(a, b) {
  return a < b ? -1 : a === b ? 0 : 1;
}
function simpleCompareReverse(a, b) {
  return a > b ? -1 : a === b ? 0 : 1;
}
function fail(collectionOrWhereClause, err, T) {
  var collection = collectionOrWhereClause instanceof WhereClause ? new collectionOrWhereClause.Collection(collectionOrWhereClause) : collectionOrWhereClause;
  collection._ctx.error = T ? new T(err) : new TypeError(err);
  return collection;
}
function emptyCollection(whereClause) {
  return new whereClause.Collection(whereClause, () => rangeEqual("")).limit(0);
}
function upperFactory(dir) {
  return dir === "next" ? (s) => s.toUpperCase() : (s) => s.toLowerCase();
}
function lowerFactory(dir) {
  return dir === "next" ? (s) => s.toLowerCase() : (s) => s.toUpperCase();
}
function nextCasing(key, lowerKey, upperNeedle, lowerNeedle, cmp2, dir) {
  var length = Math.min(key.length, lowerNeedle.length);
  var llp = -1;
  for (var i = 0; i < length; ++i) {
    var lwrKeyChar = lowerKey[i];
    if (lwrKeyChar !== lowerNeedle[i]) {
      if (cmp2(key[i], upperNeedle[i]) < 0)
        return key.substr(0, i) + upperNeedle[i] + upperNeedle.substr(i + 1);
      if (cmp2(key[i], lowerNeedle[i]) < 0)
        return key.substr(0, i) + lowerNeedle[i] + upperNeedle.substr(i + 1);
      if (llp >= 0)
        return key.substr(0, llp) + lowerKey[llp] + upperNeedle.substr(llp + 1);
      return null;
    }
    if (cmp2(key[i], lwrKeyChar) < 0)
      llp = i;
  }
  if (length < lowerNeedle.length && dir === "next")
    return key + upperNeedle.substr(key.length);
  if (length < key.length && dir === "prev")
    return key.substr(0, upperNeedle.length);
  return llp < 0 ? null : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1);
}
function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix) {
  var upper, lower, compare, upperNeedles, lowerNeedles, direction, nextKeySuffix, needlesLen = needles.length;
  if (!needles.every((s) => typeof s === "string")) {
    return fail(whereClause, STRING_EXPECTED);
  }
  function initDirection(dir) {
    upper = upperFactory(dir);
    lower = lowerFactory(dir);
    compare = dir === "next" ? simpleCompare : simpleCompareReverse;
    var needleBounds = needles.map(function(needle) {
      return { lower: lower(needle), upper: upper(needle) };
    }).sort(function(a, b) {
      return compare(a.lower, b.lower);
    });
    upperNeedles = needleBounds.map(function(nb) {
      return nb.upper;
    });
    lowerNeedles = needleBounds.map(function(nb) {
      return nb.lower;
    });
    direction = dir;
    nextKeySuffix = dir === "next" ? "" : suffix;
  }
  initDirection("next");
  var c = new whereClause.Collection(whereClause, () => createRange(upperNeedles[0], lowerNeedles[needlesLen - 1] + suffix));
  c._ondirectionchange = function(direction2) {
    initDirection(direction2);
  };
  var firstPossibleNeedle = 0;
  c._addAlgorithm(function(cursor, advance, resolve) {
    var key = cursor.key;
    if (typeof key !== "string")
      return false;
    var lowerKey = lower(key);
    if (match(lowerKey, lowerNeedles, firstPossibleNeedle)) {
      return true;
    } else {
      var lowestPossibleCasing = null;
      for (var i = firstPossibleNeedle; i < needlesLen; ++i) {
        var casing = nextCasing(key, lowerKey, upperNeedles[i], lowerNeedles[i], compare, direction);
        if (casing === null && lowestPossibleCasing === null)
          firstPossibleNeedle = i + 1;
        else if (lowestPossibleCasing === null || compare(lowestPossibleCasing, casing) > 0) {
          lowestPossibleCasing = casing;
        }
      }
      if (lowestPossibleCasing !== null) {
        advance(function() {
          cursor.continue(lowestPossibleCasing + nextKeySuffix);
        });
      } else {
        advance(resolve);
      }
      return false;
    }
  });
  return c;
}
function createRange(lower, upper, lowerOpen, upperOpen) {
  return {
    type: 2,
    lower,
    upper,
    lowerOpen,
    upperOpen
  };
}
function rangeEqual(value) {
  return {
    type: 1,
    lower: value,
    upper: value
  };
}
var WhereClause = class {
  get Collection() {
    return this._ctx.table.db.Collection;
  }
  between(lower, upper, includeLower, includeUpper) {
    includeLower = includeLower !== false;
    includeUpper = includeUpper === true;
    try {
      if (this._cmp(lower, upper) > 0 || this._cmp(lower, upper) === 0 && (includeLower || includeUpper) && !(includeLower && includeUpper))
        return emptyCollection(this);
      return new this.Collection(this, () => createRange(lower, upper, !includeLower, !includeUpper));
    } catch (e) {
      return fail(this, INVALID_KEY_ARGUMENT);
    }
  }
  equals(value) {
    if (value == null)
      return fail(this, INVALID_KEY_ARGUMENT);
    return new this.Collection(this, () => rangeEqual(value));
  }
  above(value) {
    if (value == null)
      return fail(this, INVALID_KEY_ARGUMENT);
    return new this.Collection(this, () => createRange(value, void 0, true));
  }
  aboveOrEqual(value) {
    if (value == null)
      return fail(this, INVALID_KEY_ARGUMENT);
    return new this.Collection(this, () => createRange(value, void 0, false));
  }
  below(value) {
    if (value == null)
      return fail(this, INVALID_KEY_ARGUMENT);
    return new this.Collection(this, () => createRange(void 0, value, false, true));
  }
  belowOrEqual(value) {
    if (value == null)
      return fail(this, INVALID_KEY_ARGUMENT);
    return new this.Collection(this, () => createRange(void 0, value));
  }
  startsWith(str) {
    if (typeof str !== "string")
      return fail(this, STRING_EXPECTED);
    return this.between(str, str + maxString, true, true);
  }
  startsWithIgnoreCase(str) {
    if (str === "")
      return this.startsWith(str);
    return addIgnoreCaseAlgorithm(this, (x, a) => x.indexOf(a[0]) === 0, [str], maxString);
  }
  equalsIgnoreCase(str) {
    return addIgnoreCaseAlgorithm(this, (x, a) => x === a[0], [str], "");
  }
  anyOfIgnoreCase() {
    var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
    if (set.length === 0)
      return emptyCollection(this);
    return addIgnoreCaseAlgorithm(this, (x, a) => a.indexOf(x) !== -1, set, "");
  }
  startsWithAnyOfIgnoreCase() {
    var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
    if (set.length === 0)
      return emptyCollection(this);
    return addIgnoreCaseAlgorithm(this, (x, a) => a.some((n) => x.indexOf(n) === 0), set, maxString);
  }
  anyOf() {
    const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
    let compare = this._cmp;
    try {
      set.sort(compare);
    } catch (e) {
      return fail(this, INVALID_KEY_ARGUMENT);
    }
    if (set.length === 0)
      return emptyCollection(this);
    const c = new this.Collection(this, () => createRange(set[0], set[set.length - 1]));
    c._ondirectionchange = (direction) => {
      compare = direction === "next" ? this._ascending : this._descending;
      set.sort(compare);
    };
    let i = 0;
    c._addAlgorithm((cursor, advance, resolve) => {
      const key = cursor.key;
      while (compare(key, set[i]) > 0) {
        ++i;
        if (i === set.length) {
          advance(resolve);
          return false;
        }
      }
      if (compare(key, set[i]) === 0) {
        return true;
      } else {
        advance(() => {
          cursor.continue(set[i]);
        });
        return false;
      }
    });
    return c;
  }
  notEqual(value) {
    return this.inAnyRange([[minKey, value], [value, this.db._maxKey]], { includeLowers: false, includeUppers: false });
  }
  noneOf() {
    const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
    if (set.length === 0)
      return new this.Collection(this);
    try {
      set.sort(this._ascending);
    } catch (e) {
      return fail(this, INVALID_KEY_ARGUMENT);
    }
    const ranges = set.reduce((res, val) => res ? res.concat([[res[res.length - 1][1], val]]) : [[minKey, val]], null);
    ranges.push([set[set.length - 1], this.db._maxKey]);
    return this.inAnyRange(ranges, { includeLowers: false, includeUppers: false });
  }
  inAnyRange(ranges, options) {
    const cmp2 = this._cmp, ascending = this._ascending, descending = this._descending, min = this._min, max = this._max;
    if (ranges.length === 0)
      return emptyCollection(this);
    if (!ranges.every((range) => range[0] !== void 0 && range[1] !== void 0 && ascending(range[0], range[1]) <= 0)) {
      return fail(this, "First argument to inAnyRange() must be an Array of two-value Arrays [lower,upper] where upper must not be lower than lower", exceptions.InvalidArgument);
    }
    const includeLowers = !options || options.includeLowers !== false;
    const includeUppers = options && options.includeUppers === true;
    function addRange2(ranges2, newRange) {
      let i = 0, l = ranges2.length;
      for (; i < l; ++i) {
        const range = ranges2[i];
        if (cmp2(newRange[0], range[1]) < 0 && cmp2(newRange[1], range[0]) > 0) {
          range[0] = min(range[0], newRange[0]);
          range[1] = max(range[1], newRange[1]);
          break;
        }
      }
      if (i === l)
        ranges2.push(newRange);
      return ranges2;
    }
    let sortDirection = ascending;
    function rangeSorter(a, b) {
      return sortDirection(a[0], b[0]);
    }
    let set;
    try {
      set = ranges.reduce(addRange2, []);
      set.sort(rangeSorter);
    } catch (ex) {
      return fail(this, INVALID_KEY_ARGUMENT);
    }
    let rangePos = 0;
    const keyIsBeyondCurrentEntry = includeUppers ? (key) => ascending(key, set[rangePos][1]) > 0 : (key) => ascending(key, set[rangePos][1]) >= 0;
    const keyIsBeforeCurrentEntry = includeLowers ? (key) => descending(key, set[rangePos][0]) > 0 : (key) => descending(key, set[rangePos][0]) >= 0;
    function keyWithinCurrentRange(key) {
      return !keyIsBeyondCurrentEntry(key) && !keyIsBeforeCurrentEntry(key);
    }
    let checkKey = keyIsBeyondCurrentEntry;
    const c = new this.Collection(this, () => createRange(set[0][0], set[set.length - 1][1], !includeLowers, !includeUppers));
    c._ondirectionchange = (direction) => {
      if (direction === "next") {
        checkKey = keyIsBeyondCurrentEntry;
        sortDirection = ascending;
      } else {
        checkKey = keyIsBeforeCurrentEntry;
        sortDirection = descending;
      }
      set.sort(rangeSorter);
    };
    c._addAlgorithm((cursor, advance, resolve) => {
      var key = cursor.key;
      while (checkKey(key)) {
        ++rangePos;
        if (rangePos === set.length) {
          advance(resolve);
          return false;
        }
      }
      if (keyWithinCurrentRange(key)) {
        return true;
      } else if (this._cmp(key, set[rangePos][1]) === 0 || this._cmp(key, set[rangePos][0]) === 0) {
        return false;
      } else {
        advance(() => {
          if (sortDirection === ascending)
            cursor.continue(set[rangePos][0]);
          else
            cursor.continue(set[rangePos][1]);
        });
        return false;
      }
    });
    return c;
  }
  startsWithAnyOf() {
    const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
    if (!set.every((s) => typeof s === "string")) {
      return fail(this, "startsWithAnyOf() only works with strings");
    }
    if (set.length === 0)
      return emptyCollection(this);
    return this.inAnyRange(set.map((str) => [str, str + maxString]));
  }
};
function createWhereClauseConstructor(db) {
  return makeClassConstructor(WhereClause.prototype, function WhereClause2(table, index, orCollection) {
    this.db = db;
    this._ctx = {
      table,
      index: index === ":id" ? null : index,
      or: orCollection
    };
    const indexedDB2 = db._deps.indexedDB;
    if (!indexedDB2)
      throw new exceptions.MissingAPI();
    this._cmp = this._ascending = indexedDB2.cmp.bind(indexedDB2);
    this._descending = (a, b) => indexedDB2.cmp(b, a);
    this._max = (a, b) => indexedDB2.cmp(a, b) > 0 ? a : b;
    this._min = (a, b) => indexedDB2.cmp(a, b) < 0 ? a : b;
    this._IDBKeyRange = db._deps.IDBKeyRange;
  });
}
function eventRejectHandler(reject) {
  return wrap(function(event) {
    preventDefault(event);
    reject(event.target.error);
    return false;
  });
}
function preventDefault(event) {
  if (event.stopPropagation)
    event.stopPropagation();
  if (event.preventDefault)
    event.preventDefault();
}
var DEXIE_STORAGE_MUTATED_EVENT_NAME = "storagemutated";
var STORAGE_MUTATED_DOM_EVENT_NAME = "x-storagemutated-1";
var globalEvents = Events(null, DEXIE_STORAGE_MUTATED_EVENT_NAME);
var Transaction = class {
  _lock() {
    assert(!PSD.global);
    ++this._reculock;
    if (this._reculock === 1 && !PSD.global)
      PSD.lockOwnerFor = this;
    return this;
  }
  _unlock() {
    assert(!PSD.global);
    if (--this._reculock === 0) {
      if (!PSD.global)
        PSD.lockOwnerFor = null;
      while (this._blockedFuncs.length > 0 && !this._locked()) {
        var fnAndPSD = this._blockedFuncs.shift();
        try {
          usePSD(fnAndPSD[1], fnAndPSD[0]);
        } catch (e) {
        }
      }
    }
    return this;
  }
  _locked() {
    return this._reculock && PSD.lockOwnerFor !== this;
  }
  create(idbtrans) {
    if (!this.mode)
      return this;
    const idbdb = this.db.idbdb;
    const dbOpenError = this.db._state.dbOpenError;
    assert(!this.idbtrans);
    if (!idbtrans && !idbdb) {
      switch (dbOpenError && dbOpenError.name) {
        case "DatabaseClosedError":
          throw new exceptions.DatabaseClosed(dbOpenError);
        case "MissingAPIError":
          throw new exceptions.MissingAPI(dbOpenError.message, dbOpenError);
        default:
          throw new exceptions.OpenFailed(dbOpenError);
      }
    }
    if (!this.active)
      throw new exceptions.TransactionInactive();
    assert(this._completion._state === null);
    idbtrans = this.idbtrans = idbtrans || (this.db.core ? this.db.core.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }) : idbdb.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }));
    idbtrans.onerror = wrap((ev) => {
      preventDefault(ev);
      this._reject(idbtrans.error);
    });
    idbtrans.onabort = wrap((ev) => {
      preventDefault(ev);
      this.active && this._reject(new exceptions.Abort(idbtrans.error));
      this.active = false;
      this.on("abort").fire(ev);
    });
    idbtrans.oncomplete = wrap(() => {
      this.active = false;
      this._resolve();
      if ("mutatedParts" in idbtrans) {
        globalEvents.storagemutated.fire(idbtrans["mutatedParts"]);
      }
    });
    return this;
  }
  _promise(mode, fn, bWriteLock) {
    if (mode === "readwrite" && this.mode !== "readwrite")
      return rejection(new exceptions.ReadOnly("Transaction is readonly"));
    if (!this.active)
      return rejection(new exceptions.TransactionInactive());
    if (this._locked()) {
      return new DexiePromise((resolve, reject) => {
        this._blockedFuncs.push([() => {
          this._promise(mode, fn, bWriteLock).then(resolve, reject);
        }, PSD]);
      });
    } else if (bWriteLock) {
      return newScope(() => {
        var p2 = new DexiePromise((resolve, reject) => {
          this._lock();
          const rv = fn(resolve, reject, this);
          if (rv && rv.then)
            rv.then(resolve, reject);
        });
        p2.finally(() => this._unlock());
        p2._lib = true;
        return p2;
      });
    } else {
      var p = new DexiePromise((resolve, reject) => {
        var rv = fn(resolve, reject, this);
        if (rv && rv.then)
          rv.then(resolve, reject);
      });
      p._lib = true;
      return p;
    }
  }
  _root() {
    return this.parent ? this.parent._root() : this;
  }
  waitFor(promiseLike) {
    var root = this._root();
    const promise = DexiePromise.resolve(promiseLike);
    if (root._waitingFor) {
      root._waitingFor = root._waitingFor.then(() => promise);
    } else {
      root._waitingFor = promise;
      root._waitingQueue = [];
      var store = root.idbtrans.objectStore(root.storeNames[0]);
      (function spin() {
        ++root._spinCount;
        while (root._waitingQueue.length)
          root._waitingQueue.shift()();
        if (root._waitingFor)
          store.get(-Infinity).onsuccess = spin;
      })();
    }
    var currentWaitPromise = root._waitingFor;
    return new DexiePromise((resolve, reject) => {
      promise.then((res) => root._waitingQueue.push(wrap(resolve.bind(null, res))), (err) => root._waitingQueue.push(wrap(reject.bind(null, err)))).finally(() => {
        if (root._waitingFor === currentWaitPromise) {
          root._waitingFor = null;
        }
      });
    });
  }
  abort() {
    if (this.active) {
      this.active = false;
      if (this.idbtrans)
        this.idbtrans.abort();
      this._reject(new exceptions.Abort());
    }
  }
  table(tableName) {
    const memoizedTables = this._memoizedTables || (this._memoizedTables = {});
    if (hasOwn(memoizedTables, tableName))
      return memoizedTables[tableName];
    const tableSchema = this.schema[tableName];
    if (!tableSchema) {
      throw new exceptions.NotFound("Table " + tableName + " not part of transaction");
    }
    const transactionBoundTable = new this.db.Table(tableName, tableSchema, this);
    transactionBoundTable.core = this.db.core.table(tableName);
    memoizedTables[tableName] = transactionBoundTable;
    return transactionBoundTable;
  }
};
function createTransactionConstructor(db) {
  return makeClassConstructor(Transaction.prototype, function Transaction2(mode, storeNames, dbschema, chromeTransactionDurability, parent) {
    this.db = db;
    this.mode = mode;
    this.storeNames = storeNames;
    this.schema = dbschema;
    this.chromeTransactionDurability = chromeTransactionDurability;
    this.idbtrans = null;
    this.on = Events(this, "complete", "error", "abort");
    this.parent = parent || null;
    this.active = true;
    this._reculock = 0;
    this._blockedFuncs = [];
    this._resolve = null;
    this._reject = null;
    this._waitingFor = null;
    this._waitingQueue = null;
    this._spinCount = 0;
    this._completion = new DexiePromise((resolve, reject) => {
      this._resolve = resolve;
      this._reject = reject;
    });
    this._completion.then(() => {
      this.active = false;
      this.on.complete.fire();
    }, (e) => {
      var wasActive = this.active;
      this.active = false;
      this.on.error.fire(e);
      this.parent ? this.parent._reject(e) : wasActive && this.idbtrans && this.idbtrans.abort();
      return rejection(e);
    });
  });
}
function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey) {
  return {
    name,
    keyPath,
    unique,
    multi,
    auto,
    compound,
    src: (unique && !isPrimKey ? "&" : "") + (multi ? "*" : "") + (auto ? "++" : "") + nameFromKeyPath(keyPath)
  };
}
function nameFromKeyPath(keyPath) {
  return typeof keyPath === "string" ? keyPath : keyPath ? "[" + [].join.call(keyPath, "+") + "]" : "";
}
function createTableSchema(name, primKey, indexes) {
  return {
    name,
    primKey,
    indexes,
    mappedClass: null,
    idxByName: arrayToObject(indexes, (index) => [index.name, index])
  };
}
function safariMultiStoreFix(storeNames) {
  return storeNames.length === 1 ? storeNames[0] : storeNames;
}
var getMaxKey = (IdbKeyRange) => {
  try {
    IdbKeyRange.only([[]]);
    getMaxKey = () => [[]];
    return [[]];
  } catch (e) {
    getMaxKey = () => maxString;
    return maxString;
  }
};
function getKeyExtractor(keyPath) {
  if (keyPath == null) {
    return () => void 0;
  } else if (typeof keyPath === "string") {
    return getSinglePathKeyExtractor(keyPath);
  } else {
    return (obj) => getByKeyPath(obj, keyPath);
  }
}
function getSinglePathKeyExtractor(keyPath) {
  const split = keyPath.split(".");
  if (split.length === 1) {
    return (obj) => obj[keyPath];
  } else {
    return (obj) => getByKeyPath(obj, keyPath);
  }
}
function arrayify(arrayLike) {
  return [].slice.call(arrayLike);
}
var _id_counter = 0;
function getKeyPathAlias(keyPath) {
  return keyPath == null ? ":id" : typeof keyPath === "string" ? keyPath : `[${keyPath.join("+")}]`;
}
function createDBCore(db, IdbKeyRange, tmpTrans) {
  function extractSchema(db2, trans) {
    const tables2 = arrayify(db2.objectStoreNames);
    return {
      schema: {
        name: db2.name,
        tables: tables2.map((table) => trans.objectStore(table)).map((store) => {
          const { keyPath, autoIncrement } = store;
          const compound = isArray(keyPath);
          const outbound = keyPath == null;
          const indexByKeyPath = {};
          const result = {
            name: store.name,
            primaryKey: {
              name: null,
              isPrimaryKey: true,
              outbound,
              compound,
              keyPath,
              autoIncrement,
              unique: true,
              extractKey: getKeyExtractor(keyPath)
            },
            indexes: arrayify(store.indexNames).map((indexName) => store.index(indexName)).map((index) => {
              const { name, unique, multiEntry, keyPath: keyPath2 } = index;
              const compound2 = isArray(keyPath2);
              const result2 = {
                name,
                compound: compound2,
                keyPath: keyPath2,
                unique,
                multiEntry,
                extractKey: getKeyExtractor(keyPath2)
              };
              indexByKeyPath[getKeyPathAlias(keyPath2)] = result2;
              return result2;
            }),
            getIndexByKeyPath: (keyPath2) => indexByKeyPath[getKeyPathAlias(keyPath2)]
          };
          indexByKeyPath[":id"] = result.primaryKey;
          if (keyPath != null) {
            indexByKeyPath[getKeyPathAlias(keyPath)] = result.primaryKey;
          }
          return result;
        })
      },
      hasGetAll: tables2.length > 0 && "getAll" in trans.objectStore(tables2[0]) && !(typeof navigator !== "undefined" && /Safari/.test(navigator.userAgent) && !/(Chrome\/|Edge\/)/.test(navigator.userAgent) && [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604)
    };
  }
  function makeIDBKeyRange(range) {
    if (range.type === 3)
      return null;
    if (range.type === 4)
      throw new Error("Cannot convert never type to IDBKeyRange");
    const { lower, upper, lowerOpen, upperOpen } = range;
    const idbRange = lower === void 0 ? upper === void 0 ? null : IdbKeyRange.upperBound(upper, !!upperOpen) : upper === void 0 ? IdbKeyRange.lowerBound(lower, !!lowerOpen) : IdbKeyRange.bound(lower, upper, !!lowerOpen, !!upperOpen);
    return idbRange;
  }
  function createDbCoreTable(tableSchema) {
    const tableName = tableSchema.name;
    function mutate({ trans, type: type2, keys: keys2, values, range }) {
      return new Promise((resolve, reject) => {
        resolve = wrap(resolve);
        const store = trans.objectStore(tableName);
        const outbound = store.keyPath == null;
        const isAddOrPut = type2 === "put" || type2 === "add";
        if (!isAddOrPut && type2 !== "delete" && type2 !== "deleteRange")
          throw new Error("Invalid operation type: " + type2);
        const { length } = keys2 || values || { length: 1 };
        if (keys2 && values && keys2.length !== values.length) {
          throw new Error("Given keys array must have same length as given values array.");
        }
        if (length === 0)
          return resolve({ numFailures: 0, failures: {}, results: [], lastResult: void 0 });
        let req;
        const reqs = [];
        const failures = [];
        let numFailures = 0;
        const errorHandler = (event) => {
          ++numFailures;
          preventDefault(event);
        };
        if (type2 === "deleteRange") {
          if (range.type === 4)
            return resolve({ numFailures, failures, results: [], lastResult: void 0 });
          if (range.type === 3)
            reqs.push(req = store.clear());
          else
            reqs.push(req = store.delete(makeIDBKeyRange(range)));
        } else {
          const [args1, args2] = isAddOrPut ? outbound ? [values, keys2] : [values, null] : [keys2, null];
          if (isAddOrPut) {
            for (let i = 0; i < length; ++i) {
              reqs.push(req = args2 && args2[i] !== void 0 ? store[type2](args1[i], args2[i]) : store[type2](args1[i]));
              req.onerror = errorHandler;
            }
          } else {
            for (let i = 0; i < length; ++i) {
              reqs.push(req = store[type2](args1[i]));
              req.onerror = errorHandler;
            }
          }
        }
        const done = (event) => {
          const lastResult = event.target.result;
          reqs.forEach((req2, i) => req2.error != null && (failures[i] = req2.error));
          resolve({
            numFailures,
            failures,
            results: type2 === "delete" ? keys2 : reqs.map((req2) => req2.result),
            lastResult
          });
        };
        req.onerror = (event) => {
          errorHandler(event);
          done(event);
        };
        req.onsuccess = done;
      });
    }
    function openCursor2({ trans, values, query: query2, reverse, unique }) {
      return new Promise((resolve, reject) => {
        resolve = wrap(resolve);
        const { index, range } = query2;
        const store = trans.objectStore(tableName);
        const source = index.isPrimaryKey ? store : store.index(index.name);
        const direction = reverse ? unique ? "prevunique" : "prev" : unique ? "nextunique" : "next";
        const req = values || !("openKeyCursor" in source) ? source.openCursor(makeIDBKeyRange(range), direction) : source.openKeyCursor(makeIDBKeyRange(range), direction);
        req.onerror = eventRejectHandler(reject);
        req.onsuccess = wrap((ev) => {
          const cursor = req.result;
          if (!cursor) {
            resolve(null);
            return;
          }
          cursor.___id = ++_id_counter;
          cursor.done = false;
          const _cursorContinue = cursor.continue.bind(cursor);
          let _cursorContinuePrimaryKey = cursor.continuePrimaryKey;
          if (_cursorContinuePrimaryKey)
            _cursorContinuePrimaryKey = _cursorContinuePrimaryKey.bind(cursor);
          const _cursorAdvance = cursor.advance.bind(cursor);
          const doThrowCursorIsNotStarted = () => {
            throw new Error("Cursor not started");
          };
          const doThrowCursorIsStopped = () => {
            throw new Error("Cursor not stopped");
          };
          cursor.trans = trans;
          cursor.stop = cursor.continue = cursor.continuePrimaryKey = cursor.advance = doThrowCursorIsNotStarted;
          cursor.fail = wrap(reject);
          cursor.next = function() {
            let gotOne = 1;
            return this.start(() => gotOne-- ? this.continue() : this.stop()).then(() => this);
          };
          cursor.start = (callback) => {
            const iterationPromise = new Promise((resolveIteration, rejectIteration) => {
              resolveIteration = wrap(resolveIteration);
              req.onerror = eventRejectHandler(rejectIteration);
              cursor.fail = rejectIteration;
              cursor.stop = (value) => {
                cursor.stop = cursor.continue = cursor.continuePrimaryKey = cursor.advance = doThrowCursorIsStopped;
                resolveIteration(value);
              };
            });
            const guardedCallback = () => {
              if (req.result) {
                try {
                  callback();
                } catch (err) {
                  cursor.fail(err);
                }
              } else {
                cursor.done = true;
                cursor.start = () => {
                  throw new Error("Cursor behind last entry");
                };
                cursor.stop();
              }
            };
            req.onsuccess = wrap((ev2) => {
              req.onsuccess = guardedCallback;
              guardedCallback();
            });
            cursor.continue = _cursorContinue;
            cursor.continuePrimaryKey = _cursorContinuePrimaryKey;
            cursor.advance = _cursorAdvance;
            guardedCallback();
            return iterationPromise;
          };
          resolve(cursor);
        }, reject);
      });
    }
    function query(hasGetAll2) {
      return (request) => {
        return new Promise((resolve, reject) => {
          resolve = wrap(resolve);
          const { trans, values, limit, query: query2 } = request;
          const nonInfinitLimit = limit === Infinity ? void 0 : limit;
          const { index, range } = query2;
          const store = trans.objectStore(tableName);
          const source = index.isPrimaryKey ? store : store.index(index.name);
          const idbKeyRange = makeIDBKeyRange(range);
          if (limit === 0)
            return resolve({ result: [] });
          if (hasGetAll2) {
            const req = values ? source.getAll(idbKeyRange, nonInfinitLimit) : source.getAllKeys(idbKeyRange, nonInfinitLimit);
            req.onsuccess = (event) => resolve({ result: event.target.result });
            req.onerror = eventRejectHandler(reject);
          } else {
            let count = 0;
            const req = values || !("openKeyCursor" in source) ? source.openCursor(idbKeyRange) : source.openKeyCursor(idbKeyRange);
            const result = [];
            req.onsuccess = (event) => {
              const cursor = req.result;
              if (!cursor)
                return resolve({ result });
              result.push(values ? cursor.value : cursor.primaryKey);
              if (++count === limit)
                return resolve({ result });
              cursor.continue();
            };
            req.onerror = eventRejectHandler(reject);
          }
        });
      };
    }
    return {
      name: tableName,
      schema: tableSchema,
      mutate,
      getMany({ trans, keys: keys2 }) {
        return new Promise((resolve, reject) => {
          resolve = wrap(resolve);
          const store = trans.objectStore(tableName);
          const length = keys2.length;
          const result = new Array(length);
          let keyCount = 0;
          let callbackCount = 0;
          let req;
          const successHandler = (event) => {
            const req2 = event.target;
            if ((result[req2._pos] = req2.result) != null)
              ;
            if (++callbackCount === keyCount)
              resolve(result);
          };
          const errorHandler = eventRejectHandler(reject);
          for (let i = 0; i < length; ++i) {
            const key = keys2[i];
            if (key != null) {
              req = store.get(keys2[i]);
              req._pos = i;
              req.onsuccess = successHandler;
              req.onerror = errorHandler;
              ++keyCount;
            }
          }
          if (keyCount === 0)
            resolve(result);
        });
      },
      get({ trans, key }) {
        return new Promise((resolve, reject) => {
          resolve = wrap(resolve);
          const store = trans.objectStore(tableName);
          const req = store.get(key);
          req.onsuccess = (event) => resolve(event.target.result);
          req.onerror = eventRejectHandler(reject);
        });
      },
      query: query(hasGetAll),
      openCursor: openCursor2,
      count({ query: query2, trans }) {
        const { index, range } = query2;
        return new Promise((resolve, reject) => {
          const store = trans.objectStore(tableName);
          const source = index.isPrimaryKey ? store : store.index(index.name);
          const idbKeyRange = makeIDBKeyRange(range);
          const req = idbKeyRange ? source.count(idbKeyRange) : source.count();
          req.onsuccess = wrap((ev) => resolve(ev.target.result));
          req.onerror = eventRejectHandler(reject);
        });
      }
    };
  }
  const { schema, hasGetAll } = extractSchema(db, tmpTrans);
  const tables = schema.tables.map((tableSchema) => createDbCoreTable(tableSchema));
  const tableMap = {};
  tables.forEach((table) => tableMap[table.name] = table);
  return {
    stack: "dbcore",
    transaction: db.transaction.bind(db),
    table(name) {
      const result = tableMap[name];
      if (!result)
        throw new Error(`Table '${name}' not found`);
      return tableMap[name];
    },
    MIN_KEY: -Infinity,
    MAX_KEY: getMaxKey(IdbKeyRange),
    schema
  };
}
function createMiddlewareStack(stackImpl, middlewares) {
  return middlewares.reduce((down, { create }) => ({ ...down, ...create(down) }), stackImpl);
}
function createMiddlewareStacks(middlewares, idbdb, { IDBKeyRange, indexedDB: indexedDB2 }, tmpTrans) {
  const dbcore = createMiddlewareStack(createDBCore(idbdb, IDBKeyRange, tmpTrans), middlewares.dbcore);
  return {
    dbcore
  };
}
function generateMiddlewareStacks({ _novip: db }, tmpTrans) {
  const idbdb = tmpTrans.db;
  const stacks = createMiddlewareStacks(db._middlewares, idbdb, db._deps, tmpTrans);
  db.core = stacks.dbcore;
  db.tables.forEach((table) => {
    const tableName = table.name;
    if (db.core.schema.tables.some((tbl) => tbl.name === tableName)) {
      table.core = db.core.table(tableName);
      if (db[tableName] instanceof db.Table) {
        db[tableName].core = table.core;
      }
    }
  });
}
function setApiOnPlace({ _novip: db }, objs, tableNames, dbschema) {
  tableNames.forEach((tableName) => {
    const schema = dbschema[tableName];
    objs.forEach((obj) => {
      const propDesc = getPropertyDescriptor(obj, tableName);
      if (!propDesc || "value" in propDesc && propDesc.value === void 0) {
        if (obj === db.Transaction.prototype || obj instanceof db.Transaction) {
          setProp(obj, tableName, {
            get() {
              return this.table(tableName);
            },
            set(value) {
              defineProperty(this, tableName, { value, writable: true, configurable: true, enumerable: true });
            }
          });
        } else {
          obj[tableName] = new db.Table(tableName, schema);
        }
      }
    });
  });
}
function removeTablesApi({ _novip: db }, objs) {
  objs.forEach((obj) => {
    for (let key in obj) {
      if (obj[key] instanceof db.Table)
        delete obj[key];
    }
  });
}
function lowerVersionFirst(a, b) {
  return a._cfg.version - b._cfg.version;
}
function runUpgraders(db, oldVersion, idbUpgradeTrans, reject) {
  const globalSchema = db._dbSchema;
  const trans = db._createTransaction("readwrite", db._storeNames, globalSchema);
  trans.create(idbUpgradeTrans);
  trans._completion.catch(reject);
  const rejectTransaction = trans._reject.bind(trans);
  const transless = PSD.transless || PSD;
  newScope(() => {
    PSD.trans = trans;
    PSD.transless = transless;
    if (oldVersion === 0) {
      keys(globalSchema).forEach((tableName) => {
        createTable(idbUpgradeTrans, tableName, globalSchema[tableName].primKey, globalSchema[tableName].indexes);
      });
      generateMiddlewareStacks(db, idbUpgradeTrans);
      DexiePromise.follow(() => db.on.populate.fire(trans)).catch(rejectTransaction);
    } else
      updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans).catch(rejectTransaction);
  });
}
function updateTablesAndIndexes({ _novip: db }, oldVersion, trans, idbUpgradeTrans) {
  const queue = [];
  const versions = db._versions;
  let globalSchema = db._dbSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
  let anyContentUpgraderHasRun = false;
  const versToRun = versions.filter((v) => v._cfg.version >= oldVersion);
  versToRun.forEach((version) => {
    queue.push(() => {
      const oldSchema = globalSchema;
      const newSchema = version._cfg.dbschema;
      adjustToExistingIndexNames(db, oldSchema, idbUpgradeTrans);
      adjustToExistingIndexNames(db, newSchema, idbUpgradeTrans);
      globalSchema = db._dbSchema = newSchema;
      const diff = getSchemaDiff(oldSchema, newSchema);
      diff.add.forEach((tuple) => {
        createTable(idbUpgradeTrans, tuple[0], tuple[1].primKey, tuple[1].indexes);
      });
      diff.change.forEach((change) => {
        if (change.recreate) {
          throw new exceptions.Upgrade("Not yet support for changing primary key");
        } else {
          const store = idbUpgradeTrans.objectStore(change.name);
          change.add.forEach((idx) => addIndex(store, idx));
          change.change.forEach((idx) => {
            store.deleteIndex(idx.name);
            addIndex(store, idx);
          });
          change.del.forEach((idxName) => store.deleteIndex(idxName));
        }
      });
      const contentUpgrade = version._cfg.contentUpgrade;
      if (contentUpgrade && version._cfg.version > oldVersion) {
        generateMiddlewareStacks(db, idbUpgradeTrans);
        trans._memoizedTables = {};
        anyContentUpgraderHasRun = true;
        let upgradeSchema = shallowClone(newSchema);
        diff.del.forEach((table) => {
          upgradeSchema[table] = oldSchema[table];
        });
        removeTablesApi(db, [db.Transaction.prototype]);
        setApiOnPlace(db, [db.Transaction.prototype], keys(upgradeSchema), upgradeSchema);
        trans.schema = upgradeSchema;
        const contentUpgradeIsAsync = isAsyncFunction(contentUpgrade);
        if (contentUpgradeIsAsync) {
          incrementExpectedAwaits();
        }
        let returnValue;
        const promiseFollowed = DexiePromise.follow(() => {
          returnValue = contentUpgrade(trans);
          if (returnValue) {
            if (contentUpgradeIsAsync) {
              var decrementor = decrementExpectedAwaits.bind(null, null);
              returnValue.then(decrementor, decrementor);
            }
          }
        });
        return returnValue && typeof returnValue.then === "function" ? DexiePromise.resolve(returnValue) : promiseFollowed.then(() => returnValue);
      }
    });
    queue.push((idbtrans) => {
      if (!anyContentUpgraderHasRun || !hasIEDeleteObjectStoreBug) {
        const newSchema = version._cfg.dbschema;
        deleteRemovedTables(newSchema, idbtrans);
      }
      removeTablesApi(db, [db.Transaction.prototype]);
      setApiOnPlace(db, [db.Transaction.prototype], db._storeNames, db._dbSchema);
      trans.schema = db._dbSchema;
    });
  });
  function runQueue() {
    return queue.length ? DexiePromise.resolve(queue.shift()(trans.idbtrans)).then(runQueue) : DexiePromise.resolve();
  }
  return runQueue().then(() => {
    createMissingTables(globalSchema, idbUpgradeTrans);
  });
}
function getSchemaDiff(oldSchema, newSchema) {
  const diff = {
    del: [],
    add: [],
    change: []
  };
  let table;
  for (table in oldSchema) {
    if (!newSchema[table])
      diff.del.push(table);
  }
  for (table in newSchema) {
    const oldDef = oldSchema[table], newDef = newSchema[table];
    if (!oldDef) {
      diff.add.push([table, newDef]);
    } else {
      const change = {
        name: table,
        def: newDef,
        recreate: false,
        del: [],
        add: [],
        change: []
      };
      if ("" + (oldDef.primKey.keyPath || "") !== "" + (newDef.primKey.keyPath || "") || oldDef.primKey.auto !== newDef.primKey.auto && !isIEOrEdge) {
        change.recreate = true;
        diff.change.push(change);
      } else {
        const oldIndexes = oldDef.idxByName;
        const newIndexes = newDef.idxByName;
        let idxName;
        for (idxName in oldIndexes) {
          if (!newIndexes[idxName])
            change.del.push(idxName);
        }
        for (idxName in newIndexes) {
          const oldIdx = oldIndexes[idxName], newIdx = newIndexes[idxName];
          if (!oldIdx)
            change.add.push(newIdx);
          else if (oldIdx.src !== newIdx.src)
            change.change.push(newIdx);
        }
        if (change.del.length > 0 || change.add.length > 0 || change.change.length > 0) {
          diff.change.push(change);
        }
      }
    }
  }
  return diff;
}
function createTable(idbtrans, tableName, primKey, indexes) {
  const store = idbtrans.db.createObjectStore(tableName, primKey.keyPath ? { keyPath: primKey.keyPath, autoIncrement: primKey.auto } : { autoIncrement: primKey.auto });
  indexes.forEach((idx) => addIndex(store, idx));
  return store;
}
function createMissingTables(newSchema, idbtrans) {
  keys(newSchema).forEach((tableName) => {
    if (!idbtrans.db.objectStoreNames.contains(tableName)) {
      createTable(idbtrans, tableName, newSchema[tableName].primKey, newSchema[tableName].indexes);
    }
  });
}
function deleteRemovedTables(newSchema, idbtrans) {
  [].slice.call(idbtrans.db.objectStoreNames).forEach((storeName) => newSchema[storeName] == null && idbtrans.db.deleteObjectStore(storeName));
}
function addIndex(store, idx) {
  store.createIndex(idx.name, idx.keyPath, { unique: idx.unique, multiEntry: idx.multi });
}
function buildGlobalSchema(db, idbdb, tmpTrans) {
  const globalSchema = {};
  const dbStoreNames = slice(idbdb.objectStoreNames, 0);
  dbStoreNames.forEach((storeName) => {
    const store = tmpTrans.objectStore(storeName);
    let keyPath = store.keyPath;
    const primKey = createIndexSpec(nameFromKeyPath(keyPath), keyPath || "", false, false, !!store.autoIncrement, keyPath && typeof keyPath !== "string", true);
    const indexes = [];
    for (let j = 0; j < store.indexNames.length; ++j) {
      const idbindex = store.index(store.indexNames[j]);
      keyPath = idbindex.keyPath;
      var index = createIndexSpec(idbindex.name, keyPath, !!idbindex.unique, !!idbindex.multiEntry, false, keyPath && typeof keyPath !== "string", false);
      indexes.push(index);
    }
    globalSchema[storeName] = createTableSchema(storeName, primKey, indexes);
  });
  return globalSchema;
}
function readGlobalSchema({ _novip: db }, idbdb, tmpTrans) {
  db.verno = idbdb.version / 10;
  const globalSchema = db._dbSchema = buildGlobalSchema(db, idbdb, tmpTrans);
  db._storeNames = slice(idbdb.objectStoreNames, 0);
  setApiOnPlace(db, [db._allTables], keys(globalSchema), globalSchema);
}
function verifyInstalledSchema(db, tmpTrans) {
  const installedSchema = buildGlobalSchema(db, db.idbdb, tmpTrans);
  const diff = getSchemaDiff(installedSchema, db._dbSchema);
  return !(diff.add.length || diff.change.some((ch) => ch.add.length || ch.change.length));
}
function adjustToExistingIndexNames({ _novip: db }, schema, idbtrans) {
  const storeNames = idbtrans.db.objectStoreNames;
  for (let i = 0; i < storeNames.length; ++i) {
    const storeName = storeNames[i];
    const store = idbtrans.objectStore(storeName);
    db._hasGetAll = "getAll" in store;
    for (let j = 0; j < store.indexNames.length; ++j) {
      const indexName = store.indexNames[j];
      const keyPath = store.index(indexName).keyPath;
      const dexieName = typeof keyPath === "string" ? keyPath : "[" + slice(keyPath).join("+") + "]";
      if (schema[storeName]) {
        const indexSpec = schema[storeName].idxByName[dexieName];
        if (indexSpec) {
          indexSpec.name = indexName;
          delete schema[storeName].idxByName[dexieName];
          schema[storeName].idxByName[indexName] = indexSpec;
        }
      }
    }
  }
  if (typeof navigator !== "undefined" && /Safari/.test(navigator.userAgent) && !/(Chrome\/|Edge\/)/.test(navigator.userAgent) && _global.WorkerGlobalScope && _global instanceof _global.WorkerGlobalScope && [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604) {
    db._hasGetAll = false;
  }
}
function parseIndexSyntax(primKeyAndIndexes) {
  return primKeyAndIndexes.split(",").map((index, indexNum) => {
    index = index.trim();
    const name = index.replace(/([&*]|\+\+)/g, "");
    const keyPath = /^\[/.test(name) ? name.match(/^\[(.*)\]$/)[1].split("+") : name;
    return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0);
  });
}
var Version = class {
  _parseStoresSpec(stores, outSchema) {
    keys(stores).forEach((tableName) => {
      if (stores[tableName] !== null) {
        var indexes = parseIndexSyntax(stores[tableName]);
        var primKey = indexes.shift();
        if (primKey.multi)
          throw new exceptions.Schema("Primary key cannot be multi-valued");
        indexes.forEach((idx) => {
          if (idx.auto)
            throw new exceptions.Schema("Only primary key can be marked as autoIncrement (++)");
          if (!idx.keyPath)
            throw new exceptions.Schema("Index must have a name and cannot be an empty string");
        });
        outSchema[tableName] = createTableSchema(tableName, primKey, indexes);
      }
    });
  }
  stores(stores) {
    const db = this.db;
    this._cfg.storesSource = this._cfg.storesSource ? extend(this._cfg.storesSource, stores) : stores;
    const versions = db._versions;
    const storesSpec = {};
    let dbschema = {};
    versions.forEach((version) => {
      extend(storesSpec, version._cfg.storesSource);
      dbschema = version._cfg.dbschema = {};
      version._parseStoresSpec(storesSpec, dbschema);
    });
    db._dbSchema = dbschema;
    removeTablesApi(db, [db._allTables, db, db.Transaction.prototype]);
    setApiOnPlace(db, [db._allTables, db, db.Transaction.prototype, this._cfg.tables], keys(dbschema), dbschema);
    db._storeNames = keys(dbschema);
    return this;
  }
  upgrade(upgradeFunction) {
    this._cfg.contentUpgrade = promisableChain(this._cfg.contentUpgrade || nop, upgradeFunction);
    return this;
  }
};
function createVersionConstructor(db) {
  return makeClassConstructor(Version.prototype, function Version2(versionNumber) {
    this.db = db;
    this._cfg = {
      version: versionNumber,
      storesSource: null,
      dbschema: {},
      tables: {},
      contentUpgrade: null
    };
  });
}
function getDbNamesTable(indexedDB2, IDBKeyRange) {
  let dbNamesDB = indexedDB2["_dbNamesDB"];
  if (!dbNamesDB) {
    dbNamesDB = indexedDB2["_dbNamesDB"] = new Dexie$1(DBNAMES_DB, {
      addons: [],
      indexedDB: indexedDB2,
      IDBKeyRange
    });
    dbNamesDB.version(1).stores({ dbnames: "name" });
  }
  return dbNamesDB.table("dbnames");
}
function hasDatabasesNative(indexedDB2) {
  return indexedDB2 && typeof indexedDB2.databases === "function";
}
function getDatabaseNames({ indexedDB: indexedDB2, IDBKeyRange }) {
  return hasDatabasesNative(indexedDB2) ? Promise.resolve(indexedDB2.databases()).then((infos) => infos.map((info) => info.name).filter((name) => name !== DBNAMES_DB)) : getDbNamesTable(indexedDB2, IDBKeyRange).toCollection().primaryKeys();
}
function _onDatabaseCreated({ indexedDB: indexedDB2, IDBKeyRange }, name) {
  !hasDatabasesNative(indexedDB2) && name !== DBNAMES_DB && getDbNamesTable(indexedDB2, IDBKeyRange).put({ name }).catch(nop);
}
function _onDatabaseDeleted({ indexedDB: indexedDB2, IDBKeyRange }, name) {
  !hasDatabasesNative(indexedDB2) && name !== DBNAMES_DB && getDbNamesTable(indexedDB2, IDBKeyRange).delete(name).catch(nop);
}
function vip(fn) {
  return newScope(function() {
    PSD.letThrough = true;
    return fn();
  });
}
function idbReady() {
  var isSafari = !navigator.userAgentData && /Safari\//.test(navigator.userAgent) && !/Chrom(e|ium)\//.test(navigator.userAgent);
  if (!isSafari || !indexedDB.databases)
    return Promise.resolve();
  var intervalId;
  return new Promise(function(resolve) {
    var tryIdb = function() {
      return indexedDB.databases().finally(resolve);
    };
    intervalId = setInterval(tryIdb, 100);
    tryIdb();
  }).finally(function() {
    return clearInterval(intervalId);
  });
}
function dexieOpen(db) {
  const state = db._state;
  const { indexedDB: indexedDB2 } = db._deps;
  if (state.isBeingOpened || db.idbdb)
    return state.dbReadyPromise.then(() => state.dbOpenError ? rejection(state.dbOpenError) : db);
  debug && (state.openCanceller._stackHolder = getErrorWithStack());
  state.isBeingOpened = true;
  state.dbOpenError = null;
  state.openComplete = false;
  const openCanceller = state.openCanceller;
  function throwIfCancelled() {
    if (state.openCanceller !== openCanceller)
      throw new exceptions.DatabaseClosed("db.open() was cancelled");
  }
  let resolveDbReady = state.dbReadyResolve, upgradeTransaction = null, wasCreated = false;
  const tryOpenDB = () => new DexiePromise((resolve, reject) => {
    throwIfCancelled();
    if (!indexedDB2)
      throw new exceptions.MissingAPI();
    const dbName = db.name;
    const req = state.autoSchema ? indexedDB2.open(dbName) : indexedDB2.open(dbName, Math.round(db.verno * 10));
    if (!req)
      throw new exceptions.MissingAPI();
    req.onerror = eventRejectHandler(reject);
    req.onblocked = wrap(db._fireOnBlocked);
    req.onupgradeneeded = wrap((e) => {
      upgradeTransaction = req.transaction;
      if (state.autoSchema && !db._options.allowEmptyDB) {
        req.onerror = preventDefault;
        upgradeTransaction.abort();
        req.result.close();
        const delreq = indexedDB2.deleteDatabase(dbName);
        delreq.onsuccess = delreq.onerror = wrap(() => {
          reject(new exceptions.NoSuchDatabase(`Database ${dbName} doesnt exist`));
        });
      } else {
        upgradeTransaction.onerror = eventRejectHandler(reject);
        var oldVer = e.oldVersion > Math.pow(2, 62) ? 0 : e.oldVersion;
        wasCreated = oldVer < 1;
        db._novip.idbdb = req.result;
        runUpgraders(db, oldVer / 10, upgradeTransaction, reject);
      }
    }, reject);
    req.onsuccess = wrap(() => {
      upgradeTransaction = null;
      const idbdb = db._novip.idbdb = req.result;
      const objectStoreNames = slice(idbdb.objectStoreNames);
      if (objectStoreNames.length > 0)
        try {
          const tmpTrans = idbdb.transaction(safariMultiStoreFix(objectStoreNames), "readonly");
          if (state.autoSchema)
            readGlobalSchema(db, idbdb, tmpTrans);
          else {
            adjustToExistingIndexNames(db, db._dbSchema, tmpTrans);
            if (!verifyInstalledSchema(db, tmpTrans)) {
              console.warn(`Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Some queries may fail.`);
            }
          }
          generateMiddlewareStacks(db, tmpTrans);
        } catch (e) {
        }
      connections.push(db);
      idbdb.onversionchange = wrap((ev) => {
        state.vcFired = true;
        db.on("versionchange").fire(ev);
      });
      idbdb.onclose = wrap((ev) => {
        db.on("close").fire(ev);
      });
      if (wasCreated)
        _onDatabaseCreated(db._deps, dbName);
      resolve();
    }, reject);
  }).catch((err) => {
    if (err && err.name === "UnknownError" && state.PR1398_maxLoop > 0) {
      state.PR1398_maxLoop--;
      console.warn("Dexie: Workaround for Chrome UnknownError on open()");
      return tryOpenDB();
    } else {
      return DexiePromise.reject(err);
    }
  });
  return DexiePromise.race([
    openCanceller,
    (typeof navigator === "undefined" ? DexiePromise.resolve() : idbReady()).then(tryOpenDB)
  ]).then(() => {
    throwIfCancelled();
    state.onReadyBeingFired = [];
    return DexiePromise.resolve(vip(() => db.on.ready.fire(db.vip))).then(function fireRemainders() {
      if (state.onReadyBeingFired.length > 0) {
        let remainders = state.onReadyBeingFired.reduce(promisableChain, nop);
        state.onReadyBeingFired = [];
        return DexiePromise.resolve(vip(() => remainders(db.vip))).then(fireRemainders);
      }
    });
  }).finally(() => {
    state.onReadyBeingFired = null;
    state.isBeingOpened = false;
  }).then(() => {
    return db;
  }).catch((err) => {
    state.dbOpenError = err;
    try {
      upgradeTransaction && upgradeTransaction.abort();
    } catch (_a) {
    }
    if (openCanceller === state.openCanceller) {
      db._close();
    }
    return rejection(err);
  }).finally(() => {
    state.openComplete = true;
    resolveDbReady();
  });
}
function awaitIterator(iterator) {
  var callNext = (result) => iterator.next(result), doThrow = (error) => iterator.throw(error), onSuccess = step(callNext), onError = step(doThrow);
  function step(getNext) {
    return (val) => {
      var next = getNext(val), value = next.value;
      return next.done ? value : !value || typeof value.then !== "function" ? isArray(value) ? Promise.all(value).then(onSuccess, onError) : onSuccess(value) : value.then(onSuccess, onError);
    };
  }
  return step(callNext)();
}
function extractTransactionArgs(mode, _tableArgs_, scopeFunc) {
  var i = arguments.length;
  if (i < 2)
    throw new exceptions.InvalidArgument("Too few arguments");
  var args = new Array(i - 1);
  while (--i)
    args[i - 1] = arguments[i];
  scopeFunc = args.pop();
  var tables = flatten(args);
  return [mode, tables, scopeFunc];
}
function enterTransactionScope(db, mode, storeNames, parentTransaction, scopeFunc) {
  return DexiePromise.resolve().then(() => {
    const transless = PSD.transless || PSD;
    const trans = db._createTransaction(mode, storeNames, db._dbSchema, parentTransaction);
    const zoneProps = {
      trans,
      transless
    };
    if (parentTransaction) {
      trans.idbtrans = parentTransaction.idbtrans;
    } else {
      try {
        trans.create();
        db._state.PR1398_maxLoop = 3;
      } catch (ex) {
        if (ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) {
          console.warn("Dexie: Need to reopen db");
          db._close();
          return db.open().then(() => enterTransactionScope(db, mode, storeNames, null, scopeFunc));
        }
        return rejection(ex);
      }
    }
    const scopeFuncIsAsync = isAsyncFunction(scopeFunc);
    if (scopeFuncIsAsync) {
      incrementExpectedAwaits();
    }
    let returnValue;
    const promiseFollowed = DexiePromise.follow(() => {
      returnValue = scopeFunc.call(trans, trans);
      if (returnValue) {
        if (scopeFuncIsAsync) {
          var decrementor = decrementExpectedAwaits.bind(null, null);
          returnValue.then(decrementor, decrementor);
        } else if (typeof returnValue.next === "function" && typeof returnValue.throw === "function") {
          returnValue = awaitIterator(returnValue);
        }
      }
    }, zoneProps);
    return (returnValue && typeof returnValue.then === "function" ? DexiePromise.resolve(returnValue).then((x) => trans.active ? x : rejection(new exceptions.PrematureCommit("Transaction committed too early. See http://bit.ly/2kdckMn"))) : promiseFollowed.then(() => returnValue)).then((x) => {
      if (parentTransaction)
        trans._resolve();
      return trans._completion.then(() => x);
    }).catch((e) => {
      trans._reject(e);
      return rejection(e);
    });
  });
}
function pad(a, value, count) {
  const result = isArray(a) ? a.slice() : [a];
  for (let i = 0; i < count; ++i)
    result.push(value);
  return result;
}
function createVirtualIndexMiddleware(down) {
  return {
    ...down,
    table(tableName) {
      const table = down.table(tableName);
      const { schema } = table;
      const indexLookup = {};
      const allVirtualIndexes = [];
      function addVirtualIndexes(keyPath, keyTail, lowLevelIndex) {
        const keyPathAlias = getKeyPathAlias(keyPath);
        const indexList = indexLookup[keyPathAlias] = indexLookup[keyPathAlias] || [];
        const keyLength = keyPath == null ? 0 : typeof keyPath === "string" ? 1 : keyPath.length;
        const isVirtual = keyTail > 0;
        const virtualIndex = {
          ...lowLevelIndex,
          isVirtual,
          keyTail,
          keyLength,
          extractKey: getKeyExtractor(keyPath),
          unique: !isVirtual && lowLevelIndex.unique
        };
        indexList.push(virtualIndex);
        if (!virtualIndex.isPrimaryKey) {
          allVirtualIndexes.push(virtualIndex);
        }
        if (keyLength > 1) {
          const virtualKeyPath = keyLength === 2 ? keyPath[0] : keyPath.slice(0, keyLength - 1);
          addVirtualIndexes(virtualKeyPath, keyTail + 1, lowLevelIndex);
        }
        indexList.sort((a, b) => a.keyTail - b.keyTail);
        return virtualIndex;
      }
      const primaryKey = addVirtualIndexes(schema.primaryKey.keyPath, 0, schema.primaryKey);
      indexLookup[":id"] = [primaryKey];
      for (const index of schema.indexes) {
        addVirtualIndexes(index.keyPath, 0, index);
      }
      function findBestIndex(keyPath) {
        const result2 = indexLookup[getKeyPathAlias(keyPath)];
        return result2 && result2[0];
      }
      function translateRange(range, keyTail) {
        return {
          type: range.type === 1 ? 2 : range.type,
          lower: pad(range.lower, range.lowerOpen ? down.MAX_KEY : down.MIN_KEY, keyTail),
          lowerOpen: true,
          upper: pad(range.upper, range.upperOpen ? down.MIN_KEY : down.MAX_KEY, keyTail),
          upperOpen: true
        };
      }
      function translateRequest(req) {
        const index = req.query.index;
        return index.isVirtual ? {
          ...req,
          query: {
            index,
            range: translateRange(req.query.range, index.keyTail)
          }
        } : req;
      }
      const result = {
        ...table,
        schema: {
          ...schema,
          primaryKey,
          indexes: allVirtualIndexes,
          getIndexByKeyPath: findBestIndex
        },
        count(req) {
          return table.count(translateRequest(req));
        },
        query(req) {
          return table.query(translateRequest(req));
        },
        openCursor(req) {
          const { keyTail, isVirtual, keyLength } = req.query.index;
          if (!isVirtual)
            return table.openCursor(req);
          function createVirtualCursor(cursor) {
            function _continue(key) {
              key != null ? cursor.continue(pad(key, req.reverse ? down.MAX_KEY : down.MIN_KEY, keyTail)) : req.unique ? cursor.continue(cursor.key.slice(0, keyLength).concat(req.reverse ? down.MIN_KEY : down.MAX_KEY, keyTail)) : cursor.continue();
            }
            const virtualCursor = Object.create(cursor, {
              continue: { value: _continue },
              continuePrimaryKey: {
                value(key, primaryKey2) {
                  cursor.continuePrimaryKey(pad(key, down.MAX_KEY, keyTail), primaryKey2);
                }
              },
              primaryKey: {
                get() {
                  return cursor.primaryKey;
                }
              },
              key: {
                get() {
                  const key = cursor.key;
                  return keyLength === 1 ? key[0] : key.slice(0, keyLength);
                }
              },
              value: {
                get() {
                  return cursor.value;
                }
              }
            });
            return virtualCursor;
          }
          return table.openCursor(translateRequest(req)).then((cursor) => cursor && createVirtualCursor(cursor));
        }
      };
      return result;
    }
  };
}
var virtualIndexMiddleware = {
  stack: "dbcore",
  name: "VirtualIndexMiddleware",
  level: 1,
  create: createVirtualIndexMiddleware
};
function getObjectDiff(a, b, rv, prfx) {
  rv = rv || {};
  prfx = prfx || "";
  keys(a).forEach((prop) => {
    if (!hasOwn(b, prop)) {
      rv[prfx + prop] = void 0;
    } else {
      var ap = a[prop], bp = b[prop];
      if (typeof ap === "object" && typeof bp === "object" && ap && bp) {
        const apTypeName = toStringTag(ap);
        const bpTypeName = toStringTag(bp);
        if (apTypeName !== bpTypeName) {
          rv[prfx + prop] = b[prop];
        } else if (apTypeName === "Object") {
          getObjectDiff(ap, bp, rv, prfx + prop + ".");
        } else if (ap !== bp) {
          rv[prfx + prop] = b[prop];
        }
      } else if (ap !== bp)
        rv[prfx + prop] = b[prop];
    }
  });
  keys(b).forEach((prop) => {
    if (!hasOwn(a, prop)) {
      rv[prfx + prop] = b[prop];
    }
  });
  return rv;
}
function getEffectiveKeys(primaryKey, req) {
  if (req.type === "delete")
    return req.keys;
  return req.keys || req.values.map(primaryKey.extractKey);
}
var hooksMiddleware = {
  stack: "dbcore",
  name: "HooksMiddleware",
  level: 2,
  create: (downCore) => ({
    ...downCore,
    table(tableName) {
      const downTable = downCore.table(tableName);
      const { primaryKey } = downTable.schema;
      const tableMiddleware = {
        ...downTable,
        mutate(req) {
          const dxTrans = PSD.trans;
          const { deleting, creating, updating } = dxTrans.table(tableName).hook;
          switch (req.type) {
            case "add":
              if (creating.fire === nop)
                break;
              return dxTrans._promise("readwrite", () => addPutOrDelete(req), true);
            case "put":
              if (creating.fire === nop && updating.fire === nop)
                break;
              return dxTrans._promise("readwrite", () => addPutOrDelete(req), true);
            case "delete":
              if (deleting.fire === nop)
                break;
              return dxTrans._promise("readwrite", () => addPutOrDelete(req), true);
            case "deleteRange":
              if (deleting.fire === nop)
                break;
              return dxTrans._promise("readwrite", () => deleteRange(req), true);
          }
          return downTable.mutate(req);
          function addPutOrDelete(req2) {
            const dxTrans2 = PSD.trans;
            const keys2 = req2.keys || getEffectiveKeys(primaryKey, req2);
            if (!keys2)
              throw new Error("Keys missing");
            req2 = req2.type === "add" || req2.type === "put" ? { ...req2, keys: keys2 } : { ...req2 };
            if (req2.type !== "delete")
              req2.values = [...req2.values];
            if (req2.keys)
              req2.keys = [...req2.keys];
            return getExistingValues(downTable, req2, keys2).then((existingValues) => {
              const contexts = keys2.map((key, i) => {
                const existingValue = existingValues[i];
                const ctx = { onerror: null, onsuccess: null };
                if (req2.type === "delete") {
                  deleting.fire.call(ctx, key, existingValue, dxTrans2);
                } else if (req2.type === "add" || existingValue === void 0) {
                  const generatedPrimaryKey = creating.fire.call(ctx, key, req2.values[i], dxTrans2);
                  if (key == null && generatedPrimaryKey != null) {
                    key = generatedPrimaryKey;
                    req2.keys[i] = key;
                    if (!primaryKey.outbound) {
                      setByKeyPath(req2.values[i], primaryKey.keyPath, key);
                    }
                  }
                } else {
                  const objectDiff = getObjectDiff(existingValue, req2.values[i]);
                  const additionalChanges = updating.fire.call(ctx, objectDiff, key, existingValue, dxTrans2);
                  if (additionalChanges) {
                    const requestedValue = req2.values[i];
                    Object.keys(additionalChanges).forEach((keyPath) => {
                      if (hasOwn(requestedValue, keyPath)) {
                        requestedValue[keyPath] = additionalChanges[keyPath];
                      } else {
                        setByKeyPath(requestedValue, keyPath, additionalChanges[keyPath]);
                      }
                    });
                  }
                }
                return ctx;
              });
              return downTable.mutate(req2).then(({ failures, results, numFailures, lastResult }) => {
                for (let i = 0; i < keys2.length; ++i) {
                  const primKey = results ? results[i] : keys2[i];
                  const ctx = contexts[i];
                  if (primKey == null) {
                    ctx.onerror && ctx.onerror(failures[i]);
                  } else {
                    ctx.onsuccess && ctx.onsuccess(
                      req2.type === "put" && existingValues[i] ? req2.values[i] : primKey
                    );
                  }
                }
                return { failures, results, numFailures, lastResult };
              }).catch((error) => {
                contexts.forEach((ctx) => ctx.onerror && ctx.onerror(error));
                return Promise.reject(error);
              });
            });
          }
          function deleteRange(req2) {
            return deleteNextChunk(req2.trans, req2.range, 1e4);
          }
          function deleteNextChunk(trans, range, limit) {
            return downTable.query({ trans, values: false, query: { index: primaryKey, range }, limit }).then(({ result }) => {
              return addPutOrDelete({ type: "delete", keys: result, trans }).then((res) => {
                if (res.numFailures > 0)
                  return Promise.reject(res.failures[0]);
                if (result.length < limit) {
                  return { failures: [], numFailures: 0, lastResult: void 0 };
                } else {
                  return deleteNextChunk(trans, { ...range, lower: result[result.length - 1], lowerOpen: true }, limit);
                }
              });
            });
          }
        }
      };
      return tableMiddleware;
    }
  })
};
function getExistingValues(table, req, effectiveKeys) {
  return req.type === "add" ? Promise.resolve([]) : table.getMany({ trans: req.trans, keys: effectiveKeys, cache: "immutable" });
}
function getFromTransactionCache(keys2, cache, clone) {
  try {
    if (!cache)
      return null;
    if (cache.keys.length < keys2.length)
      return null;
    const result = [];
    for (let i = 0, j = 0; i < cache.keys.length && j < keys2.length; ++i) {
      if (cmp(cache.keys[i], keys2[j]) !== 0)
        continue;
      result.push(clone ? deepClone(cache.values[i]) : cache.values[i]);
      ++j;
    }
    return result.length === keys2.length ? result : null;
  } catch (_a) {
    return null;
  }
}
var cacheExistingValuesMiddleware = {
  stack: "dbcore",
  level: -1,
  create: (core) => {
    return {
      table: (tableName) => {
        const table = core.table(tableName);
        return {
          ...table,
          getMany: (req) => {
            if (!req.cache) {
              return table.getMany(req);
            }
            const cachedResult = getFromTransactionCache(req.keys, req.trans["_cache"], req.cache === "clone");
            if (cachedResult) {
              return DexiePromise.resolve(cachedResult);
            }
            return table.getMany(req).then((res) => {
              req.trans["_cache"] = {
                keys: req.keys,
                values: req.cache === "clone" ? deepClone(res) : res
              };
              return res;
            });
          },
          mutate: (req) => {
            if (req.type !== "add")
              req.trans["_cache"] = null;
            return table.mutate(req);
          }
        };
      }
    };
  }
};
function isEmptyRange(node) {
  return !("from" in node);
}
var RangeSet = function(fromOrTree, to) {
  if (this) {
    extend(this, arguments.length ? { d: 1, from: fromOrTree, to: arguments.length > 1 ? to : fromOrTree } : { d: 0 });
  } else {
    const rv = new RangeSet();
    if (fromOrTree && "d" in fromOrTree) {
      extend(rv, fromOrTree);
    }
    return rv;
  }
};
props(RangeSet.prototype, {
  add(rangeSet) {
    mergeRanges(this, rangeSet);
    return this;
  },
  addKey(key) {
    addRange(this, key, key);
    return this;
  },
  addKeys(keys2) {
    keys2.forEach((key) => addRange(this, key, key));
    return this;
  },
  [iteratorSymbol]() {
    return getRangeSetIterator(this);
  }
});
function addRange(target, from, to) {
  const diff = cmp(from, to);
  if (isNaN(diff))
    return;
  if (diff > 0)
    throw RangeError();
  if (isEmptyRange(target))
    return extend(target, { from, to, d: 1 });
  const left = target.l;
  const right = target.r;
  if (cmp(to, target.from) < 0) {
    left ? addRange(left, from, to) : target.l = { from, to, d: 1, l: null, r: null };
    return rebalance(target);
  }
  if (cmp(from, target.to) > 0) {
    right ? addRange(right, from, to) : target.r = { from, to, d: 1, l: null, r: null };
    return rebalance(target);
  }
  if (cmp(from, target.from) < 0) {
    target.from = from;
    target.l = null;
    target.d = right ? right.d + 1 : 1;
  }
  if (cmp(to, target.to) > 0) {
    target.to = to;
    target.r = null;
    target.d = target.l ? target.l.d + 1 : 1;
  }
  const rightWasCutOff = !target.r;
  if (left && !target.l) {
    mergeRanges(target, left);
  }
  if (right && rightWasCutOff) {
    mergeRanges(target, right);
  }
}
function mergeRanges(target, newSet) {
  function _addRangeSet(target2, { from, to, l, r }) {
    addRange(target2, from, to);
    if (l)
      _addRangeSet(target2, l);
    if (r)
      _addRangeSet(target2, r);
  }
  if (!isEmptyRange(newSet))
    _addRangeSet(target, newSet);
}
function rangesOverlap(rangeSet1, rangeSet2) {
  const i1 = getRangeSetIterator(rangeSet2);
  let nextResult1 = i1.next();
  if (nextResult1.done)
    return false;
  let a = nextResult1.value;
  const i2 = getRangeSetIterator(rangeSet1);
  let nextResult2 = i2.next(a.from);
  let b = nextResult2.value;
  while (!nextResult1.done && !nextResult2.done) {
    if (cmp(b.from, a.to) <= 0 && cmp(b.to, a.from) >= 0)
      return true;
    cmp(a.from, b.from) < 0 ? a = (nextResult1 = i1.next(b.from)).value : b = (nextResult2 = i2.next(a.from)).value;
  }
  return false;
}
function getRangeSetIterator(node) {
  let state = isEmptyRange(node) ? null : { s: 0, n: node };
  return {
    next(key) {
      const keyProvided = arguments.length > 0;
      while (state) {
        switch (state.s) {
          case 0:
            state.s = 1;
            if (keyProvided) {
              while (state.n.l && cmp(key, state.n.from) < 0)
                state = { up: state, n: state.n.l, s: 1 };
            } else {
              while (state.n.l)
                state = { up: state, n: state.n.l, s: 1 };
            }
          case 1:
            state.s = 2;
            if (!keyProvided || cmp(key, state.n.to) <= 0)
              return { value: state.n, done: false };
          case 2:
            if (state.n.r) {
              state.s = 3;
              state = { up: state, n: state.n.r, s: 0 };
              continue;
            }
          case 3:
            state = state.up;
        }
      }
      return { done: true };
    }
  };
}
function rebalance(target) {
  var _a, _b;
  const diff = (((_a = target.r) === null || _a === void 0 ? void 0 : _a.d) || 0) - (((_b = target.l) === null || _b === void 0 ? void 0 : _b.d) || 0);
  const r = diff > 1 ? "r" : diff < -1 ? "l" : "";
  if (r) {
    const l = r === "r" ? "l" : "r";
    const rootClone = { ...target };
    const oldRootRight = target[r];
    target.from = oldRootRight.from;
    target.to = oldRootRight.to;
    target[r] = oldRootRight[r];
    rootClone[r] = oldRootRight[l];
    target[l] = rootClone;
    rootClone.d = computeDepth(rootClone);
  }
  target.d = computeDepth(target);
}
function computeDepth({ r, l }) {
  return (r ? l ? Math.max(r.d, l.d) : r.d : l ? l.d : 0) + 1;
}
var observabilityMiddleware = {
  stack: "dbcore",
  level: 0,
  create: (core) => {
    const dbName = core.schema.name;
    const FULL_RANGE = new RangeSet(core.MIN_KEY, core.MAX_KEY);
    return {
      ...core,
      table: (tableName) => {
        const table = core.table(tableName);
        const { schema } = table;
        const { primaryKey } = schema;
        const { extractKey, outbound } = primaryKey;
        const tableClone = {
          ...table,
          mutate: (req) => {
            const trans = req.trans;
            const mutatedParts = trans.mutatedParts || (trans.mutatedParts = {});
            const getRangeSet = (indexName) => {
              const part = `idb://${dbName}/${tableName}/${indexName}`;
              return mutatedParts[part] || (mutatedParts[part] = new RangeSet());
            };
            const pkRangeSet = getRangeSet("");
            const delsRangeSet = getRangeSet(":dels");
            const { type: type2 } = req;
            let [keys2, newObjs] = req.type === "deleteRange" ? [req.range] : req.type === "delete" ? [req.keys] : req.values.length < 50 ? [[], req.values] : [];
            const oldCache = req.trans["_cache"];
            return table.mutate(req).then((res) => {
              if (isArray(keys2)) {
                if (type2 !== "delete")
                  keys2 = res.results;
                pkRangeSet.addKeys(keys2);
                const oldObjs = getFromTransactionCache(keys2, oldCache);
                if (!oldObjs && type2 !== "add") {
                  delsRangeSet.addKeys(keys2);
                }
                if (oldObjs || newObjs) {
                  trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs);
                }
              } else if (keys2) {
                const range = { from: keys2.lower, to: keys2.upper };
                delsRangeSet.add(range);
                pkRangeSet.add(range);
              } else {
                pkRangeSet.add(FULL_RANGE);
                delsRangeSet.add(FULL_RANGE);
                schema.indexes.forEach((idx) => getRangeSet(idx.name).add(FULL_RANGE));
              }
              return res;
            });
          }
        };
        const getRange = ({ query: { index, range } }) => {
          var _a, _b;
          return [
            index,
            new RangeSet((_a = range.lower) !== null && _a !== void 0 ? _a : core.MIN_KEY, (_b = range.upper) !== null && _b !== void 0 ? _b : core.MAX_KEY)
          ];
        };
        const readSubscribers = {
          get: (req) => [primaryKey, new RangeSet(req.key)],
          getMany: (req) => [primaryKey, new RangeSet().addKeys(req.keys)],
          count: getRange,
          query: getRange,
          openCursor: getRange
        };
        keys(readSubscribers).forEach((method) => {
          tableClone[method] = function(req) {
            const { subscr } = PSD;
            if (subscr) {
              const getRangeSet = (indexName) => {
                const part = `idb://${dbName}/${tableName}/${indexName}`;
                return subscr[part] || (subscr[part] = new RangeSet());
              };
              const pkRangeSet = getRangeSet("");
              const delsRangeSet = getRangeSet(":dels");
              const [queriedIndex, queriedRanges] = readSubscribers[method](req);
              getRangeSet(queriedIndex.name || "").add(queriedRanges);
              if (!queriedIndex.isPrimaryKey) {
                if (method === "count") {
                  delsRangeSet.add(FULL_RANGE);
                } else {
                  const keysPromise = method === "query" && outbound && req.values && table.query({
                    ...req,
                    values: false
                  });
                  return table[method].apply(this, arguments).then((res) => {
                    if (method === "query") {
                      if (outbound && req.values) {
                        return keysPromise.then(({ result: resultingKeys }) => {
                          pkRangeSet.addKeys(resultingKeys);
                          return res;
                        });
                      }
                      const pKeys = req.values ? res.result.map(extractKey) : res.result;
                      if (req.values) {
                        pkRangeSet.addKeys(pKeys);
                      } else {
                        delsRangeSet.addKeys(pKeys);
                      }
                    } else if (method === "openCursor") {
                      const cursor = res;
                      const wantValues = req.values;
                      return cursor && Object.create(cursor, {
                        key: {
                          get() {
                            delsRangeSet.addKey(cursor.primaryKey);
                            return cursor.key;
                          }
                        },
                        primaryKey: {
                          get() {
                            const pkey = cursor.primaryKey;
                            delsRangeSet.addKey(pkey);
                            return pkey;
                          }
                        },
                        value: {
                          get() {
                            wantValues && pkRangeSet.addKey(cursor.primaryKey);
                            return cursor.value;
                          }
                        }
                      });
                    }
                    return res;
                  });
                }
              }
            }
            return table[method].apply(this, arguments);
          };
        });
        return tableClone;
      }
    };
  }
};
function trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs) {
  function addAffectedIndex(ix) {
    const rangeSet = getRangeSet(ix.name || "");
    function extractKey(obj) {
      return obj != null ? ix.extractKey(obj) : null;
    }
    const addKeyOrKeys = (key) => ix.multiEntry && isArray(key) ? key.forEach((key2) => rangeSet.addKey(key2)) : rangeSet.addKey(key);
    (oldObjs || newObjs).forEach((_, i) => {
      const oldKey = oldObjs && extractKey(oldObjs[i]);
      const newKey = newObjs && extractKey(newObjs[i]);
      if (cmp(oldKey, newKey) !== 0) {
        if (oldKey != null)
          addKeyOrKeys(oldKey);
        if (newKey != null)
          addKeyOrKeys(newKey);
      }
    });
  }
  schema.indexes.forEach(addAffectedIndex);
}
var Dexie$1 = class _Dexie$1 {
  constructor(name, options) {
    this._middlewares = {};
    this.verno = 0;
    const deps = _Dexie$1.dependencies;
    this._options = options = {
      addons: _Dexie$1.addons,
      autoOpen: true,
      indexedDB: deps.indexedDB,
      IDBKeyRange: deps.IDBKeyRange,
      ...options
    };
    this._deps = {
      indexedDB: options.indexedDB,
      IDBKeyRange: options.IDBKeyRange
    };
    const { addons } = options;
    this._dbSchema = {};
    this._versions = [];
    this._storeNames = [];
    this._allTables = {};
    this.idbdb = null;
    this._novip = this;
    const state = {
      dbOpenError: null,
      isBeingOpened: false,
      onReadyBeingFired: null,
      openComplete: false,
      dbReadyResolve: nop,
      dbReadyPromise: null,
      cancelOpen: nop,
      openCanceller: null,
      autoSchema: true,
      PR1398_maxLoop: 3
    };
    state.dbReadyPromise = new DexiePromise((resolve) => {
      state.dbReadyResolve = resolve;
    });
    state.openCanceller = new DexiePromise((_, reject) => {
      state.cancelOpen = reject;
    });
    this._state = state;
    this.name = name;
    this.on = Events(this, "populate", "blocked", "versionchange", "close", { ready: [promisableChain, nop] });
    this.on.ready.subscribe = override(this.on.ready.subscribe, (subscribe) => {
      return (subscriber, bSticky) => {
        _Dexie$1.vip(() => {
          const state2 = this._state;
          if (state2.openComplete) {
            if (!state2.dbOpenError)
              DexiePromise.resolve().then(subscriber);
            if (bSticky)
              subscribe(subscriber);
          } else if (state2.onReadyBeingFired) {
            state2.onReadyBeingFired.push(subscriber);
            if (bSticky)
              subscribe(subscriber);
          } else {
            subscribe(subscriber);
            const db = this;
            if (!bSticky)
              subscribe(function unsubscribe() {
                db.on.ready.unsubscribe(subscriber);
                db.on.ready.unsubscribe(unsubscribe);
              });
          }
        });
      };
    });
    this.Collection = createCollectionConstructor(this);
    this.Table = createTableConstructor(this);
    this.Transaction = createTransactionConstructor(this);
    this.Version = createVersionConstructor(this);
    this.WhereClause = createWhereClauseConstructor(this);
    this.on("versionchange", (ev) => {
      if (ev.newVersion > 0)
        console.warn(`Another connection wants to upgrade database '${this.name}'. Closing db now to resume the upgrade.`);
      else
        console.warn(`Another connection wants to delete database '${this.name}'. Closing db now to resume the delete request.`);
      this.close();
    });
    this.on("blocked", (ev) => {
      if (!ev.newVersion || ev.newVersion < ev.oldVersion)
        console.warn(`Dexie.delete('${this.name}') was blocked`);
      else
        console.warn(`Upgrade '${this.name}' blocked by other connection holding version ${ev.oldVersion / 10}`);
    });
    this._maxKey = getMaxKey(options.IDBKeyRange);
    this._createTransaction = (mode, storeNames, dbschema, parentTransaction) => new this.Transaction(mode, storeNames, dbschema, this._options.chromeTransactionDurability, parentTransaction);
    this._fireOnBlocked = (ev) => {
      this.on("blocked").fire(ev);
      connections.filter((c) => c.name === this.name && c !== this && !c._state.vcFired).map((c) => c.on("versionchange").fire(ev));
    };
    this.use(virtualIndexMiddleware);
    this.use(hooksMiddleware);
    this.use(observabilityMiddleware);
    this.use(cacheExistingValuesMiddleware);
    this.vip = Object.create(this, { _vip: { value: true } });
    addons.forEach((addon) => addon(this));
  }
  version(versionNumber) {
    if (isNaN(versionNumber) || versionNumber < 0.1)
      throw new exceptions.Type(`Given version is not a positive number`);
    versionNumber = Math.round(versionNumber * 10) / 10;
    if (this.idbdb || this._state.isBeingOpened)
      throw new exceptions.Schema("Cannot add version when database is open");
    this.verno = Math.max(this.verno, versionNumber);
    const versions = this._versions;
    var versionInstance = versions.filter((v) => v._cfg.version === versionNumber)[0];
    if (versionInstance)
      return versionInstance;
    versionInstance = new this.Version(versionNumber);
    versions.push(versionInstance);
    versions.sort(lowerVersionFirst);
    versionInstance.stores({});
    this._state.autoSchema = false;
    return versionInstance;
  }
  _whenReady(fn) {
    return this.idbdb && (this._state.openComplete || PSD.letThrough || this._vip) ? fn() : new DexiePromise((resolve, reject) => {
      if (this._state.openComplete) {
        return reject(new exceptions.DatabaseClosed(this._state.dbOpenError));
      }
      if (!this._state.isBeingOpened) {
        if (!this._options.autoOpen) {
          reject(new exceptions.DatabaseClosed());
          return;
        }
        this.open().catch(nop);
      }
      this._state.dbReadyPromise.then(resolve, reject);
    }).then(fn);
  }
  use({ stack, create, level, name }) {
    if (name)
      this.unuse({ stack, name });
    const middlewares = this._middlewares[stack] || (this._middlewares[stack] = []);
    middlewares.push({ stack, create, level: level == null ? 10 : level, name });
    middlewares.sort((a, b) => a.level - b.level);
    return this;
  }
  unuse({ stack, name, create }) {
    if (stack && this._middlewares[stack]) {
      this._middlewares[stack] = this._middlewares[stack].filter((mw) => create ? mw.create !== create : name ? mw.name !== name : false);
    }
    return this;
  }
  open() {
    return dexieOpen(this);
  }
  _close() {
    const state = this._state;
    const idx = connections.indexOf(this);
    if (idx >= 0)
      connections.splice(idx, 1);
    if (this.idbdb) {
      try {
        this.idbdb.close();
      } catch (e) {
      }
      this._novip.idbdb = null;
    }
    state.dbReadyPromise = new DexiePromise((resolve) => {
      state.dbReadyResolve = resolve;
    });
    state.openCanceller = new DexiePromise((_, reject) => {
      state.cancelOpen = reject;
    });
  }
  close() {
    this._close();
    const state = this._state;
    this._options.autoOpen = false;
    state.dbOpenError = new exceptions.DatabaseClosed();
    if (state.isBeingOpened)
      state.cancelOpen(state.dbOpenError);
  }
  delete() {
    const hasArguments = arguments.length > 0;
    const state = this._state;
    return new DexiePromise((resolve, reject) => {
      const doDelete = () => {
        this.close();
        var req = this._deps.indexedDB.deleteDatabase(this.name);
        req.onsuccess = wrap(() => {
          _onDatabaseDeleted(this._deps, this.name);
          resolve();
        });
        req.onerror = eventRejectHandler(reject);
        req.onblocked = this._fireOnBlocked;
      };
      if (hasArguments)
        throw new exceptions.InvalidArgument("Arguments not allowed in db.delete()");
      if (state.isBeingOpened) {
        state.dbReadyPromise.then(doDelete);
      } else {
        doDelete();
      }
    });
  }
  backendDB() {
    return this.idbdb;
  }
  isOpen() {
    return this.idbdb !== null;
  }
  hasBeenClosed() {
    const dbOpenError = this._state.dbOpenError;
    return dbOpenError && dbOpenError.name === "DatabaseClosed";
  }
  hasFailed() {
    return this._state.dbOpenError !== null;
  }
  dynamicallyOpened() {
    return this._state.autoSchema;
  }
  get tables() {
    return keys(this._allTables).map((name) => this._allTables[name]);
  }
  transaction() {
    const args = extractTransactionArgs.apply(this, arguments);
    return this._transaction.apply(this, args);
  }
  _transaction(mode, tables, scopeFunc) {
    let parentTransaction = PSD.trans;
    if (!parentTransaction || parentTransaction.db !== this || mode.indexOf("!") !== -1)
      parentTransaction = null;
    const onlyIfCompatible = mode.indexOf("?") !== -1;
    mode = mode.replace("!", "").replace("?", "");
    let idbMode, storeNames;
    try {
      storeNames = tables.map((table) => {
        var storeName = table instanceof this.Table ? table.name : table;
        if (typeof storeName !== "string")
          throw new TypeError("Invalid table argument to Dexie.transaction(). Only Table or String are allowed");
        return storeName;
      });
      if (mode == "r" || mode === READONLY)
        idbMode = READONLY;
      else if (mode == "rw" || mode == READWRITE)
        idbMode = READWRITE;
      else
        throw new exceptions.InvalidArgument("Invalid transaction mode: " + mode);
      if (parentTransaction) {
        if (parentTransaction.mode === READONLY && idbMode === READWRITE) {
          if (onlyIfCompatible) {
            parentTransaction = null;
          } else
            throw new exceptions.SubTransaction("Cannot enter a sub-transaction with READWRITE mode when parent transaction is READONLY");
        }
        if (parentTransaction) {
          storeNames.forEach((storeName) => {
            if (parentTransaction && parentTransaction.storeNames.indexOf(storeName) === -1) {
              if (onlyIfCompatible) {
                parentTransaction = null;
              } else
                throw new exceptions.SubTransaction("Table " + storeName + " not included in parent transaction.");
            }
          });
        }
        if (onlyIfCompatible && parentTransaction && !parentTransaction.active) {
          parentTransaction = null;
        }
      }
    } catch (e) {
      return parentTransaction ? parentTransaction._promise(null, (_, reject) => {
        reject(e);
      }) : rejection(e);
    }
    const enterTransaction = enterTransactionScope.bind(null, this, idbMode, storeNames, parentTransaction, scopeFunc);
    return parentTransaction ? parentTransaction._promise(idbMode, enterTransaction, "lock") : PSD.trans ? usePSD(PSD.transless, () => this._whenReady(enterTransaction)) : this._whenReady(enterTransaction);
  }
  table(tableName) {
    if (!hasOwn(this._allTables, tableName)) {
      throw new exceptions.InvalidTable(`Table ${tableName} does not exist`);
    }
    return this._allTables[tableName];
  }
};
var symbolObservable = typeof Symbol !== "undefined" && "observable" in Symbol ? Symbol.observable : "@@observable";
var Observable = class {
  constructor(subscribe) {
    this._subscribe = subscribe;
  }
  subscribe(x, error, complete) {
    return this._subscribe(!x || typeof x === "function" ? { next: x, error, complete } : x);
  }
  [symbolObservable]() {
    return this;
  }
};
function extendObservabilitySet(target, newSet) {
  keys(newSet).forEach((part) => {
    const rangeSet = target[part] || (target[part] = new RangeSet());
    mergeRanges(rangeSet, newSet[part]);
  });
  return target;
}
function liveQuery(querier) {
  let hasValue = false;
  let currentValue = void 0;
  const observable = new Observable((observer) => {
    const scopeFuncIsAsync = isAsyncFunction(querier);
    function execute(subscr) {
      if (scopeFuncIsAsync) {
        incrementExpectedAwaits();
      }
      const exec = () => newScope(querier, { subscr, trans: null });
      const rv = PSD.trans ? usePSD(PSD.transless, exec) : exec();
      if (scopeFuncIsAsync) {
        rv.then(decrementExpectedAwaits, decrementExpectedAwaits);
      }
      return rv;
    }
    let closed = false;
    let accumMuts = {};
    let currentObs = {};
    const subscription = {
      get closed() {
        return closed;
      },
      unsubscribe: () => {
        closed = true;
        globalEvents.storagemutated.unsubscribe(mutationListener);
      }
    };
    observer.start && observer.start(subscription);
    let querying = false, startedListening = false;
    function shouldNotify() {
      return keys(currentObs).some((key) => accumMuts[key] && rangesOverlap(accumMuts[key], currentObs[key]));
    }
    const mutationListener = (parts) => {
      extendObservabilitySet(accumMuts, parts);
      if (shouldNotify()) {
        doQuery();
      }
    };
    const doQuery = () => {
      if (querying || closed)
        return;
      accumMuts = {};
      const subscr = {};
      const ret = execute(subscr);
      if (!startedListening) {
        globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, mutationListener);
        startedListening = true;
      }
      querying = true;
      Promise.resolve(ret).then((result) => {
        hasValue = true;
        currentValue = result;
        querying = false;
        if (closed)
          return;
        if (shouldNotify()) {
          doQuery();
        } else {
          accumMuts = {};
          currentObs = subscr;
          observer.next && observer.next(result);
        }
      }, (err) => {
        querying = false;
        hasValue = false;
        observer.error && observer.error(err);
        subscription.unsubscribe();
      });
    };
    doQuery();
    return subscription;
  });
  observable.hasValue = () => hasValue;
  observable.getValue = () => currentValue;
  return observable;
}
var domDeps;
try {
  domDeps = {
    indexedDB: _global.indexedDB || _global.mozIndexedDB || _global.webkitIndexedDB || _global.msIndexedDB,
    IDBKeyRange: _global.IDBKeyRange || _global.webkitIDBKeyRange
  };
} catch (e) {
  domDeps = { indexedDB: null, IDBKeyRange: null };
}
var Dexie = Dexie$1;
props(Dexie, {
  ...fullNameExceptions,
  delete(databaseName) {
    const db = new Dexie(databaseName, { addons: [] });
    return db.delete();
  },
  exists(name) {
    return new Dexie(name, { addons: [] }).open().then((db) => {
      db.close();
      return true;
    }).catch("NoSuchDatabaseError", () => false);
  },
  getDatabaseNames(cb) {
    try {
      return getDatabaseNames(Dexie.dependencies).then(cb);
    } catch (_a) {
      return rejection(new exceptions.MissingAPI());
    }
  },
  defineClass() {
    function Class(content) {
      extend(this, content);
    }
    return Class;
  },
  ignoreTransaction(scopeFunc) {
    return PSD.trans ? usePSD(PSD.transless, scopeFunc) : scopeFunc();
  },
  vip,
  async: function(generatorFn) {
    return function() {
      try {
        var rv = awaitIterator(generatorFn.apply(this, arguments));
        if (!rv || typeof rv.then !== "function")
          return DexiePromise.resolve(rv);
        return rv;
      } catch (e) {
        return rejection(e);
      }
    };
  },
  spawn: function(generatorFn, args, thiz) {
    try {
      var rv = awaitIterator(generatorFn.apply(thiz, args || []));
      if (!rv || typeof rv.then !== "function")
        return DexiePromise.resolve(rv);
      return rv;
    } catch (e) {
      return rejection(e);
    }
  },
  currentTransaction: {
    get: () => PSD.trans || null
  },
  waitFor: function(promiseOrFunction, optionalTimeout) {
    const promise = DexiePromise.resolve(typeof promiseOrFunction === "function" ? Dexie.ignoreTransaction(promiseOrFunction) : promiseOrFunction).timeout(optionalTimeout || 6e4);
    return PSD.trans ? PSD.trans.waitFor(promise) : promise;
  },
  Promise: DexiePromise,
  debug: {
    get: () => debug,
    set: (value) => {
      setDebug(value, value === "dexie" ? () => true : dexieStackFrameFilter);
    }
  },
  derive,
  extend,
  props,
  override,
  Events,
  on: globalEvents,
  liveQuery,
  extendObservabilitySet,
  getByKeyPath,
  setByKeyPath,
  delByKeyPath,
  shallowClone,
  deepClone,
  getObjectDiff,
  cmp,
  asap: asap$1,
  minKey,
  addons: [],
  connections,
  errnames,
  dependencies: domDeps,
  semVer: DEXIE_VERSION,
  version: DEXIE_VERSION.split(".").map((n) => parseInt(n)).reduce((p, c, i) => p + c / Math.pow(10, i * 2))
});
Dexie.maxKey = getMaxKey(Dexie.dependencies.IDBKeyRange);
if (typeof dispatchEvent !== "undefined" && typeof addEventListener !== "undefined") {
  globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, (updatedParts) => {
    if (!propagatingLocally) {
      let event;
      if (isIEOrEdge) {
        event = document.createEvent("CustomEvent");
        event.initCustomEvent(STORAGE_MUTATED_DOM_EVENT_NAME, true, true, updatedParts);
      } else {
        event = new CustomEvent(STORAGE_MUTATED_DOM_EVENT_NAME, {
          detail: updatedParts
        });
      }
      propagatingLocally = true;
      dispatchEvent(event);
      propagatingLocally = false;
    }
  });
  addEventListener(STORAGE_MUTATED_DOM_EVENT_NAME, ({ detail }) => {
    if (!propagatingLocally) {
      propagateLocally(detail);
    }
  });
}
function propagateLocally(updateParts) {
  let wasMe = propagatingLocally;
  try {
    propagatingLocally = true;
    globalEvents.storagemutated.fire(updateParts);
  } finally {
    propagatingLocally = wasMe;
  }
}
var propagatingLocally = false;
if (typeof BroadcastChannel !== "undefined") {
  const bc = new BroadcastChannel(STORAGE_MUTATED_DOM_EVENT_NAME);
  if (typeof bc.unref === "function") {
    bc.unref();
  }
  globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, (changedParts) => {
    if (!propagatingLocally) {
      bc.postMessage(changedParts);
    }
  });
  bc.onmessage = (ev) => {
    if (ev.data)
      propagateLocally(ev.data);
  };
} else if (typeof self !== "undefined" && typeof navigator !== "undefined") {
  globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, (changedParts) => {
    try {
      if (!propagatingLocally) {
        if (typeof localStorage !== "undefined") {
          localStorage.setItem(STORAGE_MUTATED_DOM_EVENT_NAME, JSON.stringify({
            trig: Math.random(),
            changedParts
          }));
        }
        if (typeof self["clients"] === "object") {
          [...self["clients"].matchAll({ includeUncontrolled: true })].forEach((client) => client.postMessage({
            type: STORAGE_MUTATED_DOM_EVENT_NAME,
            changedParts
          }));
        }
      }
    } catch (_a) {
    }
  });
  if (typeof addEventListener !== "undefined") {
    addEventListener("storage", (ev) => {
      if (ev.key === STORAGE_MUTATED_DOM_EVENT_NAME) {
        const data = JSON.parse(ev.newValue);
        if (data)
          propagateLocally(data.changedParts);
      }
    });
  }
  const swContainer = self.document && navigator.serviceWorker;
  if (swContainer) {
    swContainer.addEventListener("message", propagateMessageLocally);
  }
}
function propagateMessageLocally({ data }) {
  if (data && data.type === STORAGE_MUTATED_DOM_EVENT_NAME) {
    propagateLocally(data.changedParts);
  }
}
DexiePromise.rejectionMapper = mapError;
setDebug(debug, dexieStackFrameFilter);

// node_modules/dexie-export-import/dist/dexie-export-import.mjs
function __awaiter(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function(resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function(resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
}
function __generator(thisArg, body) {
  var _ = { label: 0, sent: function() {
    if (t[0] & 1) throw t[1];
    return t[1];
  }, trys: [], ops: [] }, f, y, t, g;
  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
    return this;
  }), g;
  function verb(n) {
    return function(v) {
      return step([n, v]);
    };
  }
  function step(op) {
    if (f) throw new TypeError("Generator is already executing.");
    while (_) try {
      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
      if (y = 0, t) op = [op[0] & 2, t.value];
      switch (op[0]) {
        case 0:
        case 1:
          t = op;
          break;
        case 4:
          _.label++;
          return { value: op[1], done: false };
        case 5:
          _.label++;
          y = op[1];
          op = [0];
          continue;
        case 7:
          op = _.ops.pop();
          _.trys.pop();
          continue;
        default:
          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
            _ = 0;
            continue;
          }
          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
            _.label = op[1];
            break;
          }
          if (op[0] === 6 && _.label < t[1]) {
            _.label = t[1];
            t = op;
            break;
          }
          if (t && _.label < t[2]) {
            _.label = t[2];
            _.ops.push(op);
            break;
          }
          if (t[2]) _.ops.pop();
          _.trys.pop();
          continue;
      }
      op = body.call(thisArg, _);
    } catch (e) {
      op = [6, e];
      y = 0;
    } finally {
      f = t = 0;
    }
    if (op[0] & 5) throw op[1];
    return { value: op[0] ? op[1] : void 0, done: true };
  }
}
function getSchemaString(table) {
  var primKeyAndIndexes = [table.schema.primKey].concat(table.schema.indexes);
  return primKeyAndIndexes.map(function(index) {
    return index.src;
  }).join(",");
}
function extractDbSchema(exportedDb) {
  var schema = {};
  for (var _i = 0, _a = exportedDb.tables; _i < _a.length; _i++) {
    var table = _a[_i];
    schema[table.name] = table.schema;
  }
  return schema;
}
function readBlobAsync(blob, type2) {
  return new Promise(function(resolve, reject) {
    var reader = new FileReader();
    reader.onabort = function(ev) {
      return reject(new Error("file read aborted"));
    };
    reader.onerror = function(ev) {
      return reject(ev.target.error);
    };
    reader.onload = function(ev) {
      return resolve(ev.target.result);
    };
    if (type2 === "binary")
      reader.readAsArrayBuffer(blob);
    else
      reader.readAsText(blob);
  });
}
function readBlobSync(blob, type2) {
  if (typeof FileReaderSync === "undefined") {
    throw new Error("FileReaderSync missing. Reading blobs synchronously requires code to run from within a web worker. Use TSON.encapsulateAsync() to do it from the main thread.");
  }
  var reader = new FileReaderSync();
  var data = type2 === "binary" ? reader.readAsArrayBuffer(blob) : reader.readAsText(blob);
  return data;
}
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function createCommonjsModule(fn, module) {
  return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var typeson = createCommonjsModule(function(module, exports) {
  (function(global2, factory) {
    module.exports = factory();
  })(commonjsGlobal, function() {
    function _typeof(obj) {
      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
        _typeof = function(obj2) {
          return typeof obj2;
        };
      } else {
        _typeof = function(obj2) {
          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
        };
      }
      return _typeof(obj);
    }
    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
      try {
        var info = gen[key](arg);
        var value = info.value;
      } catch (error) {
        reject(error);
        return;
      }
      if (info.done) {
        resolve(value);
      } else {
        Promise.resolve(value).then(_next, _throw);
      }
    }
    function _asyncToGenerator(fn) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve, reject) {
          var gen = fn.apply(self2, args);
          function _next(value) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
          }
          function _throw(err) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
          }
          _next(void 0);
        });
      };
    }
    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    function _defineProperties(target, props2) {
      for (var i = 0; i < props2.length; i++) {
        var descriptor = props2[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    function _defineProperty(obj, key, value) {
      if (key in obj) {
        Object.defineProperty(obj, key, {
          value,
          enumerable: true,
          configurable: true,
          writable: true
        });
      } else {
        obj[key] = value;
      }
      return obj;
    }
    function ownKeys(object, enumerableOnly) {
      var keys3 = Object.keys(object);
      if (Object.getOwnPropertySymbols) {
        var symbols = Object.getOwnPropertySymbols(object);
        if (enumerableOnly) symbols = symbols.filter(function(sym) {
          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
        });
        keys3.push.apply(keys3, symbols);
      }
      return keys3;
    }
    function _objectSpread2(target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i] != null ? arguments[i] : {};
        if (i % 2) {
          ownKeys(Object(source), true).forEach(function(key) {
            _defineProperty(target, key, source[key]);
          });
        } else if (Object.getOwnPropertyDescriptors) {
          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
        } else {
          ownKeys(Object(source)).forEach(function(key) {
            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
          });
        }
      }
      return target;
    }
    function _slicedToArray(arr, i) {
      return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
    }
    function _toConsumableArray(arr) {
      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
    }
    function _arrayWithoutHoles(arr) {
      if (Array.isArray(arr)) {
        for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
        return arr2;
      }
    }
    function _arrayWithHoles(arr) {
      if (Array.isArray(arr)) return arr;
    }
    function _iterableToArray(iter2) {
      if (Symbol.iterator in Object(iter2) || Object.prototype.toString.call(iter2) === "[object Arguments]") return Array.from(iter2);
    }
    function _iterableToArrayLimit(arr, i) {
      if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
        return;
      }
      var _arr = [];
      var _n = true;
      var _d = false;
      var _e = void 0;
      try {
        for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
          _arr.push(_s.value);
          if (i && _arr.length === i) break;
        }
      } catch (err) {
        _d = true;
        _e = err;
      } finally {
        try {
          if (!_n && _i["return"] != null) _i["return"]();
        } finally {
          if (_d) throw _e;
        }
      }
      return _arr;
    }
    function _nonIterableSpread() {
      throw new TypeError("Invalid attempt to spread non-iterable instance");
    }
    function _nonIterableRest() {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
    var TypesonPromise = function TypesonPromise2(f) {
      _classCallCheck(this, TypesonPromise2);
      this.p = new Promise(f);
    };
    TypesonPromise.__typeson__type__ = "TypesonPromise";
    if (typeof Symbol !== "undefined") {
      TypesonPromise.prototype[Symbol.toStringTag] = "TypesonPromise";
    }
    TypesonPromise.prototype.then = function(onFulfilled, onRejected) {
      var _this = this;
      return new TypesonPromise(function(typesonResolve, typesonReject) {
        _this.p.then(function(res) {
          typesonResolve(onFulfilled ? onFulfilled(res) : res);
        })["catch"](function(res) {
          return onRejected ? onRejected(res) : Promise.reject(res);
        }).then(typesonResolve, typesonReject);
      });
    };
    TypesonPromise.prototype["catch"] = function(onRejected) {
      return this.then(null, onRejected);
    };
    TypesonPromise.resolve = function(v) {
      return new TypesonPromise(function(typesonResolve) {
        typesonResolve(v);
      });
    };
    TypesonPromise.reject = function(v) {
      return new TypesonPromise(function(typesonResolve, typesonReject) {
        typesonReject(v);
      });
    };
    ["all", "race"].forEach(function(meth) {
      TypesonPromise[meth] = function(promArr) {
        return new TypesonPromise(function(typesonResolve, typesonReject) {
          Promise[meth](promArr.map(function(prom) {
            return prom && prom.constructor && prom.constructor.__typeson__type__ === "TypesonPromise" ? prom.p : prom;
          })).then(typesonResolve, typesonReject);
        });
      };
    });
    var _ref = {}, toStr = _ref.toString, hasOwn2 = {}.hasOwnProperty, getProto2 = Object.getPrototypeOf, fnToString = hasOwn2.toString;
    function isThenable(v, catchCheck) {
      return isObject(v) && typeof v.then === "function" && (!catchCheck || typeof v["catch"] === "function");
    }
    function toStringTag2(val) {
      return toStr.call(val).slice(8, -1);
    }
    function hasConstructorOf(a, b) {
      if (!a || _typeof(a) !== "object") {
        return false;
      }
      var proto = getProto2(a);
      if (!proto) {
        return b === null;
      }
      var Ctor = hasOwn2.call(proto, "constructor") && proto.constructor;
      if (typeof Ctor !== "function") {
        return b === null;
      }
      if (b === Ctor) {
        return true;
      }
      if (b !== null && fnToString.call(Ctor) === fnToString.call(b)) {
        return true;
      }
      if (typeof b === "function" && typeof Ctor.__typeson__type__ === "string" && Ctor.__typeson__type__ === b.__typeson__type__) {
        return true;
      }
      return false;
    }
    function isPlainObject(val) {
      if (!val || toStringTag2(val) !== "Object") {
        return false;
      }
      var proto = getProto2(val);
      if (!proto) {
        return true;
      }
      return hasConstructorOf(val, Object);
    }
    function isUserObject(val) {
      if (!val || toStringTag2(val) !== "Object") {
        return false;
      }
      var proto = getProto2(val);
      if (!proto) {
        return true;
      }
      return hasConstructorOf(val, Object) || isUserObject(proto);
    }
    function isObject(v) {
      return v && _typeof(v) === "object";
    }
    function escapeKeyPathComponent(keyPathComponent) {
      return keyPathComponent.replace(/~/g, "~0").replace(/\./g, "~1");
    }
    function unescapeKeyPathComponent(keyPathComponent) {
      return keyPathComponent.replace(/~1/g, ".").replace(/~0/g, "~");
    }
    function getByKeyPath2(obj, keyPath) {
      if (keyPath === "") {
        return obj;
      }
      var period = keyPath.indexOf(".");
      if (period > -1) {
        var innerObj = obj[unescapeKeyPathComponent(keyPath.slice(0, period))];
        return innerObj === void 0 ? void 0 : getByKeyPath2(innerObj, keyPath.slice(period + 1));
      }
      return obj[unescapeKeyPathComponent(keyPath)];
    }
    function setAtKeyPath(obj, keyPath, value) {
      if (keyPath === "") {
        return value;
      }
      var period = keyPath.indexOf(".");
      if (period > -1) {
        var innerObj = obj[unescapeKeyPathComponent(keyPath.slice(0, period))];
        return setAtKeyPath(innerObj, keyPath.slice(period + 1), value);
      }
      obj[unescapeKeyPathComponent(keyPath)] = value;
      return obj;
    }
    function getJSONType(value) {
      return value === null ? "null" : Array.isArray(value) ? "array" : _typeof(value);
    }
    var keys2 = Object.keys, isArray2 = Array.isArray, hasOwn$1 = {}.hasOwnProperty, internalStateObjPropsToIgnore = ["type", "replaced", "iterateIn", "iterateUnsetNumeric"];
    function nestedPathsFirst(a, b) {
      if (a.keypath === "") {
        return -1;
      }
      var as = a.keypath.match(/\./g) || 0;
      var bs = b.keypath.match(/\./g) || 0;
      if (as) {
        as = as.length;
      }
      if (bs) {
        bs = bs.length;
      }
      return as > bs ? -1 : as < bs ? 1 : a.keypath < b.keypath ? -1 : a.keypath > b.keypath;
    }
    var Typeson = /* @__PURE__ */ function() {
      function Typeson2(options) {
        _classCallCheck(this, Typeson2);
        this.options = options;
        this.plainObjectReplacers = [];
        this.nonplainObjectReplacers = [];
        this.revivers = {};
        this.types = {};
      }
      _createClass(Typeson2, [{
        key: "stringify",
        value: function stringify(obj, replacer, space, opts) {
          opts = _objectSpread2({}, this.options, {}, opts, {
            stringification: true
          });
          var encapsulated = this.encapsulate(obj, null, opts);
          if (isArray2(encapsulated)) {
            return JSON.stringify(encapsulated[0], replacer, space);
          }
          return encapsulated.then(function(res) {
            return JSON.stringify(res, replacer, space);
          });
        }
        /**
         * Also sync but throws on non-sync result.
         * @param {Any} obj
         * @param {JSONReplacer|string[]} replacer
         * @param {number|string} space
         * @param {object} opts
         * @returns {string}
         */
      }, {
        key: "stringifySync",
        value: function stringifySync(obj, replacer, space, opts) {
          return this.stringify(obj, replacer, space, _objectSpread2({
            throwOnBadSyncType: true
          }, opts, {
            sync: true
          }));
        }
        /**
         *
         * @param {Any} obj
         * @param {JSONReplacer|string[]} replacer
         * @param {number|string} space
         * @param {object} opts
         * @returns {Promise<string>}
         */
      }, {
        key: "stringifyAsync",
        value: function stringifyAsync(obj, replacer, space, opts) {
          return this.stringify(obj, replacer, space, _objectSpread2({
            throwOnBadSyncType: true
          }, opts, {
            sync: false
          }));
        }
        /**
         * Parse Typeson back into an obejct.
         * Initial arguments works identical to those of `JSON.parse()`.
         * @param {string} text
         * @param {function} reviver This JSON reviver has nothing to do with
         *   our revivers.
         * @param {object} opts
         * @returns {external:JSON}
         */
      }, {
        key: "parse",
        value: function parse(text, reviver, opts) {
          opts = _objectSpread2({}, this.options, {}, opts, {
            parse: true
          });
          return this.revive(JSON.parse(text, reviver), opts);
        }
        /**
        * Also sync but throws on non-sync result.
        * @param {string} text
        * @param {function} reviver This JSON reviver has nothing to do with
        *   our revivers.
        * @param {object} opts
        * @returns {external:JSON}
        */
      }, {
        key: "parseSync",
        value: function parseSync(text, reviver, opts) {
          return this.parse(text, reviver, _objectSpread2({
            throwOnBadSyncType: true
          }, opts, {
            sync: true
          }));
        }
        /**
        * @param {string} text
        * @param {function} reviver This JSON reviver has nothing to do with
        *   our revivers.
        * @param {object} opts
        * @returns {Promise} Resolves to `external:JSON`
        */
      }, {
        key: "parseAsync",
        value: function parseAsync(text, reviver, opts) {
          return this.parse(text, reviver, _objectSpread2({
            throwOnBadSyncType: true
          }, opts, {
            sync: false
          }));
        }
        /**
         *
         * @param {Any} obj
         * @param {object} stateObj
         * @param {object} [opts={}]
         * @returns {string[]|false}
         */
      }, {
        key: "specialTypeNames",
        value: function specialTypeNames(obj, stateObj) {
          var opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
          opts.returnTypeNames = true;
          return this.encapsulate(obj, stateObj, opts);
        }
        /**
         *
         * @param {Any} obj
         * @param {PlainObject} stateObj
         * @param {PlainObject} [opts={}]
         * @returns {Promise|GenericArray|PlainObject|string|false}
         */
      }, {
        key: "rootTypeName",
        value: function rootTypeName(obj, stateObj) {
          var opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
          opts.iterateNone = true;
          return this.encapsulate(obj, stateObj, opts);
        }
        /**
         * Encapsulate a complex object into a plain Object by replacing
         * registered types with plain objects representing the types data.
         *
         * This method is used internally by `Typeson.stringify()`.
         * @param {Any} obj - Object to encapsulate.
         * @param {PlainObject} stateObj
         * @param {PlainObject} opts
         * @returns {Promise|GenericArray|PlainObject|string|false}
         */
      }, {
        key: "encapsulate",
        value: function encapsulate(obj, stateObj, opts) {
          opts = _objectSpread2({
            sync: true
          }, this.options, {}, opts);
          var _opts = opts, sync = _opts.sync;
          var that = this, types = {}, refObjs = [], refKeys = [], promisesDataRoot = [];
          var cyclic = "cyclic" in opts ? opts.cyclic : true;
          var _opts2 = opts, encapsulateObserver = _opts2.encapsulateObserver;
          var ret = _encapsulate("", obj, cyclic, stateObj || {}, promisesDataRoot);
          function finish(ret2) {
            var typeNames = Object.values(types);
            if (opts.iterateNone) {
              if (typeNames.length) {
                return typeNames[0];
              }
              return Typeson2.getJSONType(ret2);
            }
            if (typeNames.length) {
              if (opts.returnTypeNames) {
                return _toConsumableArray(new Set(typeNames));
              }
              if (!ret2 || !isPlainObject(ret2) || // Also need to handle if this is an object with its
              //   own `$types` property (to avoid ambiguity)
              hasOwn$1.call(ret2, "$types")) {
                ret2 = {
                  $: ret2,
                  $types: {
                    $: types
                  }
                };
              } else {
                ret2.$types = types;
              }
            } else if (isObject(ret2) && hasOwn$1.call(ret2, "$types")) {
              ret2 = {
                $: ret2,
                $types: true
              };
            }
            if (opts.returnTypeNames) {
              return false;
            }
            return ret2;
          }
          function checkPromises(_x, _x2) {
            return _checkPromises.apply(this, arguments);
          }
          function _checkPromises() {
            _checkPromises = _asyncToGenerator(
              /* @__PURE__ */ regeneratorRuntime.mark(function _callee2(ret2, promisesData) {
                var promResults;
                return regeneratorRuntime.wrap(function _callee2$(_context2) {
                  while (1) {
                    switch (_context2.prev = _context2.next) {
                      case 0:
                        _context2.next = 2;
                        return Promise.all(promisesData.map(function(pd) {
                          return pd[1].p;
                        }));
                      case 2:
                        promResults = _context2.sent;
                        _context2.next = 5;
                        return Promise.all(promResults.map(
                          /* @__PURE__ */ function() {
                            var _ref2 = _asyncToGenerator(
                              /* @__PURE__ */ regeneratorRuntime.mark(function _callee(promResult) {
                                var newPromisesData, _promisesData$splice, _promisesData$splice2, prData, _prData, keyPath, cyclic2, stateObj2, parentObj, key, detectedType, encaps, isTypesonPromise, encaps2;
                                return regeneratorRuntime.wrap(function _callee$(_context) {
                                  while (1) {
                                    switch (_context.prev = _context.next) {
                                      case 0:
                                        newPromisesData = [];
                                        _promisesData$splice = promisesData.splice(0, 1), _promisesData$splice2 = _slicedToArray(_promisesData$splice, 1), prData = _promisesData$splice2[0];
                                        _prData = _slicedToArray(prData, 7), keyPath = _prData[0], cyclic2 = _prData[2], stateObj2 = _prData[3], parentObj = _prData[4], key = _prData[5], detectedType = _prData[6];
                                        encaps = _encapsulate(keyPath, promResult, cyclic2, stateObj2, newPromisesData, true, detectedType);
                                        isTypesonPromise = hasConstructorOf(encaps, TypesonPromise);
                                        if (!(keyPath && isTypesonPromise)) {
                                          _context.next = 11;
                                          break;
                                        }
                                        _context.next = 8;
                                        return encaps.p;
                                      case 8:
                                        encaps2 = _context.sent;
                                        parentObj[key] = encaps2;
                                        return _context.abrupt("return", checkPromises(ret2, newPromisesData));
                                      case 11:
                                        if (keyPath) {
                                          parentObj[key] = encaps;
                                        } else if (isTypesonPromise) {
                                          ret2 = encaps.p;
                                        } else {
                                          ret2 = encaps;
                                        }
                                        return _context.abrupt("return", checkPromises(ret2, newPromisesData));
                                      case 13:
                                      case "end":
                                        return _context.stop();
                                    }
                                  }
                                }, _callee);
                              })
                            );
                            return function(_x3) {
                              return _ref2.apply(this, arguments);
                            };
                          }()
                        ));
                      case 5:
                        return _context2.abrupt("return", ret2);
                      case 6:
                      case "end":
                        return _context2.stop();
                    }
                  }
                }, _callee2);
              })
            );
            return _checkPromises.apply(this, arguments);
          }
          function _adaptBuiltinStateObjectProperties(stateObj2, ownKeysObj, cb) {
            Object.assign(stateObj2, ownKeysObj);
            var vals = internalStateObjPropsToIgnore.map(function(prop) {
              var tmp = stateObj2[prop];
              delete stateObj2[prop];
              return tmp;
            });
            cb();
            internalStateObjPropsToIgnore.forEach(function(prop, i) {
              stateObj2[prop] = vals[i];
            });
          }
          function _encapsulate(keypath, value, cyclic2, stateObj2, promisesData, resolvingTypesonPromise, detectedType) {
            var ret2;
            var observerData = {};
            var $typeof = _typeof(value);
            var runObserver = encapsulateObserver ? function(obj2) {
              var type2 = detectedType || stateObj2.type || Typeson2.getJSONType(value);
              encapsulateObserver(Object.assign(obj2 || observerData, {
                keypath,
                value,
                cyclic: cyclic2,
                stateObj: stateObj2,
                promisesData,
                resolvingTypesonPromise,
                awaitingTypesonPromise: hasConstructorOf(value, TypesonPromise)
              }, {
                type: type2
              }));
            } : null;
            if (["string", "boolean", "number", "undefined"].includes($typeof)) {
              if (value === void 0 || $typeof === "number" && (isNaN(value) || value === -Infinity || value === Infinity)) {
                if (stateObj2.replaced) {
                  ret2 = value;
                } else {
                  ret2 = replace(keypath, value, stateObj2, promisesData, false, resolvingTypesonPromise, runObserver);
                }
                if (ret2 !== value) {
                  observerData = {
                    replaced: ret2
                  };
                }
              } else {
                ret2 = value;
              }
              if (runObserver) {
                runObserver();
              }
              return ret2;
            }
            if (value === null) {
              if (runObserver) {
                runObserver();
              }
              return value;
            }
            if (cyclic2 && !stateObj2.iterateIn && !stateObj2.iterateUnsetNumeric && value && _typeof(value) === "object") {
              var refIndex = refObjs.indexOf(value);
              if (refIndex < 0) {
                if (cyclic2 === true) {
                  refObjs.push(value);
                  refKeys.push(keypath);
                }
              } else {
                types[keypath] = "#";
                if (runObserver) {
                  runObserver({
                    cyclicKeypath: refKeys[refIndex]
                  });
                }
                return "#" + refKeys[refIndex];
              }
            }
            var isPlainObj = isPlainObject(value);
            var isArr = isArray2(value);
            var replaced = (
              // Running replace will cause infinite loop as will test
              //   positive again
              (isPlainObj || isArr) && (!that.plainObjectReplacers.length || stateObj2.replaced) || stateObj2.iterateIn ? (
                // Optimization: if plain object and no plain-object
                //   replacers, don't try finding a replacer
                value
              ) : replace(keypath, value, stateObj2, promisesData, isPlainObj || isArr, null, runObserver)
            );
            var clone;
            if (replaced !== value) {
              ret2 = replaced;
              observerData = {
                replaced
              };
            } else {
              if (keypath === "" && hasConstructorOf(value, TypesonPromise)) {
                promisesData.push([keypath, value, cyclic2, stateObj2, void 0, void 0, stateObj2.type]);
                ret2 = value;
              } else if (isArr && stateObj2.iterateIn !== "object" || stateObj2.iterateIn === "array") {
                clone = new Array(value.length);
                observerData = {
                  clone
                };
              } else if (!["function", "symbol"].includes(_typeof(value)) && !("toJSON" in value) && !hasConstructorOf(value, TypesonPromise) && !hasConstructorOf(value, Promise) && !hasConstructorOf(value, ArrayBuffer) || isPlainObj || stateObj2.iterateIn === "object") {
                clone = {};
                if (stateObj2.addLength) {
                  clone.length = value.length;
                }
                observerData = {
                  clone
                };
              } else {
                ret2 = value;
              }
            }
            if (runObserver) {
              runObserver();
            }
            if (opts.iterateNone) {
              return clone || ret2;
            }
            if (!clone) {
              return ret2;
            }
            if (stateObj2.iterateIn) {
              var _loop = function _loop3(key2) {
                var ownKeysObj = {
                  ownKeys: hasOwn$1.call(value, key2)
                };
                _adaptBuiltinStateObjectProperties(stateObj2, ownKeysObj, function() {
                  var kp = keypath + (keypath ? "." : "") + escapeKeyPathComponent(key2);
                  var val = _encapsulate(kp, value[key2], Boolean(cyclic2), stateObj2, promisesData, resolvingTypesonPromise);
                  if (hasConstructorOf(val, TypesonPromise)) {
                    promisesData.push([kp, val, Boolean(cyclic2), stateObj2, clone, key2, stateObj2.type]);
                  } else if (val !== void 0) {
                    clone[key2] = val;
                  }
                });
              };
              for (var key in value) {
                _loop(key);
              }
              if (runObserver) {
                runObserver({
                  endIterateIn: true,
                  end: true
                });
              }
            } else {
              keys2(value).forEach(function(key2) {
                var kp = keypath + (keypath ? "." : "") + escapeKeyPathComponent(key2);
                var ownKeysObj = {
                  ownKeys: true
                };
                _adaptBuiltinStateObjectProperties(stateObj2, ownKeysObj, function() {
                  var val = _encapsulate(kp, value[key2], Boolean(cyclic2), stateObj2, promisesData, resolvingTypesonPromise);
                  if (hasConstructorOf(val, TypesonPromise)) {
                    promisesData.push([kp, val, Boolean(cyclic2), stateObj2, clone, key2, stateObj2.type]);
                  } else if (val !== void 0) {
                    clone[key2] = val;
                  }
                });
              });
              if (runObserver) {
                runObserver({
                  endIterateOwn: true,
                  end: true
                });
              }
            }
            if (stateObj2.iterateUnsetNumeric) {
              var vl = value.length;
              var _loop2 = function _loop22(i2) {
                if (!(i2 in value)) {
                  var kp = keypath + (keypath ? "." : "") + i2;
                  var ownKeysObj = {
                    ownKeys: false
                  };
                  _adaptBuiltinStateObjectProperties(stateObj2, ownKeysObj, function() {
                    var val = _encapsulate(kp, void 0, Boolean(cyclic2), stateObj2, promisesData, resolvingTypesonPromise);
                    if (hasConstructorOf(val, TypesonPromise)) {
                      promisesData.push([kp, val, Boolean(cyclic2), stateObj2, clone, i2, stateObj2.type]);
                    } else if (val !== void 0) {
                      clone[i2] = val;
                    }
                  });
                }
              };
              for (var i = 0; i < vl; i++) {
                _loop2(i);
              }
              if (runObserver) {
                runObserver({
                  endIterateUnsetNumeric: true,
                  end: true
                });
              }
            }
            return clone;
          }
          function replace(keypath, value, stateObj2, promisesData, plainObject, resolvingTypesonPromise, runObserver) {
            var replacers = plainObject ? that.plainObjectReplacers : that.nonplainObjectReplacers;
            var i = replacers.length;
            while (i--) {
              var replacer = replacers[i];
              if (replacer.test(value, stateObj2)) {
                var type2 = replacer.type;
                if (that.revivers[type2]) {
                  var existing = types[keypath];
                  types[keypath] = existing ? [type2].concat(existing) : type2;
                }
                Object.assign(stateObj2, {
                  type: type2,
                  replaced: true
                });
                if ((sync || !replacer.replaceAsync) && !replacer.replace) {
                  if (runObserver) {
                    runObserver({
                      typeDetected: true
                    });
                  }
                  return _encapsulate(keypath, value, cyclic && "readonly", stateObj2, promisesData, resolvingTypesonPromise, type2);
                }
                if (runObserver) {
                  runObserver({
                    replacing: true
                  });
                }
                var replaceMethod = sync || !replacer.replaceAsync ? "replace" : "replaceAsync";
                return _encapsulate(keypath, replacer[replaceMethod](value, stateObj2), cyclic && "readonly", stateObj2, promisesData, resolvingTypesonPromise, type2);
              }
            }
            return value;
          }
          return promisesDataRoot.length ? sync && opts.throwOnBadSyncType ? function() {
            throw new TypeError("Sync method requested but async result obtained");
          }() : Promise.resolve(checkPromises(ret, promisesDataRoot)).then(finish) : !sync && opts.throwOnBadSyncType ? function() {
            throw new TypeError("Async method requested but sync result obtained");
          }() : opts.stringification && sync ? [finish(ret)] : sync ? finish(ret) : Promise.resolve(finish(ret));
        }
        /**
         * Also sync but throws on non-sync result.
         * @param {*} obj
         * @param {object} stateObj
         * @param {object} opts
         * @returns {*}
         */
      }, {
        key: "encapsulateSync",
        value: function encapsulateSync(obj, stateObj, opts) {
          return this.encapsulate(obj, stateObj, _objectSpread2({
            throwOnBadSyncType: true
          }, opts, {
            sync: true
          }));
        }
        /**
         * @param {*} obj
         * @param {object} stateObj
         * @param {object} opts
         * @returns {*}
         */
      }, {
        key: "encapsulateAsync",
        value: function encapsulateAsync(obj, stateObj, opts) {
          return this.encapsulate(obj, stateObj, _objectSpread2({
            throwOnBadSyncType: true
          }, opts, {
            sync: false
          }));
        }
        /**
         * Revive an encapsulated object.
         * This method is used internally by `Typeson.parse()`.
         * @param {object} obj - Object to revive. If it has `$types` member, the
         *   properties that are listed there will be replaced with its true type
         *   instead of just plain objects.
         * @param {object} opts
         * @throws TypeError If mismatch between sync/async type and result
         * @returns {Promise|*} If async, returns a Promise that resolves to `*`
         */
      }, {
        key: "revive",
        value: function revive(obj, opts) {
          var types = obj && obj.$types;
          if (!types) {
            return obj;
          }
          if (types === true) {
            return obj.$;
          }
          opts = _objectSpread2({
            sync: true
          }, this.options, {}, opts);
          var _opts3 = opts, sync = _opts3.sync;
          var keyPathResolutions = [];
          var stateObj = {};
          var ignore$Types = true;
          if (types.$ && isPlainObject(types.$)) {
            obj = obj.$;
            types = types.$;
            ignore$Types = false;
          }
          var that = this;
          function executeReviver(type2, val) {
            var _ref2 = that.revivers[type2] || [], _ref3 = _slicedToArray(_ref2, 1), reviver = _ref3[0];
            if (!reviver) {
              throw new Error("Unregistered type: " + type2);
            }
            if (sync && !("revive" in reviver)) {
              return val;
            }
            return reviver[sync && reviver.revive ? "revive" : !sync && reviver.reviveAsync ? "reviveAsync" : "revive"](val, stateObj);
          }
          function revivePlainObjects() {
            var plainObjectTypes = [];
            Object.entries(types).forEach(function(_ref4) {
              var _ref5 = _slicedToArray(_ref4, 2), keypath = _ref5[0], type2 = _ref5[1];
              if (type2 === "#") {
                return;
              }
              [].concat(type2).forEach(function(type3) {
                var _ref6 = that.revivers[type3] || [null, {}], _ref7 = _slicedToArray(_ref6, 2), plain = _ref7[1].plain;
                if (!plain) {
                  return;
                }
                plainObjectTypes.push({
                  keypath,
                  type: type3
                });
                delete types[keypath];
              });
            });
            if (!plainObjectTypes.length) {
              return void 0;
            }
            return plainObjectTypes.sort(nestedPathsFirst).reduce(
              function reducer(possibleTypesonPromise2, _ref8) {
                var keypath = _ref8.keypath, type2 = _ref8.type;
                if (isThenable(possibleTypesonPromise2)) {
                  return possibleTypesonPromise2.then(function(val2) {
                    return reducer(val2, {
                      keypath,
                      type: type2
                    });
                  });
                }
                var val = getByKeyPath2(obj, keypath);
                val = executeReviver(type2, val);
                if (hasConstructorOf(val, TypesonPromise)) {
                  return val.then(function(v) {
                    var newVal2 = setAtKeyPath(obj, keypath, v);
                    if (newVal2 === v) {
                      obj = newVal2;
                    }
                    return void 0;
                  });
                }
                var newVal = setAtKeyPath(obj, keypath, val);
                if (newVal === val) {
                  obj = newVal;
                }
                return void 0;
              },
              void 0
              // This argument must be explicit
            );
          }
          var revivalPromises = [];
          function _revive(keypath, value, target, clone, key) {
            if (ignore$Types && keypath === "$types") {
              return void 0;
            }
            var type2 = types[keypath];
            var isArr = isArray2(value);
            if (isArr || isPlainObject(value)) {
              var _clone = isArr ? new Array(value.length) : {};
              keys2(value).forEach(function(k2) {
                var val2 = _revive(keypath + (keypath ? "." : "") + escapeKeyPathComponent(k2), value[k2], target || _clone, _clone, k2);
                var set = function set2(v) {
                  if (hasConstructorOf(v, Undefined)) {
                    _clone[k2] = void 0;
                  } else if (v !== void 0) {
                    _clone[k2] = v;
                  }
                  return v;
                };
                if (hasConstructorOf(val2, TypesonPromise)) {
                  revivalPromises.push(val2.then(function(ret2) {
                    return set(ret2);
                  }));
                } else {
                  set(val2);
                }
              });
              value = _clone;
              while (keyPathResolutions.length) {
                var _keyPathResolutions$ = _slicedToArray(keyPathResolutions[0], 4), _target = _keyPathResolutions$[0], keyPath = _keyPathResolutions$[1], _clone2 = _keyPathResolutions$[2], k = _keyPathResolutions$[3];
                var val = getByKeyPath2(_target, keyPath);
                if (val !== void 0) {
                  _clone2[k] = val;
                } else {
                  break;
                }
                keyPathResolutions.splice(0, 1);
              }
            }
            if (!type2) {
              return value;
            }
            if (type2 === "#") {
              var _ret = getByKeyPath2(target, value.slice(1));
              if (_ret === void 0) {
                keyPathResolutions.push([target, value.slice(1), clone, key]);
              }
              return _ret;
            }
            return [].concat(type2).reduce(function reducer(val2, typ) {
              if (hasConstructorOf(val2, TypesonPromise)) {
                return val2.then(function(v) {
                  return reducer(v, typ);
                });
              }
              return executeReviver(typ, val2);
            }, value);
          }
          function checkUndefined(retrn) {
            return hasConstructorOf(retrn, Undefined) ? void 0 : retrn;
          }
          var possibleTypesonPromise = revivePlainObjects();
          var ret;
          if (hasConstructorOf(possibleTypesonPromise, TypesonPromise)) {
            ret = possibleTypesonPromise.then(function() {
              return obj;
            });
          } else {
            ret = _revive("", obj, null);
            if (revivalPromises.length) {
              ret = TypesonPromise.resolve(ret).then(function(r) {
                return TypesonPromise.all([
                  // May be a TypesonPromise or not
                  r
                ].concat(revivalPromises));
              }).then(function(_ref9) {
                var _ref10 = _slicedToArray(_ref9, 1), r = _ref10[0];
                return r;
              });
            }
          }
          return isThenable(ret) ? sync && opts.throwOnBadSyncType ? function() {
            throw new TypeError("Sync method requested but async result obtained");
          }() : hasConstructorOf(ret, TypesonPromise) ? ret.p.then(checkUndefined) : ret : !sync && opts.throwOnBadSyncType ? function() {
            throw new TypeError("Async method requested but sync result obtained");
          }() : sync ? checkUndefined(ret) : Promise.resolve(checkUndefined(ret));
        }
        /**
         * Also sync but throws on non-sync result.
         * @param {Any} obj
         * @param {object} opts
         * @returns {Any}
         */
      }, {
        key: "reviveSync",
        value: function reviveSync(obj, opts) {
          return this.revive(obj, _objectSpread2({
            throwOnBadSyncType: true
          }, opts, {
            sync: true
          }));
        }
        /**
        * @param {Any} obj
        * @param {object} opts
        * @returns {Promise} Resolves to `*`
        */
      }, {
        key: "reviveAsync",
        value: function reviveAsync(obj, opts) {
          return this.revive(obj, _objectSpread2({
            throwOnBadSyncType: true
          }, opts, {
            sync: false
          }));
        }
        /**
         * Register types.
         * For examples on how to use this method, see
         *   {@link https://github.com/dfahlander/typeson-registry/tree/master/types}.
         * @param {object.<string,Function[]>[]} typeSpecSets - Types and
         *   their functions [test, encapsulate, revive];
         * @param {object} opts
         * @returns {Typeson}
         */
      }, {
        key: "register",
        value: function register(typeSpecSets, opts) {
          opts = opts || {};
          [].concat(typeSpecSets).forEach(function R(typeSpec) {
            var _this = this;
            if (isArray2(typeSpec)) {
              return typeSpec.map(function(typSpec) {
                return R.call(_this, typSpec);
              });
            }
            typeSpec && keys2(typeSpec).forEach(function(typeId) {
              if (typeId === "#") {
                throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");
              } else if (Typeson2.JSON_TYPES.includes(typeId)) {
                throw new TypeError("Plain JSON object types are reserved as type names");
              }
              var spec = typeSpec[typeId];
              var replacers = spec && spec.testPlainObjects ? this.plainObjectReplacers : this.nonplainObjectReplacers;
              var existingReplacer = replacers.filter(function(r) {
                return r.type === typeId;
              });
              if (existingReplacer.length) {
                replacers.splice(replacers.indexOf(existingReplacer[0]), 1);
                delete this.revivers[typeId];
                delete this.types[typeId];
              }
              if (typeof spec === "function") {
                var Class = spec;
                spec = {
                  test: function test2(x) {
                    return x && x.constructor === Class;
                  },
                  replace: function replace2(x) {
                    return _objectSpread2({}, x);
                  },
                  revive: function revive2(x) {
                    return Object.assign(Object.create(Class.prototype), x);
                  }
                };
              } else if (isArray2(spec)) {
                var _spec = spec, _spec2 = _slicedToArray(_spec, 3), test = _spec2[0], replace = _spec2[1], revive = _spec2[2];
                spec = {
                  test,
                  replace,
                  revive
                };
              }
              if (!spec || !spec.test) {
                return;
              }
              var replacerObj = {
                type: typeId,
                test: spec.test.bind(spec)
              };
              if (spec.replace) {
                replacerObj.replace = spec.replace.bind(spec);
              }
              if (spec.replaceAsync) {
                replacerObj.replaceAsync = spec.replaceAsync.bind(spec);
              }
              var start = typeof opts.fallback === "number" ? opts.fallback : opts.fallback ? 0 : Infinity;
              if (spec.testPlainObjects) {
                this.plainObjectReplacers.splice(start, 0, replacerObj);
              } else {
                this.nonplainObjectReplacers.splice(start, 0, replacerObj);
              }
              if (spec.revive || spec.reviveAsync) {
                var reviverObj = {};
                if (spec.revive) {
                  reviverObj.revive = spec.revive.bind(spec);
                }
                if (spec.reviveAsync) {
                  reviverObj.reviveAsync = spec.reviveAsync.bind(spec);
                }
                this.revivers[typeId] = [reviverObj, {
                  plain: spec.testPlainObjects
                }];
              }
              this.types[typeId] = spec;
            }, this);
          }, this);
          return this;
        }
      }]);
      return Typeson2;
    }();
    var Undefined = function Undefined2() {
      _classCallCheck(this, Undefined2);
    };
    Undefined.__typeson__type__ = "TypesonUndefined";
    Typeson.Undefined = Undefined;
    Typeson.Promise = TypesonPromise;
    Typeson.isThenable = isThenable;
    Typeson.toStringTag = toStringTag2;
    Typeson.hasConstructorOf = hasConstructorOf;
    Typeson.isObject = isObject;
    Typeson.isPlainObject = isPlainObject;
    Typeson.isUserObject = isUserObject;
    Typeson.escapeKeyPathComponent = escapeKeyPathComponent;
    Typeson.unescapeKeyPathComponent = unescapeKeyPathComponent;
    Typeson.getByKeyPath = getByKeyPath2;
    Typeson.getJSONType = getJSONType;
    Typeson.JSON_TYPES = ["null", "boolean", "number", "string", "array", "object"];
    return Typeson;
  });
});
var structuredCloning = createCommonjsModule(function(module, exports) {
  !function(e, t) {
    module.exports = t();
  }(commonjsGlobal, function() {
    function _typeof$1(e2) {
      return (_typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e3) {
        return typeof e3;
      } : function(e3) {
        return e3 && "function" == typeof Symbol && e3.constructor === Symbol && e3 !== Symbol.prototype ? "symbol" : typeof e3;
      })(e2);
    }
    function _classCallCheck$1(e2, t2) {
      if (!(e2 instanceof t2)) throw new TypeError("Cannot call a class as a function");
    }
    function _defineProperties$1(e2, t2) {
      for (var r2 = 0; r2 < t2.length; r2++) {
        var n2 = t2[r2];
        n2.enumerable = n2.enumerable || false, n2.configurable = true, "value" in n2 && (n2.writable = true), Object.defineProperty(e2, n2.key, n2);
      }
    }
    function _defineProperty$1(e2, t2, r2) {
      return t2 in e2 ? Object.defineProperty(e2, t2, { value: r2, enumerable: true, configurable: true, writable: true }) : e2[t2] = r2, e2;
    }
    function ownKeys$1(e2, t2) {
      var r2 = Object.keys(e2);
      if (Object.getOwnPropertySymbols) {
        var n2 = Object.getOwnPropertySymbols(e2);
        t2 && (n2 = n2.filter(function(t3) {
          return Object.getOwnPropertyDescriptor(e2, t3).enumerable;
        })), r2.push.apply(r2, n2);
      }
      return r2;
    }
    function _toConsumableArray$1(e2) {
      return function _arrayWithoutHoles$1(e3) {
        if (Array.isArray(e3)) return _arrayLikeToArray$1(e3);
      }(e2) || function _iterableToArray$1(e3) {
        if ("undefined" != typeof Symbol && Symbol.iterator in Object(e3)) return Array.from(e3);
      }(e2) || function _unsupportedIterableToArray$1(e3, t2) {
        if (!e3) return;
        if ("string" == typeof e3) return _arrayLikeToArray$1(e3, t2);
        var r2 = Object.prototype.toString.call(e3).slice(8, -1);
        "Object" === r2 && e3.constructor && (r2 = e3.constructor.name);
        if ("Map" === r2 || "Set" === r2) return Array.from(e3);
        if ("Arguments" === r2 || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r2)) return _arrayLikeToArray$1(e3, t2);
      }(e2) || function _nonIterableSpread$1() {
        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }();
    }
    function _arrayLikeToArray$1(e2, t2) {
      (null == t2 || t2 > e2.length) && (t2 = e2.length);
      for (var r2 = 0, n2 = new Array(t2); r2 < t2; r2++) n2[r2] = e2[r2];
      return n2;
    }
    function _typeof(e2) {
      return (_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function _typeof2(e3) {
        return typeof e3;
      } : function _typeof2(e3) {
        return e3 && "function" == typeof Symbol && e3.constructor === Symbol && e3 !== Symbol.prototype ? "symbol" : typeof e3;
      })(e2);
    }
    function _classCallCheck(e2, t2) {
      if (!(e2 instanceof t2)) throw new TypeError("Cannot call a class as a function");
    }
    function _defineProperties(e2, t2) {
      for (var r2 = 0; r2 < t2.length; r2++) {
        var n2 = t2[r2];
        n2.enumerable = n2.enumerable || false, n2.configurable = true, "value" in n2 && (n2.writable = true), Object.defineProperty(e2, n2.key, n2);
      }
    }
    function _defineProperty(e2, t2, r2) {
      return t2 in e2 ? Object.defineProperty(e2, t2, { value: r2, enumerable: true, configurable: true, writable: true }) : e2[t2] = r2, e2;
    }
    function ownKeys(e2, t2) {
      var r2 = Object.keys(e2);
      if (Object.getOwnPropertySymbols) {
        var n2 = Object.getOwnPropertySymbols(e2);
        t2 && (n2 = n2.filter(function(t3) {
          return Object.getOwnPropertyDescriptor(e2, t3).enumerable;
        })), r2.push.apply(r2, n2);
      }
      return r2;
    }
    function _objectSpread2(e2) {
      for (var t2 = 1; t2 < arguments.length; t2++) {
        var r2 = null != arguments[t2] ? arguments[t2] : {};
        t2 % 2 ? ownKeys(Object(r2), true).forEach(function(t3) {
          _defineProperty(e2, t3, r2[t3]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e2, Object.getOwnPropertyDescriptors(r2)) : ownKeys(Object(r2)).forEach(function(t3) {
          Object.defineProperty(e2, t3, Object.getOwnPropertyDescriptor(r2, t3));
        });
      }
      return e2;
    }
    function _slicedToArray(e2, t2) {
      return function _arrayWithHoles(e3) {
        if (Array.isArray(e3)) return e3;
      }(e2) || function _iterableToArrayLimit(e3, t3) {
        if ("undefined" == typeof Symbol || !(Symbol.iterator in Object(e3))) return;
        var r2 = [], n2 = true, i2 = false, o2 = void 0;
        try {
          for (var a2, c2 = e3[Symbol.iterator](); !(n2 = (a2 = c2.next()).done) && (r2.push(a2.value), !t3 || r2.length !== t3); n2 = true) ;
        } catch (e4) {
          i2 = true, o2 = e4;
        } finally {
          try {
            n2 || null == c2.return || c2.return();
          } finally {
            if (i2) throw o2;
          }
        }
        return r2;
      }(e2, t2) || _unsupportedIterableToArray(e2, t2) || function _nonIterableRest() {
        throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }();
    }
    function _toConsumableArray(e2) {
      return function _arrayWithoutHoles(e3) {
        if (Array.isArray(e3)) return _arrayLikeToArray(e3);
      }(e2) || function _iterableToArray(e3) {
        if ("undefined" != typeof Symbol && Symbol.iterator in Object(e3)) return Array.from(e3);
      }(e2) || _unsupportedIterableToArray(e2) || function _nonIterableSpread() {
        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }();
    }
    function _unsupportedIterableToArray(e2, t2) {
      if (e2) {
        if ("string" == typeof e2) return _arrayLikeToArray(e2, t2);
        var r2 = Object.prototype.toString.call(e2).slice(8, -1);
        return "Object" === r2 && e2.constructor && (r2 = e2.constructor.name), "Map" === r2 || "Set" === r2 ? Array.from(e2) : "Arguments" === r2 || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r2) ? _arrayLikeToArray(e2, t2) : void 0;
      }
    }
    function _arrayLikeToArray(e2, t2) {
      (null == t2 || t2 > e2.length) && (t2 = e2.length);
      for (var r2 = 0, n2 = new Array(t2); r2 < t2; r2++) n2[r2] = e2[r2];
      return n2;
    }
    var e = function TypesonPromise(e2) {
      _classCallCheck(this, TypesonPromise), this.p = new Promise(e2);
    };
    e.__typeson__type__ = "TypesonPromise", "undefined" != typeof Symbol && (e.prototype[Symbol.toStringTag] = "TypesonPromise"), e.prototype.then = function(t2, r2) {
      var n2 = this;
      return new e(function(e2, i2) {
        n2.p.then(function(r3) {
          e2(t2 ? t2(r3) : r3);
        }).catch(function(e3) {
          return r2 ? r2(e3) : Promise.reject(e3);
        }).then(e2, i2);
      });
    }, e.prototype.catch = function(e2) {
      return this.then(null, e2);
    }, e.resolve = function(t2) {
      return new e(function(e2) {
        e2(t2);
      });
    }, e.reject = function(t2) {
      return new e(function(e2, r2) {
        r2(t2);
      });
    }, ["all", "race"].forEach(function(t2) {
      e[t2] = function(r2) {
        return new e(function(e2, n2) {
          Promise[t2](r2.map(function(e3) {
            return e3 && e3.constructor && "TypesonPromise" === e3.constructor.__typeson__type__ ? e3.p : e3;
          })).then(e2, n2);
        });
      };
    });
    var t = {}.toString, r = {}.hasOwnProperty, n = Object.getPrototypeOf, i = r.toString;
    function isThenable(e2, t2) {
      return isObject(e2) && "function" == typeof e2.then && (!t2 || "function" == typeof e2.catch);
    }
    function toStringTag2(e2) {
      return t.call(e2).slice(8, -1);
    }
    function hasConstructorOf(e2, t2) {
      if (!e2 || "object" !== _typeof(e2)) return false;
      var o2 = n(e2);
      if (!o2) return null === t2;
      var a2 = r.call(o2, "constructor") && o2.constructor;
      return "function" != typeof a2 ? null === t2 : t2 === a2 || (null !== t2 && i.call(a2) === i.call(t2) || "function" == typeof t2 && "string" == typeof a2.__typeson__type__ && a2.__typeson__type__ === t2.__typeson__type__);
    }
    function isPlainObject(e2) {
      return !(!e2 || "Object" !== toStringTag2(e2)) && (!n(e2) || hasConstructorOf(e2, Object));
    }
    function isObject(e2) {
      return e2 && "object" === _typeof(e2);
    }
    function escapeKeyPathComponent(e2) {
      return e2.replace(/~/g, "~0").replace(/\./g, "~1");
    }
    function unescapeKeyPathComponent(e2) {
      return e2.replace(/~1/g, ".").replace(/~0/g, "~");
    }
    function getByKeyPath2(e2, t2) {
      if ("" === t2) return e2;
      var r2 = t2.indexOf(".");
      if (r2 > -1) {
        var n2 = e2[unescapeKeyPathComponent(t2.slice(0, r2))];
        return void 0 === n2 ? void 0 : getByKeyPath2(n2, t2.slice(r2 + 1));
      }
      return e2[unescapeKeyPathComponent(t2)];
    }
    function setAtKeyPath(e2, t2, r2) {
      if ("" === t2) return r2;
      var n2 = t2.indexOf(".");
      return n2 > -1 ? setAtKeyPath(e2[unescapeKeyPathComponent(t2.slice(0, n2))], t2.slice(n2 + 1), r2) : (e2[unescapeKeyPathComponent(t2)] = r2, e2);
    }
    function _await(e2, t2, r2) {
      return r2 ? t2 ? t2(e2) : e2 : (e2 && e2.then || (e2 = Promise.resolve(e2)), t2 ? e2.then(t2) : e2);
    }
    var o = Object.keys, a = Array.isArray, c = {}.hasOwnProperty, u = ["type", "replaced", "iterateIn", "iterateUnsetNumeric"];
    function _async(e2) {
      return function() {
        for (var t2 = [], r2 = 0; r2 < arguments.length; r2++) t2[r2] = arguments[r2];
        try {
          return Promise.resolve(e2.apply(this, t2));
        } catch (e3) {
          return Promise.reject(e3);
        }
      };
    }
    function nestedPathsFirst(e2, t2) {
      if ("" === e2.keypath) return -1;
      var r2 = e2.keypath.match(/\./g) || 0, n2 = t2.keypath.match(/\./g) || 0;
      return r2 && (r2 = r2.length), n2 && (n2 = n2.length), r2 > n2 ? -1 : r2 < n2 ? 1 : e2.keypath < t2.keypath ? -1 : e2.keypath > t2.keypath;
    }
    var s = function() {
      function Typeson(e2) {
        _classCallCheck(this, Typeson), this.options = e2, this.plainObjectReplacers = [], this.nonplainObjectReplacers = [], this.revivers = {}, this.types = {};
      }
      return function _createClass(e2, t2, r2) {
        return t2 && _defineProperties(e2.prototype, t2), r2 && _defineProperties(e2, r2), e2;
      }(Typeson, [{ key: "stringify", value: function stringify(e2, t2, r2, n2) {
        n2 = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), n2), {}, { stringification: true });
        var i2 = this.encapsulate(e2, null, n2);
        return a(i2) ? JSON.stringify(i2[0], t2, r2) : i2.then(function(e3) {
          return JSON.stringify(e3, t2, r2);
        });
      } }, { key: "stringifySync", value: function stringifySync(e2, t2, r2, n2) {
        return this.stringify(e2, t2, r2, _objectSpread2(_objectSpread2({ throwOnBadSyncType: true }, n2), {}, { sync: true }));
      } }, { key: "stringifyAsync", value: function stringifyAsync(e2, t2, r2, n2) {
        return this.stringify(e2, t2, r2, _objectSpread2(_objectSpread2({ throwOnBadSyncType: true }, n2), {}, { sync: false }));
      } }, { key: "parse", value: function parse(e2, t2, r2) {
        return r2 = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), r2), {}, { parse: true }), this.revive(JSON.parse(e2, t2), r2);
      } }, { key: "parseSync", value: function parseSync(e2, t2, r2) {
        return this.parse(e2, t2, _objectSpread2(_objectSpread2({ throwOnBadSyncType: true }, r2), {}, { sync: true }));
      } }, { key: "parseAsync", value: function parseAsync(e2, t2, r2) {
        return this.parse(e2, t2, _objectSpread2(_objectSpread2({ throwOnBadSyncType: true }, r2), {}, { sync: false }));
      } }, { key: "specialTypeNames", value: function specialTypeNames(e2, t2) {
        var r2 = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
        return r2.returnTypeNames = true, this.encapsulate(e2, t2, r2);
      } }, { key: "rootTypeName", value: function rootTypeName(e2, t2) {
        var r2 = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
        return r2.iterateNone = true, this.encapsulate(e2, t2, r2);
      } }, { key: "encapsulate", value: function encapsulate(t2, r2, n2) {
        var i2 = _async(function(t3, r3) {
          return _await(Promise.all(r3.map(function(e2) {
            return e2[1].p;
          })), function(n3) {
            return _await(Promise.all(n3.map(_async(function(n4) {
              var o2 = false, a2 = [], c2 = _slicedToArray(r3.splice(0, 1), 1), u2 = _slicedToArray(c2[0], 7), s3 = u2[0], f3 = u2[2], l3 = u2[3], p3 = u2[4], y3 = u2[5], v3 = u2[6], b3 = _encapsulate(s3, n4, f3, l3, a2, true, v3), d3 = hasConstructorOf(b3, e);
              return function _invoke(e2, t4) {
                var r4 = e2();
                return r4 && r4.then ? r4.then(t4) : t4(r4);
              }(function() {
                if (s3 && d3) return _await(b3.p, function(e2) {
                  return p3[y3] = e2, o2 = true, i2(t3, a2);
                });
              }, function(e2) {
                return o2 ? e2 : (s3 ? p3[y3] = b3 : t3 = d3 ? b3.p : b3, i2(t3, a2));
              });
            }))), function() {
              return t3;
            });
          });
        }), s2 = (n2 = _objectSpread2(_objectSpread2({ sync: true }, this.options), n2)).sync, f2 = this, l2 = {}, p2 = [], y2 = [], v2 = [], b2 = !("cyclic" in n2) || n2.cyclic, d2 = n2.encapsulateObserver, h2 = _encapsulate("", t2, b2, r2 || {}, v2);
        function finish(e2) {
          var t3 = Object.values(l2);
          if (n2.iterateNone) return t3.length ? t3[0] : Typeson.getJSONType(e2);
          if (t3.length) {
            if (n2.returnTypeNames) return _toConsumableArray(new Set(t3));
            e2 && isPlainObject(e2) && !c.call(e2, "$types") ? e2.$types = l2 : e2 = { $: e2, $types: { $: l2 } };
          } else isObject(e2) && c.call(e2, "$types") && (e2 = { $: e2, $types: true });
          return !n2.returnTypeNames && e2;
        }
        function _adaptBuiltinStateObjectProperties(e2, t3, r3) {
          Object.assign(e2, t3);
          var n3 = u.map(function(t4) {
            var r4 = e2[t4];
            return delete e2[t4], r4;
          });
          r3(), u.forEach(function(t4, r4) {
            e2[t4] = n3[r4];
          });
        }
        function _encapsulate(t3, r3, i3, u2, s3, v3, b3) {
          var h3, g2 = {}, m2 = _typeof(r3), O2 = d2 ? function(n3) {
            var o2 = b3 || u2.type || Typeson.getJSONType(r3);
            d2(Object.assign(n3 || g2, { keypath: t3, value: r3, cyclic: i3, stateObj: u2, promisesData: s3, resolvingTypesonPromise: v3, awaitingTypesonPromise: hasConstructorOf(r3, e) }, { type: o2 }));
          } : null;
          if (["string", "boolean", "number", "undefined"].includes(m2)) return void 0 === r3 || Number.isNaN(r3) || r3 === Number.NEGATIVE_INFINITY || r3 === Number.POSITIVE_INFINITY ? (h3 = u2.replaced ? r3 : replace(t3, r3, u2, s3, false, v3, O2)) !== r3 && (g2 = { replaced: h3 }) : h3 = r3, O2 && O2(), h3;
          if (null === r3) return O2 && O2(), r3;
          if (i3 && !u2.iterateIn && !u2.iterateUnsetNumeric && r3 && "object" === _typeof(r3)) {
            var _2 = p2.indexOf(r3);
            if (!(_2 < 0)) return l2[t3] = "#", O2 && O2({ cyclicKeypath: y2[_2] }), "#" + y2[_2];
            true === i3 && (p2.push(r3), y2.push(t3));
          }
          var j2, S2 = isPlainObject(r3), T2 = a(r3), w2 = (S2 || T2) && (!f2.plainObjectReplacers.length || u2.replaced) || u2.iterateIn ? r3 : replace(t3, r3, u2, s3, S2 || T2, null, O2);
          if (w2 !== r3 ? (h3 = w2, g2 = { replaced: w2 }) : "" === t3 && hasConstructorOf(r3, e) ? (s3.push([t3, r3, i3, u2, void 0, void 0, u2.type]), h3 = r3) : T2 && "object" !== u2.iterateIn || "array" === u2.iterateIn ? (j2 = new Array(r3.length), g2 = { clone: j2 }) : (["function", "symbol"].includes(_typeof(r3)) || "toJSON" in r3 || hasConstructorOf(r3, e) || hasConstructorOf(r3, Promise) || hasConstructorOf(r3, ArrayBuffer)) && !S2 && "object" !== u2.iterateIn ? h3 = r3 : (j2 = {}, u2.addLength && (j2.length = r3.length), g2 = { clone: j2 }), O2 && O2(), n2.iterateNone) return j2 || h3;
          if (!j2) return h3;
          if (u2.iterateIn) {
            var A2 = function _loop(n3) {
              var o2 = { ownKeys: c.call(r3, n3) };
              _adaptBuiltinStateObjectProperties(u2, o2, function() {
                var o3 = t3 + (t3 ? "." : "") + escapeKeyPathComponent(n3), a2 = _encapsulate(o3, r3[n3], Boolean(i3), u2, s3, v3);
                hasConstructorOf(a2, e) ? s3.push([o3, a2, Boolean(i3), u2, j2, n3, u2.type]) : void 0 !== a2 && (j2[n3] = a2);
              });
            };
            for (var P2 in r3) A2(P2);
            O2 && O2({ endIterateIn: true, end: true });
          } else o(r3).forEach(function(n3) {
            var o2 = t3 + (t3 ? "." : "") + escapeKeyPathComponent(n3);
            _adaptBuiltinStateObjectProperties(u2, { ownKeys: true }, function() {
              var t4 = _encapsulate(o2, r3[n3], Boolean(i3), u2, s3, v3);
              hasConstructorOf(t4, e) ? s3.push([o2, t4, Boolean(i3), u2, j2, n3, u2.type]) : void 0 !== t4 && (j2[n3] = t4);
            });
          }), O2 && O2({ endIterateOwn: true, end: true });
          if (u2.iterateUnsetNumeric) {
            for (var I2 = r3.length, C2 = function _loop2(n3) {
              if (!(n3 in r3)) {
                var o2 = t3 + (t3 ? "." : "") + n3;
                _adaptBuiltinStateObjectProperties(u2, { ownKeys: false }, function() {
                  var t4 = _encapsulate(o2, void 0, Boolean(i3), u2, s3, v3);
                  hasConstructorOf(t4, e) ? s3.push([o2, t4, Boolean(i3), u2, j2, n3, u2.type]) : void 0 !== t4 && (j2[n3] = t4);
                });
              }
            }, N2 = 0; N2 < I2; N2++) C2(N2);
            O2 && O2({ endIterateUnsetNumeric: true, end: true });
          }
          return j2;
        }
        function replace(e2, t3, r3, n3, i3, o2, a2) {
          for (var c2 = i3 ? f2.plainObjectReplacers : f2.nonplainObjectReplacers, u2 = c2.length; u2--; ) {
            var p3 = c2[u2];
            if (p3.test(t3, r3)) {
              var y3 = p3.type;
              if (f2.revivers[y3]) {
                var v3 = l2[e2];
                l2[e2] = v3 ? [y3].concat(v3) : y3;
              }
              return Object.assign(r3, { type: y3, replaced: true }), !s2 && p3.replaceAsync || p3.replace ? (a2 && a2({ replacing: true }), _encapsulate(e2, p3[s2 || !p3.replaceAsync ? "replace" : "replaceAsync"](t3, r3), b2 && "readonly", r3, n3, o2, y3)) : (a2 && a2({ typeDetected: true }), _encapsulate(e2, t3, b2 && "readonly", r3, n3, o2, y3));
            }
          }
          return t3;
        }
        return v2.length ? s2 && n2.throwOnBadSyncType ? function() {
          throw new TypeError("Sync method requested but async result obtained");
        }() : Promise.resolve(i2(h2, v2)).then(finish) : !s2 && n2.throwOnBadSyncType ? function() {
          throw new TypeError("Async method requested but sync result obtained");
        }() : n2.stringification && s2 ? [finish(h2)] : s2 ? finish(h2) : Promise.resolve(finish(h2));
      } }, { key: "encapsulateSync", value: function encapsulateSync(e2, t2, r2) {
        return this.encapsulate(e2, t2, _objectSpread2(_objectSpread2({ throwOnBadSyncType: true }, r2), {}, { sync: true }));
      } }, { key: "encapsulateAsync", value: function encapsulateAsync(e2, t2, r2) {
        return this.encapsulate(e2, t2, _objectSpread2(_objectSpread2({ throwOnBadSyncType: true }, r2), {}, { sync: false }));
      } }, { key: "revive", value: function revive(t2, r2) {
        var n2 = t2 && t2.$types;
        if (!n2) return t2;
        if (true === n2) return t2.$;
        var i2 = (r2 = _objectSpread2(_objectSpread2({ sync: true }, this.options), r2)).sync, c2 = [], u2 = {}, s2 = true;
        n2.$ && isPlainObject(n2.$) && (t2 = t2.$, n2 = n2.$, s2 = false);
        var l2 = this;
        function executeReviver(e2, t3) {
          var r3 = _slicedToArray(l2.revivers[e2] || [], 1)[0];
          if (!r3) throw new Error("Unregistered type: " + e2);
          return i2 && !("revive" in r3) ? t3 : r3[i2 && r3.revive ? "revive" : !i2 && r3.reviveAsync ? "reviveAsync" : "revive"](t3, u2);
        }
        var p2 = [];
        function checkUndefined(e2) {
          return hasConstructorOf(e2, f) ? void 0 : e2;
        }
        var y2, v2 = function revivePlainObjects() {
          var r3 = [];
          if (Object.entries(n2).forEach(function(e2) {
            var t3 = _slicedToArray(e2, 2), i3 = t3[0], o2 = t3[1];
            "#" !== o2 && [].concat(o2).forEach(function(e3) {
              _slicedToArray(l2.revivers[e3] || [null, {}], 2)[1].plain && (r3.push({ keypath: i3, type: e3 }), delete n2[i3]);
            });
          }), r3.length) return r3.sort(nestedPathsFirst).reduce(function reducer(r4, n3) {
            var i3 = n3.keypath, o2 = n3.type;
            if (isThenable(r4)) return r4.then(function(e2) {
              return reducer(e2, { keypath: i3, type: o2 });
            });
            var a2 = getByKeyPath2(t2, i3);
            if (hasConstructorOf(a2 = executeReviver(o2, a2), e)) return a2.then(function(e2) {
              var r5 = setAtKeyPath(t2, i3, e2);
              r5 === e2 && (t2 = r5);
            });
            var c3 = setAtKeyPath(t2, i3, a2);
            c3 === a2 && (t2 = c3);
          }, void 0);
        }();
        return hasConstructorOf(v2, e) ? y2 = v2.then(function() {
          return t2;
        }) : (y2 = function _revive(t3, r3, i3, u3, l3) {
          if (!s2 || "$types" !== t3) {
            var y3 = n2[t3], v3 = a(r3);
            if (v3 || isPlainObject(r3)) {
              var b2 = v3 ? new Array(r3.length) : {};
              for (o(r3).forEach(function(n3) {
                var o2 = _revive(t3 + (t3 ? "." : "") + escapeKeyPathComponent(n3), r3[n3], i3 || b2, b2, n3), a2 = function set(e2) {
                  return hasConstructorOf(e2, f) ? b2[n3] = void 0 : void 0 !== e2 && (b2[n3] = e2), e2;
                };
                hasConstructorOf(o2, e) ? p2.push(o2.then(function(e2) {
                  return a2(e2);
                })) : a2(o2);
              }), r3 = b2; c2.length; ) {
                var d2 = _slicedToArray(c2[0], 4), h2 = d2[0], g2 = d2[1], m2 = d2[2], O2 = d2[3], _2 = getByKeyPath2(h2, g2);
                if (void 0 === _2) break;
                m2[O2] = _2, c2.splice(0, 1);
              }
            }
            if (!y3) return r3;
            if ("#" === y3) {
              var j2 = getByKeyPath2(i3, r3.slice(1));
              return void 0 === j2 && c2.push([i3, r3.slice(1), u3, l3]), j2;
            }
            return [].concat(y3).reduce(function reducer(t4, r4) {
              return hasConstructorOf(t4, e) ? t4.then(function(e2) {
                return reducer(e2, r4);
              }) : executeReviver(r4, t4);
            }, r3);
          }
        }("", t2, null), p2.length && (y2 = e.resolve(y2).then(function(t3) {
          return e.all([t3].concat(p2));
        }).then(function(e2) {
          return _slicedToArray(e2, 1)[0];
        }))), isThenable(y2) ? i2 && r2.throwOnBadSyncType ? function() {
          throw new TypeError("Sync method requested but async result obtained");
        }() : hasConstructorOf(y2, e) ? y2.p.then(checkUndefined) : y2 : !i2 && r2.throwOnBadSyncType ? function() {
          throw new TypeError("Async method requested but sync result obtained");
        }() : i2 ? checkUndefined(y2) : Promise.resolve(checkUndefined(y2));
      } }, { key: "reviveSync", value: function reviveSync(e2, t2) {
        return this.revive(e2, _objectSpread2(_objectSpread2({ throwOnBadSyncType: true }, t2), {}, { sync: true }));
      } }, { key: "reviveAsync", value: function reviveAsync(e2, t2) {
        return this.revive(e2, _objectSpread2(_objectSpread2({ throwOnBadSyncType: true }, t2), {}, { sync: false }));
      } }, { key: "register", value: function register(e2, t2) {
        return t2 = t2 || {}, [].concat(e2).forEach(function R(e3) {
          var r2 = this;
          if (a(e3)) return e3.map(function(e4) {
            return R.call(r2, e4);
          });
          e3 && o(e3).forEach(function(r3) {
            if ("#" === r3) throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");
            if (Typeson.JSON_TYPES.includes(r3)) throw new TypeError("Plain JSON object types are reserved as type names");
            var n2 = e3[r3], i2 = n2 && n2.testPlainObjects ? this.plainObjectReplacers : this.nonplainObjectReplacers, o2 = i2.filter(function(e4) {
              return e4.type === r3;
            });
            if (o2.length && (i2.splice(i2.indexOf(o2[0]), 1), delete this.revivers[r3], delete this.types[r3]), "function" == typeof n2) {
              var c2 = n2;
              n2 = { test: function test(e4) {
                return e4 && e4.constructor === c2;
              }, replace: function replace(e4) {
                return _objectSpread2({}, e4);
              }, revive: function revive(e4) {
                return Object.assign(Object.create(c2.prototype), e4);
              } };
            } else if (a(n2)) {
              var u2 = _slicedToArray(n2, 3);
              n2 = { test: u2[0], replace: u2[1], revive: u2[2] };
            }
            if (n2 && n2.test) {
              var s2 = { type: r3, test: n2.test.bind(n2) };
              n2.replace && (s2.replace = n2.replace.bind(n2)), n2.replaceAsync && (s2.replaceAsync = n2.replaceAsync.bind(n2));
              var f2 = "number" == typeof t2.fallback ? t2.fallback : t2.fallback ? 0 : Number.POSITIVE_INFINITY;
              if (n2.testPlainObjects ? this.plainObjectReplacers.splice(f2, 0, s2) : this.nonplainObjectReplacers.splice(f2, 0, s2), n2.revive || n2.reviveAsync) {
                var l2 = {};
                n2.revive && (l2.revive = n2.revive.bind(n2)), n2.reviveAsync && (l2.reviveAsync = n2.reviveAsync.bind(n2)), this.revivers[r3] = [l2, { plain: n2.testPlainObjects }];
              }
              this.types[r3] = n2;
            }
          }, this);
        }, this), this;
      } }]), Typeson;
    }(), f = function Undefined() {
      _classCallCheck(this, Undefined);
    };
    f.__typeson__type__ = "TypesonUndefined", s.Undefined = f, s.Promise = e, s.isThenable = isThenable, s.toStringTag = toStringTag2, s.hasConstructorOf = hasConstructorOf, s.isObject = isObject, s.isPlainObject = isPlainObject, s.isUserObject = function isUserObject(e2) {
      if (!e2 || "Object" !== toStringTag2(e2)) return false;
      var t2 = n(e2);
      return !t2 || (hasConstructorOf(e2, Object) || isUserObject(t2));
    }, s.escapeKeyPathComponent = escapeKeyPathComponent, s.unescapeKeyPathComponent = unescapeKeyPathComponent, s.getByKeyPath = getByKeyPath2, s.getJSONType = function getJSONType(e2) {
      return null === e2 ? "null" : Array.isArray(e2) ? "array" : _typeof(e2);
    }, s.JSON_TYPES = ["null", "boolean", "number", "string", "array", "object"];
    for (var l = { userObject: { test: function test(e2, t2) {
      return s.isUserObject(e2);
    }, replace: function replace(e2) {
      return function _objectSpread2$1(e3) {
        for (var t2 = 1; t2 < arguments.length; t2++) {
          var r2 = null != arguments[t2] ? arguments[t2] : {};
          t2 % 2 ? ownKeys$1(Object(r2), true).forEach(function(t3) {
            _defineProperty$1(e3, t3, r2[t3]);
          }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e3, Object.getOwnPropertyDescriptors(r2)) : ownKeys$1(Object(r2)).forEach(function(t3) {
            Object.defineProperty(e3, t3, Object.getOwnPropertyDescriptor(r2, t3));
          });
        }
        return e3;
      }({}, e2);
    }, revive: function revive(e2) {
      return e2;
    } } }, p = [{ arrayNonindexKeys: { testPlainObjects: true, test: function test(e2, t2) {
      return !!Array.isArray(e2) && (Object.keys(e2).some(function(e3) {
        return String(Number.parseInt(e3)) !== e3;
      }) && (t2.iterateIn = "object", t2.addLength = true), true);
    }, replace: function replace(e2, t2) {
      return t2.iterateUnsetNumeric = true, e2;
    }, revive: function revive(e2) {
      if (Array.isArray(e2)) return e2;
      var t2 = [];
      return Object.keys(e2).forEach(function(r2) {
        var n2 = e2[r2];
        t2[r2] = n2;
      }), t2;
    } } }, { sparseUndefined: { test: function test(e2, t2) {
      return void 0 === e2 && false === t2.ownKeys;
    }, replace: function replace(e2) {
      return 0;
    }, revive: function revive(e2) {
    } } }], y = { undef: { test: function test(e2, t2) {
      return void 0 === e2 && (t2.ownKeys || !("ownKeys" in t2));
    }, replace: function replace(e2) {
      return 0;
    }, revive: function revive(e2) {
      return new s.Undefined();
    } } }, v = { StringObject: { test: function test(e2) {
      return "String" === s.toStringTag(e2) && "object" === _typeof$1(e2);
    }, replace: function replace(e2) {
      return String(e2);
    }, revive: function revive(e2) {
      return new String(e2);
    } }, BooleanObject: { test: function test(e2) {
      return "Boolean" === s.toStringTag(e2) && "object" === _typeof$1(e2);
    }, replace: function replace(e2) {
      return Boolean(e2);
    }, revive: function revive(e2) {
      return new Boolean(e2);
    } }, NumberObject: { test: function test(e2) {
      return "Number" === s.toStringTag(e2) && "object" === _typeof$1(e2);
    }, replace: function replace(e2) {
      return Number(e2);
    }, revive: function revive(e2) {
      return new Number(e2);
    } } }, b = [{ nan: { test: function test(e2) {
      return Number.isNaN(e2);
    }, replace: function replace(e2) {
      return "NaN";
    }, revive: function revive(e2) {
      return Number.NaN;
    } } }, { infinity: { test: function test(e2) {
      return e2 === Number.POSITIVE_INFINITY;
    }, replace: function replace(e2) {
      return "Infinity";
    }, revive: function revive(e2) {
      return Number.POSITIVE_INFINITY;
    } } }, { negativeInfinity: { test: function test(e2) {
      return e2 === Number.NEGATIVE_INFINITY;
    }, replace: function replace(e2) {
      return "-Infinity";
    }, revive: function revive(e2) {
      return Number.NEGATIVE_INFINITY;
    } } }], d = { date: { test: function test(e2) {
      return "Date" === s.toStringTag(e2);
    }, replace: function replace(e2) {
      var t2 = e2.getTime();
      return Number.isNaN(t2) ? "NaN" : t2;
    }, revive: function revive(e2) {
      return "NaN" === e2 ? new Date(Number.NaN) : new Date(e2);
    } } }, h = { regexp: { test: function test(e2) {
      return "RegExp" === s.toStringTag(e2);
    }, replace: function replace(e2) {
      return { source: e2.source, flags: (e2.global ? "g" : "") + (e2.ignoreCase ? "i" : "") + (e2.multiline ? "m" : "") + (e2.sticky ? "y" : "") + (e2.unicode ? "u" : "") };
    }, revive: function revive(e2) {
      var t2 = e2.source, r2 = e2.flags;
      return new RegExp(t2, r2);
    } } }, g = { map: { test: function test(e2) {
      return "Map" === s.toStringTag(e2);
    }, replace: function replace(e2) {
      return _toConsumableArray$1(e2.entries());
    }, revive: function revive(e2) {
      return new Map(e2);
    } } }, m = { set: { test: function test(e2) {
      return "Set" === s.toStringTag(e2);
    }, replace: function replace(e2) {
      return _toConsumableArray$1(e2.values());
    }, revive: function revive(e2) {
      return new Set(e2);
    } } }, O = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", _ = new Uint8Array(256), j = 0; j < O.length; j++) _[O.charCodeAt(j)] = j;
    var S = function encode3(e2, t2, r2) {
      null == r2 && (r2 = e2.byteLength);
      for (var n2 = new Uint8Array(e2, t2 || 0, r2), i2 = n2.length, o2 = "", a2 = 0; a2 < i2; a2 += 3) o2 += O[n2[a2] >> 2], o2 += O[(3 & n2[a2]) << 4 | n2[a2 + 1] >> 4], o2 += O[(15 & n2[a2 + 1]) << 2 | n2[a2 + 2] >> 6], o2 += O[63 & n2[a2 + 2]];
      return i2 % 3 == 2 ? o2 = o2.slice(0, -1) + "=" : i2 % 3 == 1 && (o2 = o2.slice(0, -2) + "=="), o2;
    }, T = function decode3(e2) {
      var t2, r2, n2, i2, o2 = e2.length, a2 = 0.75 * e2.length, c2 = 0;
      "=" === e2[e2.length - 1] && (a2--, "=" === e2[e2.length - 2] && a2--);
      for (var u2 = new ArrayBuffer(a2), s2 = new Uint8Array(u2), f2 = 0; f2 < o2; f2 += 4) t2 = _[e2.charCodeAt(f2)], r2 = _[e2.charCodeAt(f2 + 1)], n2 = _[e2.charCodeAt(f2 + 2)], i2 = _[e2.charCodeAt(f2 + 3)], s2[c2++] = t2 << 2 | r2 >> 4, s2[c2++] = (15 & r2) << 4 | n2 >> 2, s2[c2++] = (3 & n2) << 6 | 63 & i2;
      return u2;
    }, w = { arraybuffer: { test: function test(e2) {
      return "ArrayBuffer" === s.toStringTag(e2);
    }, replace: function replace(e2, t2) {
      t2.buffers || (t2.buffers = []);
      var r2 = t2.buffers.indexOf(e2);
      return r2 > -1 ? { index: r2 } : (t2.buffers.push(e2), S(e2));
    }, revive: function revive(e2, t2) {
      if (t2.buffers || (t2.buffers = []), "object" === _typeof$1(e2)) return t2.buffers[e2.index];
      var r2 = T(e2);
      return t2.buffers.push(r2), r2;
    } } }, A = "undefined" == typeof self ? commonjsGlobal : self, P = {};
    ["Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array"].forEach(function(e2) {
      var t2 = e2, r2 = A[t2];
      r2 && (P[e2.toLowerCase()] = { test: function test(e3) {
        return s.toStringTag(e3) === t2;
      }, replace: function replace(e3, t3) {
        var r3 = e3.buffer, n2 = e3.byteOffset, i2 = e3.length;
        t3.buffers || (t3.buffers = []);
        var o2 = t3.buffers.indexOf(r3);
        return o2 > -1 ? { index: o2, byteOffset: n2, length: i2 } : (t3.buffers.push(r3), { encoded: S(r3), byteOffset: n2, length: i2 });
      }, revive: function revive(e3, t3) {
        t3.buffers || (t3.buffers = []);
        var n2, i2 = e3.byteOffset, o2 = e3.length, a2 = e3.encoded, c2 = e3.index;
        return "index" in e3 ? n2 = t3.buffers[c2] : (n2 = T(a2), t3.buffers.push(n2)), new r2(n2, i2, o2);
      } });
    });
    var I = { dataview: { test: function test(e2) {
      return "DataView" === s.toStringTag(e2);
    }, replace: function replace(e2, t2) {
      var r2 = e2.buffer, n2 = e2.byteOffset, i2 = e2.byteLength;
      t2.buffers || (t2.buffers = []);
      var o2 = t2.buffers.indexOf(r2);
      return o2 > -1 ? { index: o2, byteOffset: n2, byteLength: i2 } : (t2.buffers.push(r2), { encoded: S(r2), byteOffset: n2, byteLength: i2 });
    }, revive: function revive(e2, t2) {
      t2.buffers || (t2.buffers = []);
      var r2, n2 = e2.byteOffset, i2 = e2.byteLength, o2 = e2.encoded, a2 = e2.index;
      return "index" in e2 ? r2 = t2.buffers[a2] : (r2 = T(o2), t2.buffers.push(r2)), new DataView(r2, n2, i2);
    } } }, C = { IntlCollator: { test: function test(e2) {
      return s.hasConstructorOf(e2, Intl.Collator);
    }, replace: function replace(e2) {
      return e2.resolvedOptions();
    }, revive: function revive(e2) {
      return new Intl.Collator(e2.locale, e2);
    } }, IntlDateTimeFormat: { test: function test(e2) {
      return s.hasConstructorOf(e2, Intl.DateTimeFormat);
    }, replace: function replace(e2) {
      return e2.resolvedOptions();
    }, revive: function revive(e2) {
      return new Intl.DateTimeFormat(e2.locale, e2);
    } }, IntlNumberFormat: { test: function test(e2) {
      return s.hasConstructorOf(e2, Intl.NumberFormat);
    }, replace: function replace(e2) {
      return e2.resolvedOptions();
    }, revive: function revive(e2) {
      return new Intl.NumberFormat(e2.locale, e2);
    } } };
    function string2arraybuffer(e2) {
      for (var t2 = new Uint8Array(e2.length), r2 = 0; r2 < e2.length; r2++) t2[r2] = e2.charCodeAt(r2);
      return t2.buffer;
    }
    var N = { file: { test: function test(e2) {
      return "File" === s.toStringTag(e2);
    }, replace: function replace(e2) {
      var t2 = new XMLHttpRequest();
      if (t2.overrideMimeType("text/plain; charset=x-user-defined"), t2.open("GET", URL.createObjectURL(e2), false), t2.send(), 200 !== t2.status && 0 !== t2.status) throw new Error("Bad File access: " + t2.status);
      return { type: e2.type, stringContents: t2.responseText, name: e2.name, lastModified: e2.lastModified };
    }, revive: function revive(e2) {
      var t2 = e2.name, r2 = e2.type, n2 = e2.stringContents, i2 = e2.lastModified;
      return new File([string2arraybuffer(n2)], t2, { type: r2, lastModified: i2 });
    }, replaceAsync: function replaceAsync(e2) {
      return new s.Promise(function(t2, r2) {
        var n2 = new FileReader();
        n2.addEventListener("load", function() {
          t2({ type: e2.type, stringContents: n2.result, name: e2.name, lastModified: e2.lastModified });
        }), n2.addEventListener("error", function() {
          r2(n2.error);
        }), n2.readAsBinaryString(e2);
      });
    } } }, k = { bigint: { test: function test(e2) {
      return "bigint" == typeof e2;
    }, replace: function replace(e2) {
      return String(e2);
    }, revive: function revive(e2) {
      return BigInt(e2);
    } } }, E = { bigintObject: { test: function test(e2) {
      return "object" === _typeof$1(e2) && s.hasConstructorOf(e2, BigInt);
    }, replace: function replace(e2) {
      return String(e2);
    }, revive: function revive(e2) {
      return new Object(BigInt(e2));
    } } }, B = { cryptokey: { test: function test(e2) {
      return "CryptoKey" === s.toStringTag(e2) && e2.extractable;
    }, replaceAsync: function replaceAsync(e2) {
      return new s.Promise(function(t2, r2) {
        crypto.subtle.exportKey("jwk", e2).catch(function(e3) {
          r2(e3);
        }).then(function(r3) {
          t2({ jwk: r3, algorithm: e2.algorithm, usages: e2.usages });
        });
      });
    }, revive: function revive(e2) {
      var t2 = e2.jwk, r2 = e2.algorithm, n2 = e2.usages;
      return crypto.subtle.importKey("jwk", t2, r2, true, n2);
    } } };
    return [l, y, p, v, b, d, h, { imagedata: { test: function test(e2) {
      return "ImageData" === s.toStringTag(e2);
    }, replace: function replace(e2) {
      return { array: _toConsumableArray$1(e2.data), width: e2.width, height: e2.height };
    }, revive: function revive(e2) {
      return new ImageData(new Uint8ClampedArray(e2.array), e2.width, e2.height);
    } } }, { imagebitmap: { test: function test(e2) {
      return "ImageBitmap" === s.toStringTag(e2) || e2 && e2.dataset && "ImageBitmap" === e2.dataset.toStringTag;
    }, replace: function replace(e2) {
      var t2 = document.createElement("canvas");
      return t2.getContext("2d").drawImage(e2, 0, 0), t2.toDataURL();
    }, revive: function revive(e2) {
      var t2 = document.createElement("canvas"), r2 = t2.getContext("2d"), n2 = document.createElement("img");
      return n2.addEventListener("load", function() {
        r2.drawImage(n2, 0, 0);
      }), n2.src = e2, t2;
    }, reviveAsync: function reviveAsync(e2) {
      var t2 = document.createElement("canvas"), r2 = t2.getContext("2d"), n2 = document.createElement("img");
      return n2.addEventListener("load", function() {
        r2.drawImage(n2, 0, 0);
      }), n2.src = e2, createImageBitmap(t2);
    } } }, N, { file: N.file, filelist: { test: function test(e2) {
      return "FileList" === s.toStringTag(e2);
    }, replace: function replace(e2) {
      for (var t2 = [], r2 = 0; r2 < e2.length; r2++) t2[r2] = e2.item(r2);
      return t2;
    }, revive: function revive(e2) {
      return new (function() {
        function FileList() {
          _classCallCheck$1(this, FileList), this._files = arguments[0], this.length = this._files.length;
        }
        return function _createClass$1(e3, t2, r2) {
          return t2 && _defineProperties$1(e3.prototype, t2), r2 && _defineProperties$1(e3, r2), e3;
        }(FileList, [{ key: "item", value: function item(e3) {
          return this._files[e3];
        } }, { key: Symbol.toStringTag, get: function get() {
          return "FileList";
        } }]), FileList;
      }())(e2);
    } } }, { blob: { test: function test(e2) {
      return "Blob" === s.toStringTag(e2);
    }, replace: function replace(e2) {
      var t2 = new XMLHttpRequest();
      if (t2.overrideMimeType("text/plain; charset=x-user-defined"), t2.open("GET", URL.createObjectURL(e2), false), t2.send(), 200 !== t2.status && 0 !== t2.status) throw new Error("Bad Blob access: " + t2.status);
      return { type: e2.type, stringContents: t2.responseText };
    }, revive: function revive(e2) {
      var t2 = e2.type, r2 = e2.stringContents;
      return new Blob([string2arraybuffer(r2)], { type: t2 });
    }, replaceAsync: function replaceAsync(e2) {
      return new s.Promise(function(t2, r2) {
        var n2 = new FileReader();
        n2.addEventListener("load", function() {
          t2({ type: e2.type, stringContents: n2.result });
        }), n2.addEventListener("error", function() {
          r2(n2.error);
        }), n2.readAsBinaryString(e2);
      });
    } } }].concat("function" == typeof Map ? g : [], "function" == typeof Set ? m : [], "function" == typeof ArrayBuffer ? w : [], "function" == typeof Uint8Array ? P : [], "function" == typeof DataView ? I : [], "undefined" != typeof Intl ? C : [], "undefined" != typeof crypto ? B : [], "undefined" != typeof BigInt ? [k, E] : []);
  });
});
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var lookup = new Uint8Array(256);
for (i = 0; i < chars.length; i++) {
  lookup[chars.codePointAt(i)] = i;
}
var i;
var encode = function encode2(arraybuffer, byteOffset, lngth) {
  if (lngth === null || lngth === void 0) {
    lngth = arraybuffer.byteLength;
  }
  var bytes = new Uint8Array(
    arraybuffer,
    byteOffset || 0,
    // Default needed for Safari
    lngth
  );
  var len = bytes.length;
  var base64 = "";
  for (var _i = 0; _i < len; _i += 3) {
    base64 += chars[bytes[_i] >> 2];
    base64 += chars[(bytes[_i] & 3) << 4 | bytes[_i + 1] >> 4];
    base64 += chars[(bytes[_i + 1] & 15) << 2 | bytes[_i + 2] >> 6];
    base64 += chars[bytes[_i + 2] & 63];
  }
  if (len % 3 === 2) {
    base64 = base64.slice(0, -1) + "=";
  } else if (len % 3 === 1) {
    base64 = base64.slice(0, -2) + "==";
  }
  return base64;
};
var decode = function decode2(base64) {
  var len = base64.length;
  var bufferLength = base64.length * 0.75;
  var p = 0;
  var encoded1, encoded2, encoded3, encoded4;
  if (base64[base64.length - 1] === "=") {
    bufferLength--;
    if (base64[base64.length - 2] === "=") {
      bufferLength--;
    }
  }
  var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
  for (var _i2 = 0; _i2 < len; _i2 += 4) {
    encoded1 = lookup[base64.codePointAt(_i2)];
    encoded2 = lookup[base64.codePointAt(_i2 + 1)];
    encoded3 = lookup[base64.codePointAt(_i2 + 2)];
    encoded4 = lookup[base64.codePointAt(_i2 + 3)];
    bytes[p++] = encoded1 << 2 | encoded2 >> 4;
    bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
    bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
  }
  return arraybuffer;
};
var _global2 = typeof self === "undefined" ? global : self;
var exportObj = {};
[
  "Int8Array",
  "Uint8Array",
  "Uint8ClampedArray",
  "Int16Array",
  "Uint16Array",
  "Int32Array",
  "Uint32Array",
  "Float32Array",
  "Float64Array"
].forEach(function(typeName) {
  var arrType = typeName;
  var TypedArray = _global2[arrType];
  if (TypedArray) {
    exportObj[typeName.toLowerCase() + "2"] = {
      test: function(x) {
        return typeson.toStringTag(x) === arrType;
      },
      replace: function(_a) {
        var buffer = _a.buffer, byteOffset = _a.byteOffset, length = _a.length;
        return {
          buffer,
          byteOffset,
          length
        };
      },
      revive: function(b64Obj) {
        var buffer = b64Obj.buffer, byteOffset = b64Obj.byteOffset, length = b64Obj.length;
        return new TypedArray(buffer, byteOffset, length);
      }
    };
  }
});
var arrayBuffer = {
  arraybuffer: {
    test: function(x) {
      return typeson.toStringTag(x) === "ArrayBuffer";
    },
    replace: function(b) {
      return encode(b, 0, b.byteLength);
    },
    revive: function(b64) {
      var buffer = decode(b64);
      return buffer;
    }
  }
};
var TSON = new typeson().register(structuredCloning);
var readBlobsSynchronously = "FileReaderSync" in self;
var blobsToAwait = [];
var blobsToAwaitPos = 0;
TSON.register([
  arrayBuffer,
  exportObj,
  {
    blob2: {
      test: function(x) {
        return typeson.toStringTag(x) === "Blob";
      },
      replace: function(b) {
        if (b.isClosed) {
          throw new Error("The Blob is closed");
        }
        if (readBlobsSynchronously) {
          var data = readBlobSync(b, "binary");
          var base64 = encode(data, 0, data.byteLength);
          return {
            type: b.type,
            data: base64
          };
        } else {
          blobsToAwait.push(b);
          var result = {
            type: b.type,
            data: { start: blobsToAwaitPos, end: blobsToAwaitPos + b.size }
          };
          blobsToAwaitPos += b.size;
          return result;
        }
      },
      finalize: function(b, ba) {
        b.data = encode(ba, 0, ba.byteLength);
      },
      revive: function(_a) {
        var type2 = _a.type, data = _a.data;
        return new Blob([decode(data)], { type: type2 });
      }
    }
  }
]);
TSON.mustFinalize = function() {
  return blobsToAwait.length > 0;
};
TSON.finalize = function(items) {
  return __awaiter(void 0, void 0, void 0, function() {
    var allChunks, _i, items_1, item, types, arrayType, keyPath, typeName, typeSpec, b;
    return __generator(this, function(_a) {
      switch (_a.label) {
        case 0:
          return [4, readBlobAsync(new Blob(blobsToAwait), "binary")];
        case 1:
          allChunks = _a.sent();
          if (items) {
            for (_i = 0, items_1 = items; _i < items_1.length; _i++) {
              item = items_1[_i];
              if (item.$types) {
                types = item.$types;
                arrayType = types.$;
                if (arrayType)
                  types = types.$;
                for (keyPath in types) {
                  typeName = types[keyPath];
                  typeSpec = TSON.types[typeName];
                  if (typeSpec && typeSpec.finalize) {
                    b = Dexie$1.getByKeyPath(item, arrayType ? "$." + keyPath : keyPath);
                    typeSpec.finalize(b, allChunks.slice(b.start, b.end));
                  }
                }
              }
            }
          }
          blobsToAwait = [];
          return [
            2
            /*return*/
          ];
      }
    });
  });
};
var DEFAULT_ROWS_PER_CHUNK = 2e3;
function exportDB(db, options) {
  return __awaiter(this, void 0, void 0, function() {
    function exportAll() {
      return __awaiter(this, void 0, void 0, function() {
        var tablesRowCounts, emptyExportJson, posEndDataArray, firstJsonSlice, filter, transform, _loop_1, _i, tables_1, tableName;
        return __generator(this, function(_a) {
          switch (_a.label) {
            case 0:
              return [4, Promise.all(targetTables.map(function(table) {
                return table.count();
              }))];
            case 1:
              tablesRowCounts = _a.sent();
              tablesRowCounts.forEach(function(rowCount, i) {
                return tables[i].rowCount = rowCount;
              });
              progress.totalRows = tablesRowCounts.reduce(function(p, c) {
                return p + c;
              });
              emptyExportJson = JSON.stringify(emptyExport, void 0, prettyJson ? 2 : void 0);
              posEndDataArray = emptyExportJson.lastIndexOf("]");
              firstJsonSlice = emptyExportJson.substring(0, posEndDataArray);
              slices.push(firstJsonSlice);
              filter = options.filter;
              transform = options.transform;
              _loop_1 = function(tableName2) {
                var table, primKey, inbound, LIMIT, emptyTableExport, emptyTableExportJson, posEndRowsArray, lastKey, lastNumRows, mayHaveMoreRows, _loop_2, state_1;
                return __generator(this, function(_b) {
                  switch (_b.label) {
                    case 0:
                      table = db.table(tableName2);
                      primKey = table.schema.primKey;
                      inbound = !!primKey.keyPath;
                      LIMIT = options.numRowsPerChunk || DEFAULT_ROWS_PER_CHUNK;
                      emptyTableExport = inbound ? {
                        tableName: table.name,
                        inbound: true,
                        rows: []
                      } : {
                        tableName: table.name,
                        inbound: false,
                        rows: []
                      };
                      emptyTableExportJson = JSON.stringify(emptyTableExport, void 0, prettyJson ? 2 : void 0);
                      if (prettyJson) {
                        emptyTableExportJson = emptyTableExportJson.split("\n").join("\n    ");
                      }
                      posEndRowsArray = emptyTableExportJson.lastIndexOf("]");
                      slices.push(emptyTableExportJson.substring(0, posEndRowsArray));
                      lastKey = null;
                      lastNumRows = 0;
                      mayHaveMoreRows = true;
                      _loop_2 = function() {
                        var chunkedCollection, values, filteredValues, transformedValues, tsonValues, json, keys2, keyvals, tsonTuples, json;
                        return __generator(this, function(_c) {
                          switch (_c.label) {
                            case 0:
                              if (progressCallback) {
                                Dexie$1.ignoreTransaction(function() {
                                  return progressCallback(progress);
                                });
                              }
                              chunkedCollection = lastKey == null ? table.limit(LIMIT) : table.where(":id").above(lastKey).limit(LIMIT);
                              return [4, chunkedCollection.toArray()];
                            case 1:
                              values = _c.sent();
                              if (values.length === 0)
                                return [2, "break"];
                              if (lastKey != null && lastNumRows > 0) {
                                slices.push(",");
                                if (prettyJson) {
                                  slices.push("\n      ");
                                }
                              }
                              mayHaveMoreRows = values.length === LIMIT;
                              if (!inbound) return [3, 4];
                              filteredValues = filter ? values.filter(function(value) {
                                return filter(tableName2, value);
                              }) : values;
                              transformedValues = transform ? filteredValues.map(function(value) {
                                return transform(tableName2, value).value;
                              }) : filteredValues;
                              tsonValues = transformedValues.map(function(value) {
                                return TSON.encapsulate(value);
                              });
                              if (!TSON.mustFinalize()) return [3, 3];
                              return [4, Dexie$1.waitFor(TSON.finalize(tsonValues))];
                            case 2:
                              _c.sent();
                              _c.label = 3;
                            case 3:
                              json = JSON.stringify(tsonValues, void 0, prettyJson ? 2 : void 0);
                              if (prettyJson)
                                json = json.split("\n").join("\n      ");
                              slices.push(new Blob([json.substring(1, json.length - 1)]));
                              lastNumRows = transformedValues.length;
                              lastKey = values.length > 0 ? Dexie$1.getByKeyPath(values[values.length - 1], primKey.keyPath) : null;
                              return [3, 8];
                            case 4:
                              return [4, chunkedCollection.primaryKeys()];
                            case 5:
                              keys2 = _c.sent();
                              keyvals = keys2.map(function(key, i) {
                                return [key, values[i]];
                              });
                              if (filter)
                                keyvals = keyvals.filter(function(_a2) {
                                  var key = _a2[0], value = _a2[1];
                                  return filter(tableName2, value, key);
                                });
                              if (transform)
                                keyvals = keyvals.map(function(_a2) {
                                  var key = _a2[0], value = _a2[1];
                                  var transformResult = transform(tableName2, value, key);
                                  return [transformResult.key, transformResult.value];
                                });
                              tsonTuples = keyvals.map(function(tuple) {
                                return TSON.encapsulate(tuple);
                              });
                              if (!TSON.mustFinalize()) return [3, 7];
                              return [4, Dexie$1.waitFor(TSON.finalize(tsonTuples))];
                            case 6:
                              _c.sent();
                              _c.label = 7;
                            case 7:
                              json = JSON.stringify(tsonTuples, void 0, prettyJson ? 2 : void 0);
                              if (prettyJson)
                                json = json.split("\n").join("\n      ");
                              slices.push(new Blob([json.substring(1, json.length - 1)]));
                              lastNumRows = keyvals.length;
                              lastKey = keys2.length > 0 ? keys2[keys2.length - 1] : null;
                              _c.label = 8;
                            case 8:
                              progress.completedRows += values.length;
                              return [
                                2
                                /*return*/
                              ];
                          }
                        });
                      };
                      _b.label = 1;
                    case 1:
                      if (!mayHaveMoreRows) return [3, 3];
                      return [5, _loop_2()];
                    case 2:
                      state_1 = _b.sent();
                      if (state_1 === "break")
                        return [3, 3];
                      return [3, 1];
                    case 3:
                      slices.push(emptyTableExportJson.substr(posEndRowsArray));
                      progress.completedTables += 1;
                      if (progress.completedTables < progress.totalTables) {
                        slices.push(",");
                      }
                      return [
                        2
                        /*return*/
                      ];
                  }
                });
              };
              _i = 0, tables_1 = tables;
              _a.label = 2;
            case 2:
              if (!(_i < tables_1.length)) return [3, 5];
              tableName = tables_1[_i].name;
              return [5, _loop_1(tableName)];
            case 3:
              _a.sent();
              _a.label = 4;
            case 4:
              _i++;
              return [3, 2];
            case 5:
              slices.push(emptyExportJson.substr(posEndDataArray));
              progress.done = true;
              if (progressCallback) {
                Dexie$1.ignoreTransaction(function() {
                  return progressCallback(progress);
                });
              }
              return [
                2
                /*return*/
              ];
          }
        });
      });
    }
    var skipTables, targetTables, slices, tables, prettyJson, emptyExport, progressCallback, progress;
    return __generator(this, function(_a) {
      switch (_a.label) {
        case 0:
          options = options || {};
          skipTables = options.skipTables ? options.skipTables : [];
          targetTables = db.tables.filter(function(x) {
            return !skipTables.includes(x.name);
          });
          slices = [];
          tables = targetTables.map(function(table) {
            return {
              name: table.name,
              schema: getSchemaString(table),
              rowCount: 0
            };
          });
          prettyJson = options.prettyJson;
          emptyExport = {
            formatName: "dexie",
            formatVersion: 1,
            data: {
              databaseName: db.name,
              databaseVersion: db.verno,
              tables,
              data: []
            }
          };
          progressCallback = options.progressCallback;
          progress = {
            done: false,
            completedRows: 0,
            completedTables: 0,
            totalRows: NaN,
            totalTables: tables.length
          };
          _a.label = 1;
        case 1:
          _a.trys.push([1, , 6, 7]);
          if (!options.noTransaction) return [3, 3];
          return [4, exportAll()];
        case 2:
          _a.sent();
          return [3, 5];
        case 3:
          return [4, db.transaction("r", db.tables, exportAll)];
        case 4:
          _a.sent();
          _a.label = 5;
        case 5:
          return [3, 7];
        case 6:
          TSON.finalize();
          return [
            7
            /*endfinally*/
          ];
        case 7:
          return [2, new Blob(slices, { type: "text/json" })];
      }
    });
  });
}
var VERSION = 1;
var fakeStream = { Stream: function() {
} };
var clarinet_1 = createCommonjsModule(function(module, exports) {
  (function(clarinet) {
    var env = typeof process === "object" && process.env ? process.env : self;
    clarinet.parser = function(opt) {
      return new CParser(opt);
    };
    clarinet.CParser = CParser;
    clarinet.CStream = CStream;
    clarinet.createStream = createStream;
    clarinet.MAX_BUFFER_LENGTH = 10 * 1024 * 1024;
    clarinet.DEBUG = env.CDEBUG === "debug";
    clarinet.INFO = env.CDEBUG === "debug" || env.CDEBUG === "info";
    clarinet.EVENTS = [
      "value",
      "string",
      "key",
      "openobject",
      "closeobject",
      "openarray",
      "closearray",
      "error",
      "end",
      "ready"
    ];
    var buffers = {
      textNode: void 0,
      numberNode: ""
    }, streamWraps = clarinet.EVENTS.filter(function(ev) {
      return ev !== "error" && ev !== "end";
    }), S = 0, Stream;
    clarinet.STATE = {
      BEGIN: S++,
      VALUE: S++,
      OPEN_OBJECT: S++,
      CLOSE_OBJECT: S++,
      OPEN_ARRAY: S++,
      CLOSE_ARRAY: S++,
      TEXT_ESCAPE: S++,
      STRING: S++,
      BACKSLASH: S++,
      END: S++,
      OPEN_KEY: S++,
      CLOSE_KEY: S++,
      TRUE: S++,
      TRUE2: S++,
      TRUE3: S++,
      FALSE: S++,
      FALSE2: S++,
      FALSE3: S++,
      FALSE4: S++,
      NULL: S++,
      NULL2: S++,
      NULL3: S++,
      NUMBER_DECIMAL_POINT: S++,
      NUMBER_DIGIT: S++
      // [0-9]
    };
    for (var s_ in clarinet.STATE) clarinet.STATE[clarinet.STATE[s_]] = s_;
    S = clarinet.STATE;
    const Char = {
      tab: 9,
      // \t
      lineFeed: 10,
      // \n
      carriageReturn: 13,
      // \r
      space: 32,
      // " "
      doubleQuote: 34,
      // "
      plus: 43,
      // +
      comma: 44,
      // ,
      minus: 45,
      // -
      period: 46,
      // .
      _0: 48,
      // 0
      _9: 57,
      // 9
      colon: 58,
      // :
      E: 69,
      // E
      openBracket: 91,
      // [
      backslash: 92,
      // \
      closeBracket: 93,
      // ]
      a: 97,
      // a
      b: 98,
      // b
      e: 101,
      // e 
      f: 102,
      // f
      l: 108,
      // l
      n: 110,
      // n
      r: 114,
      // r
      s: 115,
      // s
      t: 116,
      // t
      u: 117,
      // u
      openBrace: 123,
      // {
      closeBrace: 125
      // }
    };
    if (!Object.create) {
      Object.create = function(o) {
        function f() {
          this["__proto__"] = o;
        }
        f.prototype = o;
        return new f();
      };
    }
    if (!Object.getPrototypeOf) {
      Object.getPrototypeOf = function(o) {
        return o["__proto__"];
      };
    }
    if (!Object.keys) {
      Object.keys = function(o) {
        var a = [];
        for (var i in o) if (o.hasOwnProperty(i)) a.push(i);
        return a;
      };
    }
    function checkBufferLength(parser) {
      var maxAllowed = Math.max(clarinet.MAX_BUFFER_LENGTH, 10), maxActual = 0;
      for (var buffer in buffers) {
        var len = parser[buffer] === void 0 ? 0 : parser[buffer].length;
        if (len > maxAllowed) {
          switch (buffer) {
            case "text":
              closeText(parser);
              break;
            default:
              error(parser, "Max buffer length exceeded: " + buffer);
          }
        }
        maxActual = Math.max(maxActual, len);
      }
      parser.bufferCheckPosition = clarinet.MAX_BUFFER_LENGTH - maxActual + parser.position;
    }
    function clearBuffers(parser) {
      for (var buffer in buffers) {
        parser[buffer] = buffers[buffer];
      }
    }
    var stringTokenPattern = /[\\"\n]/g;
    function CParser(opt) {
      if (!(this instanceof CParser)) return new CParser(opt);
      var parser = this;
      clearBuffers(parser);
      parser.bufferCheckPosition = clarinet.MAX_BUFFER_LENGTH;
      parser.q = parser.c = parser.p = "";
      parser.opt = opt || {};
      parser.closed = parser.closedRoot = parser.sawRoot = false;
      parser.tag = parser.error = null;
      parser.state = S.BEGIN;
      parser.stack = new Array();
      parser.position = parser.column = 0;
      parser.line = 1;
      parser.slashed = false;
      parser.unicodeI = 0;
      parser.unicodeS = null;
      parser.depth = 0;
      emit(parser, "onready");
    }
    CParser.prototype = {
      end: function() {
        end(this);
      },
      write,
      resume: function() {
        this.error = null;
        return this;
      },
      close: function() {
        return this.write(null);
      }
    };
    try {
      Stream = fakeStream.Stream;
    } catch (ex) {
      Stream = function() {
      };
    }
    function createStream(opt) {
      return new CStream(opt);
    }
    function CStream(opt) {
      if (!(this instanceof CStream)) return new CStream(opt);
      this._parser = new CParser(opt);
      this.writable = true;
      this.readable = true;
      this.bytes_remaining = 0;
      this.bytes_in_sequence = 0;
      this.temp_buffs = { "2": new Buffer(2), "3": new Buffer(3), "4": new Buffer(4) };
      this.string = "";
      var me = this;
      Stream.apply(me);
      this._parser.onend = function() {
        me.emit("end");
      };
      this._parser.onerror = function(er) {
        me.emit("error", er);
        me._parser.error = null;
      };
      streamWraps.forEach(function(ev) {
        Object.defineProperty(
          me,
          "on" + ev,
          {
            get: function() {
              return me._parser["on" + ev];
            },
            set: function(h) {
              if (!h) {
                me.removeAllListeners(ev);
                me._parser["on" + ev] = h;
                return h;
              }
              me.on(ev, h);
            },
            enumerable: true,
            configurable: false
          }
        );
      });
    }
    CStream.prototype = Object.create(
      Stream.prototype,
      { constructor: { value: CStream } }
    );
    CStream.prototype.write = function(data) {
      data = new Buffer(data);
      for (var i = 0; i < data.length; i++) {
        var n = data[i];
        if (this.bytes_remaining > 0) {
          for (var j = 0; j < this.bytes_remaining; j++) {
            this.temp_buffs[this.bytes_in_sequence][this.bytes_in_sequence - this.bytes_remaining + j] = data[j];
          }
          this.string = this.temp_buffs[this.bytes_in_sequence].toString();
          this.bytes_in_sequence = this.bytes_remaining = 0;
          i = i + j - 1;
          this._parser.write(this.string);
          this.emit("data", this.string);
          continue;
        }
        if (this.bytes_remaining === 0 && n >= 128) {
          if (n >= 194 && n <= 223) this.bytes_in_sequence = 2;
          if (n >= 224 && n <= 239) this.bytes_in_sequence = 3;
          if (n >= 240 && n <= 244) this.bytes_in_sequence = 4;
          if (this.bytes_in_sequence + i > data.length) {
            for (var k = 0; k <= data.length - 1 - i; k++) {
              this.temp_buffs[this.bytes_in_sequence][k] = data[i + k];
            }
            this.bytes_remaining = i + this.bytes_in_sequence - data.length;
            return true;
          } else {
            this.string = data.slice(i, i + this.bytes_in_sequence).toString();
            i = i + this.bytes_in_sequence - 1;
            this._parser.write(this.string);
            this.emit("data", this.string);
            continue;
          }
        }
        for (var p = i; p < data.length; p++) {
          if (data[p] >= 128) break;
        }
        this.string = data.slice(i, p).toString();
        this._parser.write(this.string);
        this.emit("data", this.string);
        i = p - 1;
        continue;
      }
    };
    CStream.prototype.end = function(chunk) {
      if (chunk && chunk.length) this._parser.write(chunk.toString());
      this._parser.end();
      return true;
    };
    CStream.prototype.on = function(ev, handler) {
      var me = this;
      if (!me._parser["on" + ev] && streamWraps.indexOf(ev) !== -1) {
        me._parser["on" + ev] = function() {
          var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
          args.splice(0, 0, ev);
          me.emit.apply(me, args);
        };
      }
      return Stream.prototype.on.call(me, ev, handler);
    };
    CStream.prototype.destroy = function() {
      clearBuffers(this._parser);
      this.emit("close");
    };
    function emit(parser, event, data) {
      if (clarinet.INFO) console.log("-- emit", event, data);
      if (parser[event]) parser[event](data);
    }
    function emitNode(parser, event, data) {
      closeValue(parser);
      emit(parser, event, data);
    }
    function closeValue(parser, event) {
      parser.textNode = textopts(parser.opt, parser.textNode);
      if (parser.textNode !== void 0) {
        emit(parser, event ? event : "onvalue", parser.textNode);
      }
      parser.textNode = void 0;
    }
    function closeNumber(parser) {
      if (parser.numberNode)
        emit(parser, "onvalue", parseFloat(parser.numberNode));
      parser.numberNode = "";
    }
    function textopts(opt, text) {
      if (text === void 0) {
        return text;
      }
      if (opt.trim) text = text.trim();
      if (opt.normalize) text = text.replace(/\s+/g, " ");
      return text;
    }
    function error(parser, er) {
      closeValue(parser);
      er += "\nLine: " + parser.line + "\nColumn: " + parser.column + "\nChar: " + parser.c;
      er = new Error(er);
      parser.error = er;
      emit(parser, "onerror", er);
      return parser;
    }
    function end(parser) {
      if (parser.state !== S.VALUE || parser.depth !== 0)
        error(parser, "Unexpected end");
      closeValue(parser);
      parser.c = "";
      parser.closed = true;
      emit(parser, "onend");
      CParser.call(parser, parser.opt);
      return parser;
    }
    function isWhitespace(c) {
      return c === Char.carriageReturn || c === Char.lineFeed || c === Char.space || c === Char.tab;
    }
    function write(chunk) {
      var parser = this;
      if (this.error) throw this.error;
      if (parser.closed) return error(
        parser,
        "Cannot write after close. Assign an onready handler."
      );
      if (chunk === null) return end(parser);
      var i = 0, c = chunk.charCodeAt(0), p = parser.p;
      if (clarinet.DEBUG) console.log("write -> [" + chunk + "]");
      while (c) {
        p = c;
        parser.c = c = chunk.charCodeAt(i++);
        if (p !== c) parser.p = p;
        else p = parser.p;
        if (!c) break;
        if (clarinet.DEBUG) console.log(i, c, clarinet.STATE[parser.state]);
        parser.position++;
        if (c === Char.lineFeed) {
          parser.line++;
          parser.column = 0;
        } else parser.column++;
        switch (parser.state) {
          case S.BEGIN:
            if (c === Char.openBrace) parser.state = S.OPEN_OBJECT;
            else if (c === Char.openBracket) parser.state = S.OPEN_ARRAY;
            else if (!isWhitespace(c))
              error(parser, "Non-whitespace before {[.");
            continue;
          case S.OPEN_KEY:
          case S.OPEN_OBJECT:
            if (isWhitespace(c)) continue;
            if (parser.state === S.OPEN_KEY) parser.stack.push(S.CLOSE_KEY);
            else {
              if (c === Char.closeBrace) {
                emit(parser, "onopenobject");
                this.depth++;
                emit(parser, "oncloseobject");
                this.depth--;
                parser.state = parser.stack.pop() || S.VALUE;
                continue;
              } else parser.stack.push(S.CLOSE_OBJECT);
            }
            if (c === Char.doubleQuote) parser.state = S.STRING;
            else error(parser, 'Malformed object key should start with "');
            continue;
          case S.CLOSE_KEY:
          case S.CLOSE_OBJECT:
            if (isWhitespace(c)) continue;
            parser.state === S.CLOSE_KEY ? "key" : "object";
            if (c === Char.colon) {
              if (parser.state === S.CLOSE_OBJECT) {
                parser.stack.push(S.CLOSE_OBJECT);
                closeValue(parser, "onopenobject");
                this.depth++;
              } else closeValue(parser, "onkey");
              parser.state = S.VALUE;
            } else if (c === Char.closeBrace) {
              emitNode(parser, "oncloseobject");
              this.depth--;
              parser.state = parser.stack.pop() || S.VALUE;
            } else if (c === Char.comma) {
              if (parser.state === S.CLOSE_OBJECT)
                parser.stack.push(S.CLOSE_OBJECT);
              closeValue(parser);
              parser.state = S.OPEN_KEY;
            } else error(parser, "Bad object");
            continue;
          case S.OPEN_ARRAY:
          case S.VALUE:
            if (isWhitespace(c)) continue;
            if (parser.state === S.OPEN_ARRAY) {
              emit(parser, "onopenarray");
              this.depth++;
              parser.state = S.VALUE;
              if (c === Char.closeBracket) {
                emit(parser, "onclosearray");
                this.depth--;
                parser.state = parser.stack.pop() || S.VALUE;
                continue;
              } else {
                parser.stack.push(S.CLOSE_ARRAY);
              }
            }
            if (c === Char.doubleQuote) parser.state = S.STRING;
            else if (c === Char.openBrace) parser.state = S.OPEN_OBJECT;
            else if (c === Char.openBracket) parser.state = S.OPEN_ARRAY;
            else if (c === Char.t) parser.state = S.TRUE;
            else if (c === Char.f) parser.state = S.FALSE;
            else if (c === Char.n) parser.state = S.NULL;
            else if (c === Char.minus) {
              parser.numberNode += "-";
            } else if (Char._0 <= c && c <= Char._9) {
              parser.numberNode += String.fromCharCode(c);
              parser.state = S.NUMBER_DIGIT;
            } else error(parser, "Bad value");
            continue;
          case S.CLOSE_ARRAY:
            if (c === Char.comma) {
              parser.stack.push(S.CLOSE_ARRAY);
              closeValue(parser, "onvalue");
              parser.state = S.VALUE;
            } else if (c === Char.closeBracket) {
              emitNode(parser, "onclosearray");
              this.depth--;
              parser.state = parser.stack.pop() || S.VALUE;
            } else if (isWhitespace(c))
              continue;
            else error(parser, "Bad array");
            continue;
          case S.STRING:
            if (parser.textNode === void 0) {
              parser.textNode = "";
            }
            var starti = i - 1, slashed = parser.slashed, unicodeI = parser.unicodeI;
            STRING_BIGLOOP: while (true) {
              if (clarinet.DEBUG)
                console.log(
                  i,
                  c,
                  clarinet.STATE[parser.state],
                  slashed
                );
              while (unicodeI > 0) {
                parser.unicodeS += String.fromCharCode(c);
                c = chunk.charCodeAt(i++);
                parser.position++;
                if (unicodeI === 4) {
                  parser.textNode += String.fromCharCode(parseInt(parser.unicodeS, 16));
                  unicodeI = 0;
                  starti = i - 1;
                } else {
                  unicodeI++;
                }
                if (!c) break STRING_BIGLOOP;
              }
              if (c === Char.doubleQuote && !slashed) {
                parser.state = parser.stack.pop() || S.VALUE;
                parser.textNode += chunk.substring(starti, i - 1);
                parser.position += i - 1 - starti;
                break;
              }
              if (c === Char.backslash && !slashed) {
                slashed = true;
                parser.textNode += chunk.substring(starti, i - 1);
                parser.position += i - 1 - starti;
                c = chunk.charCodeAt(i++);
                parser.position++;
                if (!c) break;
              }
              if (slashed) {
                slashed = false;
                if (c === Char.n) {
                  parser.textNode += "\n";
                } else if (c === Char.r) {
                  parser.textNode += "\r";
                } else if (c === Char.t) {
                  parser.textNode += "	";
                } else if (c === Char.f) {
                  parser.textNode += "\f";
                } else if (c === Char.b) {
                  parser.textNode += "\b";
                } else if (c === Char.u) {
                  unicodeI = 1;
                  parser.unicodeS = "";
                } else {
                  parser.textNode += String.fromCharCode(c);
                }
                c = chunk.charCodeAt(i++);
                parser.position++;
                starti = i - 1;
                if (!c) break;
                else continue;
              }
              stringTokenPattern.lastIndex = i;
              var reResult = stringTokenPattern.exec(chunk);
              if (reResult === null) {
                i = chunk.length + 1;
                parser.textNode += chunk.substring(starti, i - 1);
                parser.position += i - 1 - starti;
                break;
              }
              i = reResult.index + 1;
              c = chunk.charCodeAt(reResult.index);
              if (!c) {
                parser.textNode += chunk.substring(starti, i - 1);
                parser.position += i - 1 - starti;
                break;
              }
            }
            parser.slashed = slashed;
            parser.unicodeI = unicodeI;
            continue;
          case S.TRUE:
            if (c === Char.r) parser.state = S.TRUE2;
            else error(parser, "Invalid true started with t" + c);
            continue;
          case S.TRUE2:
            if (c === Char.u) parser.state = S.TRUE3;
            else error(parser, "Invalid true started with tr" + c);
            continue;
          case S.TRUE3:
            if (c === Char.e) {
              emit(parser, "onvalue", true);
              parser.state = parser.stack.pop() || S.VALUE;
            } else error(parser, "Invalid true started with tru" + c);
            continue;
          case S.FALSE:
            if (c === Char.a) parser.state = S.FALSE2;
            else error(parser, "Invalid false started with f" + c);
            continue;
          case S.FALSE2:
            if (c === Char.l) parser.state = S.FALSE3;
            else error(parser, "Invalid false started with fa" + c);
            continue;
          case S.FALSE3:
            if (c === Char.s) parser.state = S.FALSE4;
            else error(parser, "Invalid false started with fal" + c);
            continue;
          case S.FALSE4:
            if (c === Char.e) {
              emit(parser, "onvalue", false);
              parser.state = parser.stack.pop() || S.VALUE;
            } else error(parser, "Invalid false started with fals" + c);
            continue;
          case S.NULL:
            if (c === Char.u) parser.state = S.NULL2;
            else error(parser, "Invalid null started with n" + c);
            continue;
          case S.NULL2:
            if (c === Char.l) parser.state = S.NULL3;
            else error(parser, "Invalid null started with nu" + c);
            continue;
          case S.NULL3:
            if (c === Char.l) {
              emit(parser, "onvalue", null);
              parser.state = parser.stack.pop() || S.VALUE;
            } else error(parser, "Invalid null started with nul" + c);
            continue;
          case S.NUMBER_DECIMAL_POINT:
            if (c === Char.period) {
              parser.numberNode += ".";
              parser.state = S.NUMBER_DIGIT;
            } else error(parser, "Leading zero not followed by .");
            continue;
          case S.NUMBER_DIGIT:
            if (Char._0 <= c && c <= Char._9) parser.numberNode += String.fromCharCode(c);
            else if (c === Char.period) {
              if (parser.numberNode.indexOf(".") !== -1)
                error(parser, "Invalid number has two dots");
              parser.numberNode += ".";
            } else if (c === Char.e || c === Char.E) {
              if (parser.numberNode.indexOf("e") !== -1 || parser.numberNode.indexOf("E") !== -1)
                error(parser, "Invalid number has two exponential");
              parser.numberNode += "e";
            } else if (c === Char.plus || c === Char.minus) {
              if (!(p === Char.e || p === Char.E))
                error(parser, "Invalid symbol in number");
              parser.numberNode += String.fromCharCode(c);
            } else {
              closeNumber(parser);
              i--;
              parser.state = parser.stack.pop() || S.VALUE;
            }
            continue;
          default:
            error(parser, "Unknown state: " + parser.state);
        }
      }
      if (parser.position >= parser.bufferCheckPosition)
        checkBufferLength(parser);
      return parser;
    }
  })(exports);
});
function JsonStream(blob) {
  var pos = 0;
  var parser = JsonParser(true);
  var rv = {
    pullAsync: function(numBytes) {
      return __awaiter(this, void 0, void 0, function() {
        var slize, jsonPart, result;
        return __generator(this, function(_a) {
          switch (_a.label) {
            case 0:
              slize = blob.slice(pos, pos + numBytes);
              pos += numBytes;
              return [4, readBlobAsync(slize, "text")];
            case 1:
              jsonPart = _a.sent();
              result = parser.write(jsonPart);
              rv.result = result || {};
              return [2, result];
          }
        });
      });
    },
    pullSync: function(numBytes) {
      var slize = blob.slice(pos, pos + numBytes);
      pos += numBytes;
      var jsonPart = readBlobSync(slize, "text");
      var result = parser.write(jsonPart);
      rv.result = result || {};
      return result;
    },
    done: function() {
      return parser.done();
    },
    eof: function() {
      return pos >= blob.size;
    },
    result: {}
  };
  return rv;
}
function JsonParser(allowPartial) {
  var parser = clarinet_1.parser();
  var level = 0;
  var result;
  var stack = [];
  var obj;
  var key;
  var done = false;
  var array = false;
  parser.onopenobject = function(newKey) {
    var newObj = {};
    newObj.incomplete = true;
    if (!result)
      result = newObj;
    if (obj) {
      stack.push([key, obj, array]);
      if (allowPartial) {
        if (array) {
          obj.push(newObj);
        } else {
          obj[key] = newObj;
        }
      }
    }
    obj = newObj;
    key = newKey;
    array = false;
    ++level;
  };
  parser.onkey = function(newKey) {
    return key = newKey;
  };
  parser.onvalue = function(value) {
    return array ? obj.push(value) : obj[key] = value;
  };
  parser.oncloseobject = function() {
    var _a;
    delete obj.incomplete;
    key = null;
    if (--level === 0) {
      done = true;
    } else {
      var completedObj = obj;
      _a = stack.pop(), key = _a[0], obj = _a[1], array = _a[2];
      if (!allowPartial) {
        if (array) {
          obj.push(completedObj);
        } else {
          obj[key] = completedObj;
        }
      }
    }
  };
  parser.onopenarray = function() {
    var newObj = [];
    newObj.incomplete = true;
    if (!result)
      result = newObj;
    if (obj) {
      stack.push([key, obj, array]);
      if (allowPartial) {
        if (array) {
          obj.push(newObj);
        } else {
          obj[key] = newObj;
        }
      }
    }
    obj = newObj;
    array = true;
    key = null;
    ++level;
  };
  parser.onclosearray = function() {
    var _a;
    delete obj.incomplete;
    key = null;
    if (--level === 0) {
      done = true;
    } else {
      var completedObj = obj;
      _a = stack.pop(), key = _a[0], obj = _a[1], array = _a[2];
      if (!allowPartial) {
        if (array) {
          obj.push(completedObj);
        } else {
          obj[key] = completedObj;
        }
      }
    }
  };
  return {
    write: function(jsonPart) {
      parser.write(jsonPart);
      return result;
    },
    done: function() {
      return done;
    }
  };
}
var DEFAULT_KILOBYTES_PER_CHUNK = 1024;
function importDB(exportedData, options) {
  return __awaiter(this, void 0, void 0, function() {
    var CHUNK_SIZE, stream, dbExport, db;
    return __generator(this, function(_a) {
      switch (_a.label) {
        case 0:
          options = options || {};
          CHUNK_SIZE = options.chunkSizeBytes || DEFAULT_KILOBYTES_PER_CHUNK * 1024;
          return [4, loadUntilWeGotEnoughData(exportedData, CHUNK_SIZE)];
        case 1:
          stream = _a.sent();
          dbExport = stream.result.data;
          db = new Dexie$1(dbExport.databaseName);
          db.version(dbExport.databaseVersion).stores(extractDbSchema(dbExport));
          return [4, importInto(db, stream, options)];
        case 2:
          _a.sent();
          return [2, db];
      }
    });
  });
}
function importInto(db, exportedData, options) {
  return __awaiter(this, void 0, void 0, function() {
    function importAll() {
      return __awaiter(this, void 0, void 0, function() {
        var _loop_1, _i2, _a2, tableExport, state_1;
        return __generator(this, function(_b) {
          switch (_b.label) {
            case 0:
              _loop_1 = function(tableExport2) {
                var tableName, table2, tableSchemaStr, sourceRows, rows, i, obj, filter, transform, filteredRows, _c, keys2, values;
                return __generator(this, function(_d) {
                  switch (_d.label) {
                    case 0:
                      if (skipTables.includes(tableExport2.tableName))
                        return [2, "continue"];
                      if (!tableExport2.rows)
                        return [2, "break"];
                      if (!tableExport2.rows.incomplete && tableExport2.rows.length === 0)
                        return [2, "continue"];
                      if (progressCallback) {
                        Dexie$1.ignoreTransaction(function() {
                          return progressCallback(progress);
                        });
                      }
                      tableName = tableExport2.tableName;
                      table2 = db.table(tableName);
                      tableSchemaStr = dbExport.tables.filter(function(t) {
                        return t.name === tableName;
                      })[0].schema;
                      if (!table2) {
                        if (!options.acceptMissingTables)
                          throw new Error("Exported table ".concat(tableExport2.tableName, " is missing in installed database"));
                        else
                          return [2, "continue"];
                      }
                      if (!options.acceptChangedPrimaryKey && tableSchemaStr.split(",")[0] != table2.schema.primKey.src) {
                        throw new Error("Primary key differs for table ".concat(tableExport2.tableName, ". "));
                      }
                      sourceRows = tableExport2.rows;
                      rows = [];
                      for (i = 0; i < sourceRows.length; i++) {
                        obj = sourceRows[i];
                        if (!obj.incomplete) {
                          rows.push(TSON.revive(obj));
                        } else {
                          break;
                        }
                      }
                      filter = options.filter;
                      transform = options.transform;
                      filteredRows = filter ? tableExport2.inbound ? rows.filter(function(value) {
                        return filter(tableName, value);
                      }) : rows.filter(function(_a3) {
                        var key = _a3[0], value = _a3[1];
                        return filter(tableName, value, key);
                      }) : rows;
                      if (transform) {
                        filteredRows = filteredRows.map(tableExport2.inbound ? function(value) {
                          return transform(tableName, value).value;
                        } : function(_a3) {
                          var key = _a3[0], value = _a3[1];
                          var res = transform(tableName, value, key);
                          return [res.key, res.value];
                        });
                      }
                      _c = tableExport2.inbound ? [void 0, filteredRows] : [filteredRows.map(function(row) {
                        return row[0];
                      }), rows.map(function(row) {
                        return row[1];
                      })], keys2 = _c[0], values = _c[1];
                      if (!options.overwriteValues) return [3, 2];
                      return [4, table2.bulkPut(values, keys2)];
                    case 1:
                      _d.sent();
                      return [3, 4];
                    case 2:
                      return [4, table2.bulkAdd(values, keys2)];
                    case 3:
                      _d.sent();
                      _d.label = 4;
                    case 4:
                      progress.completedRows += rows.length;
                      if (!rows.incomplete) {
                        progress.completedTables += 1;
                      }
                      sourceRows.splice(0, rows.length);
                      return [
                        2
                        /*return*/
                      ];
                  }
                });
              };
              _i2 = 0, _a2 = dbExport.data;
              _b.label = 1;
            case 1:
              if (!(_i2 < _a2.length)) return [3, 4];
              tableExport = _a2[_i2];
              return [5, _loop_1(tableExport)];
            case 2:
              state_1 = _b.sent();
              if (state_1 === "break")
                return [3, 4];
              _b.label = 3;
            case 3:
              _i2++;
              return [3, 1];
            case 4:
              while (dbExport.data.length > 0 && dbExport.data[0].rows && !dbExport.data[0].rows.incomplete) {
                dbExport.data.splice(0, 1);
              }
              if (!(!jsonStream.done() && !jsonStream.eof())) return [3, 8];
              if (!readBlobsSynchronously2) return [3, 5];
              jsonStream.pullSync(CHUNK_SIZE);
              return [3, 7];
            case 5:
              return [4, Dexie$1.waitFor(jsonStream.pullAsync(CHUNK_SIZE))];
            case 6:
              _b.sent();
              _b.label = 7;
            case 7:
              return [3, 9];
            case 8:
              return [3, 10];
            case 9:
              return [3, 0];
            case 10:
              return [
                2
                /*return*/
              ];
          }
        });
      });
    }
    var CHUNK_SIZE, jsonStream, dbExportFile, readBlobsSynchronously2, dbExport, skipTables, progressCallback, progress, _i, _a, table;
    return __generator(this, function(_b) {
      switch (_b.label) {
        case 0:
          options = options || {};
          CHUNK_SIZE = options.chunkSizeBytes || DEFAULT_KILOBYTES_PER_CHUNK * 1024;
          return [4, loadUntilWeGotEnoughData(exportedData, CHUNK_SIZE)];
        case 1:
          jsonStream = _b.sent();
          dbExportFile = jsonStream.result;
          readBlobsSynchronously2 = "FileReaderSync" in self;
          dbExport = dbExportFile.data;
          skipTables = options.skipTables ? options.skipTables : [];
          if (!options.acceptNameDiff && db.name !== dbExport.databaseName)
            throw new Error("Name differs. Current database name is ".concat(db.name, " but export is ").concat(dbExport.databaseName));
          if (!options.acceptVersionDiff && db.verno !== dbExport.databaseVersion) {
            throw new Error("Database version differs. Current database is in version ".concat(db.verno, " but export is ").concat(dbExport.databaseVersion));
          }
          progressCallback = options.progressCallback;
          progress = {
            done: false,
            completedRows: 0,
            completedTables: 0,
            totalRows: dbExport.tables.reduce(function(p, c) {
              return p + c.rowCount;
            }, 0),
            totalTables: dbExport.tables.length
          };
          if (progressCallback) {
            Dexie$1.ignoreTransaction(function() {
              return progressCallback(progress);
            });
          }
          if (!options.clearTablesBeforeImport) return [3, 5];
          _i = 0, _a = db.tables;
          _b.label = 2;
        case 2:
          if (!(_i < _a.length)) return [3, 5];
          table = _a[_i];
          if (skipTables.includes(table.name))
            return [3, 4];
          return [4, table.clear()];
        case 3:
          _b.sent();
          _b.label = 4;
        case 4:
          _i++;
          return [3, 2];
        case 5:
          if (!options.noTransaction) return [3, 7];
          return [4, importAll()];
        case 6:
          _b.sent();
          return [3, 9];
        case 7:
          return [4, db.transaction("rw", db.tables, importAll)];
        case 8:
          _b.sent();
          _b.label = 9;
        case 9:
          progress.done = true;
          if (progressCallback) {
            Dexie$1.ignoreTransaction(function() {
              return progressCallback(progress);
            });
          }
          return [
            2
            /*return*/
          ];
      }
    });
  });
}
function loadUntilWeGotEnoughData(exportedData, CHUNK_SIZE) {
  return __awaiter(this, void 0, void 0, function() {
    var stream, dbExportFile;
    return __generator(this, function(_a) {
      switch (_a.label) {
        case 0:
          stream = "slice" in exportedData ? JsonStream(exportedData) : exportedData;
          _a.label = 1;
        case 1:
          if (!!stream.eof()) return [3, 3];
          return [4, stream.pullAsync(CHUNK_SIZE)];
        case 2:
          _a.sent();
          if (stream.result.data && stream.result.data.data)
            return [3, 3];
          return [3, 1];
        case 3:
          dbExportFile = stream.result;
          if (!dbExportFile || dbExportFile.formatName != "dexie")
            throw new Error("Given file is not a dexie export");
          if (dbExportFile.formatVersion > VERSION) {
            throw new Error("Format version ".concat(dbExportFile.formatVersion, " not supported"));
          }
          if (!dbExportFile.data) {
            throw new Error("No data in export file");
          }
          if (!dbExportFile.data.databaseName) {
            throw new Error("Missing databaseName in export file");
          }
          if (!dbExportFile.data.databaseVersion) {
            throw new Error("Missing databaseVersion in export file");
          }
          if (!dbExportFile.data.tables) {
            throw new Error("Missing tables in export file");
          }
          return [2, stream];
      }
    });
  });
}
Dexie$1.prototype.export = function(options) {
  return exportDB(this, options);
};
Dexie$1.prototype.import = function(blob, options) {
  return importInto(this, blob, options);
};
Dexie$1.import = function(blob, options) {
  return importDB(blob, options);
};
export {
  Dexie$1 as Dexie
};
/*! Bundled license information:

dexie-export-import/dist/dexie-export-import.mjs:
  (*! *****************************************************************************
  Copyright (c) Microsoft Corporation.
  
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.
  
  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** *)
*/
//# sourceMappingURL=dexie.js.map