indexeddbshim 6.6.0 → 9.0.0

package/dist/indexeddbshim-UnicodeIdentifiers-node.js

@@ -1,75 +1,70 @@
-/*! indexeddbshim - v6.6.0 - 6/26/2020 */
+/*! indexeddbshim - v9.0.0 - 1/5/2022 */
 
 'use strict';
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+var path = require('path');
+var customOpenDatabase = require('websql/custom/index.js');
 
-var path = _interopDefault(require('path'));
-var customOpenDatabase = _interopDefault(require('websql/custom/index.js'));
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var customOpenDatabase__default = /*#__PURE__*/_interopDefaultLegacy(customOpenDatabase);
 
-  return obj;
-}
-
-function ownKeys(object, enumerableOnly) {
+function ownKeys$1(object, enumerableOnly) {
   var keys = Object.keys(object);
 
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
       return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
-    keys.push.apply(keys, symbols);
+    })), keys.push.apply(keys, symbols);
   }
 
   return keys;
 }
 
-function _objectSpread2(target) {
+function _objectSpread2$1(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));
-      });
-    }
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) {
+      _defineProperty$1(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
   }
 
   return target;
 }
 
-function _typeof(obj) {
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function _typeof$1(obj) {
   "@babel/helpers - typeof";
 
   if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function (obj) {
+    _typeof$1 = function (obj) {
       return typeof obj;
     };
   } else {
-    _typeof = function (obj) {
+    _typeof$1 = function (obj) {
       return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
     };
   }
 
-  return _typeof(obj);
+  return _typeof$1(obj);
 }
 /* eslint-disable no-sync, no-restricted-syntax */
 // Todo: Switch to ES6 classes
@@ -81,7 +76,7 @@ var phases = {
   AT_TARGET: 2,
   BUBBLING_PHASE: 3
 };
-var ShimDOMException = typeof DOMException === 'undefined' // Todo: Better polyfill (if even needed here)
+var ShimDOMException$1 = typeof DOMException === 'undefined' // Todo: Better polyfill (if even needed here)
 // eslint-disable-next-line no-shadow
 ? function DOMException(msg, name) {
   // No need for `toString` as same as for `Error`
@@ -465,7 +460,7 @@ Object.assign(EventTarget.prototype, ['Early', '', 'Late', 'Default'].reduce(fun
       if (arguments.length < 2) throw new TypeError('2 or more arguments required');
 
       if (typeof type !== 'string') {
-        throw new ShimDOMException('UNSPECIFIED_EVENT_TYPE_ERR', 'UNSPECIFIED_EVENT_TYPE_ERR');
+        throw new ShimDOMException$1('UNSPECIFIED_EVENT_TYPE_ERR', 'UNSPECIFIED_EVENT_TYPE_ERR');
       }
 
       try {
@@ -526,7 +521,7 @@ Object.assign(EventTarget.prototype, {
     var _evCfg = evCfg.get(e);
 
     if (_evCfg && setTarget && _evCfg._dispatched) {
-      throw new ShimDOMException('The object is in an invalid state.', 'InvalidStateError');
+      throw new ShimDOMException$1('The object is in an invalid state.', 'InvalidStateError');
     }
 
     var eventCopy;
@@ -768,7 +763,7 @@ Object.assign(EventTarget.prototype, {
     var triggerGlobalErrorEvent;
     var useNodeImpl = false;
 
-    if (typeof window === 'undefined' || typeof ErrorEvent === 'undefined' || window && (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object' && !window.dispatchEvent) {
+    if (typeof window === 'undefined' || typeof ErrorEvent === 'undefined' || window && (typeof window === "undefined" ? "undefined" : _typeof$1(window)) === 'object' && !window.dispatchEvent) {
       useNodeImpl = true;
 
       triggerGlobalErrorEvent = function triggerGlobalErrorEvent() {
@@ -837,7 +832,7 @@ var EventTargetFactory = {
 };
 EventTarget.ShimEvent = ShimEvent;
 EventTarget.ShimCustomEvent = ShimCustomEvent;
-EventTarget.ShimDOMException = ShimDOMException;
+EventTarget.ShimDOMException = ShimDOMException$1;
 EventTarget.ShimEventTarget = EventTarget;
 EventTarget.EventTargetFactory = EventTargetFactory;
 /**
@@ -850,7 +845,7 @@ function setPrototypeOfCustomEvent() {
   Object.setPrototypeOf(ShimCustomEvent.prototype, ShimEvent.prototype);
 } // Todo: Move to own library (but allowing WeakMaps to be passed in for sharing here)
 
-const map = {};
+const map$1 = {};
 const CFG = {};
 [// Boolean for verbose reporting
 'DEBUG', // Effectively defaults to false (ignored unless `true`)
@@ -955,7 +950,7 @@ const CFG = {};
 
   Object.defineProperty(CFG, prop, {
     get() {
-      return map[prop];
+      return map$1[prop];
     },
 
     set(val) {
@@ -963,13 +958,13 @@ const CFG = {};
         validator(val);
       }
 
-      map[prop] = val;
+      map$1[prop] = val;
     }
 
   });
 });
 
-var regex = /[\xC0-\xC5\xC7-\xCF\xD1-\xD6\xD9-\xDD\xE0-\xE5\xE7-\xEF\xF1-\xF6\xF9-\xFD\xFF-\u010F\u0112-\u0125\u0128-\u0130\u0134-\u0137\u0139-\u013E\u0143-\u0148\u014C-\u0151\u0154-\u0165\u0168-\u017E\u01A0\u01A1\u01AF\u01B0\u01CD-\u01DC\u01DE-\u01E3\u01E6-\u01F0\u01F4\u01F5\u01F8-\u021B\u021E\u021F\u0226-\u0233\u0344\u0385\u0386\u0388-\u038A\u038C\u038E-\u0390\u03AA-\u03B0\u03CA-\u03CE\u03D3\u03D4\u0400\u0401\u0403\u0407\u040C-\u040E\u0419\u0439\u0450\u0451\u0453\u0457\u045C-\u045E\u0476\u0477\u04C1\u04C2\u04D0-\u04D3\u04D6\u04D7\u04DA-\u04DF\u04E2-\u04E7\u04EA-\u04F5\u04F8\u04F9\u0622-\u0626\u06C0\u06C2\u06D3\u0929\u0931\u0934\u0958-\u095F\u09CB\u09CC\u09DC\u09DD\u09DF\u0A33\u0A36\u0A59-\u0A5B\u0A5E\u0B48\u0B4B\u0B4C\u0B5C\u0B5D\u0B94\u0BCA-\u0BCC\u0C48\u0CC0\u0CC7\u0CC8\u0CCA\u0CCB\u0D4A-\u0D4C\u0DDA\u0DDC-\u0DDE\u0F43\u0F4D\u0F52\u0F57\u0F5C\u0F69\u0F73\u0F75\u0F76\u0F78\u0F81\u0F93\u0F9D\u0FA2\u0FA7\u0FAC\u0FB9\u1026\u1B06\u1B08\u1B0A\u1B0C\u1B0E\u1B12\u1B3B\u1B3D\u1B40\u1B41\u1B43\u1E00-\u1E99\u1E9B\u1EA0-\u1EF9\u1F00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FC1-\u1FC4\u1FC6-\u1FD3\u1FD6-\u1FDB\u1FDD-\u1FEE\u1FF2-\u1FF4\u1FF6-\u1FFC\u212B\u219A\u219B\u21AE\u21CD-\u21CF\u2204\u2209\u220C\u2224\u2226\u2241\u2244\u2247\u2249\u2260\u2262\u226D-\u2271\u2274\u2275\u2278\u2279\u2280\u2281\u2284\u2285\u2288\u2289\u22AC-\u22AF\u22E0-\u22E3\u22EA-\u22ED\u2ADC\u304C\u304E\u3050\u3052\u3054\u3056\u3058\u305A\u305C\u305E\u3060\u3062\u3065\u3067\u3069\u3070\u3071\u3073\u3074\u3076\u3077\u3079\u307A\u307C\u307D\u3094\u309E\u30AC\u30AE\u30B0\u30B2\u30B4\u30B6\u30B8\u30BA\u30BC\u30BE\u30C0\u30C2\u30C5\u30C7\u30C9\u30D0\u30D1\u30D3\u30D4\u30D6\u30D7\u30D9\u30DA\u30DC\u30DD\u30F4\u30F7-\u30FA\u30FE\uAC00-\uD7A3\uFB1D\uFB1F\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFB4E]|\uD804[\uDC9A\uDC9C\uDCAB\uDD2E\uDD2F\uDF4B\uDF4C]|\uD805[\uDCBB\uDCBC\uDCBE\uDDBA\uDDBB]|\uD834[\uDD5E-\uDD64\uDDBB-\uDDC0]/;
+var regex = /[\xC0-\xC5\xC7-\xCF\xD1-\xD6\xD9-\xDD\xE0-\xE5\xE7-\xEF\xF1-\xF6\xF9-\xFD\xFF-\u010F\u0112-\u0125\u0128-\u0130\u0134-\u0137\u0139-\u013E\u0143-\u0148\u014C-\u0151\u0154-\u0165\u0168-\u017E\u01A0\u01A1\u01AF\u01B0\u01CD-\u01DC\u01DE-\u01E3\u01E6-\u01F0\u01F4\u01F5\u01F8-\u021B\u021E\u021F\u0226-\u0233\u0344\u0385\u0386\u0388-\u038A\u038C\u038E-\u0390\u03AA-\u03B0\u03CA-\u03CE\u03D3\u03D4\u0400\u0401\u0403\u0407\u040C-\u040E\u0419\u0439\u0450\u0451\u0453\u0457\u045C-\u045E\u0476\u0477\u04C1\u04C2\u04D0-\u04D3\u04D6\u04D7\u04DA-\u04DF\u04E2-\u04E7\u04EA-\u04F5\u04F8\u04F9\u0622-\u0626\u06C0\u06C2\u06D3\u0929\u0931\u0934\u0958-\u095F\u09CB\u09CC\u09DC\u09DD\u09DF\u0A33\u0A36\u0A59-\u0A5B\u0A5E\u0B48\u0B4B\u0B4C\u0B5C\u0B5D\u0B94\u0BCA-\u0BCC\u0C48\u0CC0\u0CC7\u0CC8\u0CCA\u0CCB\u0D4A-\u0D4C\u0DDA\u0DDC-\u0DDE\u0F43\u0F4D\u0F52\u0F57\u0F5C\u0F69\u0F73\u0F75\u0F76\u0F78\u0F81\u0F93\u0F9D\u0FA2\u0FA7\u0FAC\u0FB9\u1026\u1B06\u1B08\u1B0A\u1B0C\u1B0E\u1B12\u1B3B\u1B3D\u1B40\u1B41\u1B43\u1E00-\u1E99\u1E9B\u1EA0-\u1EF9\u1F00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FC1-\u1FC4\u1FC6-\u1FD3\u1FD6-\u1FDB\u1FDD-\u1FEE\u1FF2-\u1FF4\u1FF6-\u1FFC\u212B\u219A\u219B\u21AE\u21CD-\u21CF\u2204\u2209\u220C\u2224\u2226\u2241\u2244\u2247\u2249\u2260\u2262\u226D-\u2271\u2274\u2275\u2278\u2279\u2280\u2281\u2284\u2285\u2288\u2289\u22AC-\u22AF\u22E0-\u22E3\u22EA-\u22ED\u2ADC\u304C\u304E\u3050\u3052\u3054\u3056\u3058\u305A\u305C\u305E\u3060\u3062\u3065\u3067\u3069\u3070\u3071\u3073\u3074\u3076\u3077\u3079\u307A\u307C\u307D\u3094\u309E\u30AC\u30AE\u30B0\u30B2\u30B4\u30B6\u30B8\u30BA\u30BC\u30BE\u30C0\u30C2\u30C5\u30C7\u30C9\u30D0\u30D1\u30D3\u30D4\u30D6\u30D7\u30D9\u30DA\u30DC\u30DD\u30F4\u30F7-\u30FA\u30FE\uAC00-\uD7A3\uFB1D\uFB1F\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFB4E]|\uD804[\uDC9A\uDC9C\uDCAB\uDD2E\uDD2F\uDF4B\uDF4C]|\uD805[\uDCBB\uDCBC\uDCBE\uDDBA\uDDBB]|\uD806\uDD38|\uD834[\uDD5E-\uDD64\uDDBB-\uDDC0]/;
 
 function escapeUnmatchedSurrogates(arg) {
   // http://stackoverflow.com/a/6701665/271577
@@ -977,10 +972,10 @@ function escapeUnmatchedSurrogates(arg) {
     // Could add a corresponding surrogate for compatibility with `node-sqlite3`: http://bugs.python.org/issue12569 and http://stackoverflow.com/a/6701665/271577
     //   but Chrome having problems
     if (unmatchedHighSurrogate) {
-      return '^2' + padStart(unmatchedHighSurrogate.charCodeAt().toString(16), 4, '0');
+      return '^2' + unmatchedHighSurrogate.codePointAt().toString(16).padStart(4, '0');
     }
 
-    return (precedingLow || '') + '^3' + padStart(unmatchedLowSurrogate.charCodeAt().toString(16), 4, '0');
+    return (precedingLow || '') + '^3' + unmatchedLowSurrogate.codePointAt().toString(16).padStart(4, '0');
   });
 }
 
@@ -1032,18 +1027,16 @@ function escapeDatabaseNameForSQLAndFiles(db) {
 
   if (CFG.escapeNFDForDatabaseNames !== false) {
     // ES6 copying of regex with different flags
-    // Todo: Remove `.source` when
-    //   https://github.com/babel/babel/issues/5978 completed (see also
-    //   https://github.com/axemclion/IndexedDBShim/issues/311#issuecomment-316090147 )
-    db = db.replace(new RegExp(regex.source, 'gu'), function (expandable) {
-      return '^4' + padStart(expandable.codePointAt().toString(16), 6, '0');
+    db = db.replace(new RegExp(regex, 'gu'), function (expandable) {
+      return '^4' + expandable.codePointAt().toString(16).padStart(6, '0');
     });
   }
 
   if (CFG.databaseCharacterEscapeList !== false) {
     db = db.replace(CFG.databaseCharacterEscapeList ? new RegExp(CFG.databaseCharacterEscapeList, 'gu') : /[\u0000-\u001F\u007F"*/:<>?\\|]/gu, // eslint-disable-line no-control-regex
     function (n0) {
-      return '^1' + padStart(n0.charCodeAt().toString(16), 2, '0');
+      // eslint-disable-next-line unicorn/prefer-code-point -- Switch to `codePointAt`?
+      return '^1' + n0.charCodeAt().toString(16).padStart(2, '0');
     });
   }
 
@@ -1058,9 +1051,9 @@ function escapeDatabaseNameForSQLAndFiles(db) {
 
 function unescapeUnmatchedSurrogates(arg) {
   return arg.replace(/(\^+)3(d[0-9a-f]{3})/gu, (_, esc, lowSurr) => {
-    return esc.length % 2 ? esc.slice(1) + String.fromCharCode(Number.parseInt(lowSurr, 16)) : _;
+    return esc.length % 2 ? esc.slice(1) + String.fromCodePoint(Number.parseInt(lowSurr, 16)) : _;
   }).replace(/(\^+)2(d[0-9a-f]{3})/gu, (_, esc, highSurr) => {
-    return esc.length % 2 ? esc.slice(1) + String.fromCharCode(Number.parseInt(highSurr, 16)) : _;
+    return esc.length % 2 ? esc.slice(1) + String.fromCodePoint(Number.parseInt(highSurr, 16)) : _;
   });
 } // Not in use internally but supplied for convenience
 
@@ -1281,13 +1274,8 @@ function isNullish(v) {
   return v === null || v === undefined;
 }
 
-function hasOwn(obj, prop) {
-  return {}.hasOwnProperty.call(obj, prop);
-} // Todo: Replace with `String.prototype.padStart` when targeting supporting Node version
-
-
-function padStart(str, ct, fill) {
-  return new Array(ct - String(str).length + 1).join(fill) + str;
+function hasOwn$2(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
 /**
@@ -1309,7 +1297,7 @@ Object.defineProperty(ShimEvent, Symbol.hasInstance, {
   value: obj => isObj(obj) && 'target' in obj && typeof obj.bubbles === 'boolean'
 });
 
-const readonlyProperties = ['oldVersion', 'newVersion']; // Babel apparently having a problem adding `hasInstance` to a class, so we are redefining as a function
+const readonlyProperties$6 = ['oldVersion', 'newVersion']; // Babel apparently having a problem adding `hasInstance` to a class, so we are redefining as a function
 
 function IDBVersionChangeEvent(type
 /* , eventInitDict */
@@ -1328,7 +1316,7 @@ function IDBVersionChangeEvent(type
 
 IDBVersionChangeEvent.prototype = Object.create(ShimEvent.prototype);
 IDBVersionChangeEvent.prototype[Symbol.toStringTag] = 'IDBVersionChangeEventPrototype';
-readonlyProperties.forEach(prop => {
+readonlyProperties$6.forEach(prop => {
   // Ensure for proper interface testing that "get <name>" is the function name
   const o = {
     get [prop]() {
@@ -1671,10 +1659,10 @@ const createDOMException = useNativeDOMException ? function (name, message, erro
   logError(name, message, error);
   return createNonNativeDOMException(name, message);
 };
-const ShimDOMException$1 = useNativeDOMException ? DOMException : ShimNonNativeDOMException;
+const ShimDOMException = useNativeDOMException ? DOMException : ShimNonNativeDOMException;
 
-const listeners = ['onsuccess', 'onerror'];
-const readonlyProperties$1 = ['source', 'transaction', 'readyState'];
+const listeners$2 = ['onsuccess', 'onerror'];
+const readonlyProperties$5 = ['source', 'transaction', 'readyState'];
 const doneFlagGetters = ['result', 'error'];
 /**
  * The IDBRequest Object that is returns for all async calls.
@@ -1695,7 +1683,7 @@ IDBRequest.__super = function IDBRequest() {
 
   });
 
-  doneFlagGetters.forEach(function (prop) {
+  doneFlagGetters.forEach(prop => {
     Object.defineProperty(this, '__' + prop, {
       enumerable: false,
       configurable: false,
@@ -1714,8 +1702,8 @@ IDBRequest.__super = function IDBRequest() {
       }
 
     });
-  }, this);
-  defineReadonlyProperties(this, readonlyProperties$1, {
+  });
+  defineReadonlyProperties(this, readonlyProperties$5, {
     readyState: {
       get readyState() {
         return this.__done ? 'done' : 'pending';
@@ -1723,7 +1711,7 @@ IDBRequest.__super = function IDBRequest() {
 
     }
   });
-  defineListenerProperties(this, listeners);
+  defineListenerProperties(this, listeners$2);
   this.__result = undefined;
   this.__error = this.__source = this.__transaction = null;
   this.__done = false;
@@ -1747,9 +1735,9 @@ IDBRequest.prototype.__getParent = function () {
 }; // Illegal invocations
 
 
-defineReadonlyOuterInterface(IDBRequest.prototype, readonlyProperties$1);
+defineReadonlyOuterInterface(IDBRequest.prototype, readonlyProperties$5);
 defineReadonlyOuterInterface(IDBRequest.prototype, doneFlagGetters);
-defineOuterInterface(IDBRequest.prototype, listeners);
+defineOuterInterface(IDBRequest.prototype, listeners$2);
 Object.defineProperty(IDBRequest.prototype, 'constructor', {
   enumerable: false,
   writable: true,
@@ -1805,9 +1793,9 @@ Object.defineProperty(IDBOpenDBRequest, 'prototype', {
   writable: false
 });
 
-// Since [immediate](https://github.com/calvinmetcalf/immediate) is
 //   not doing the trick for our WebSQL transactions (at least in Node),
 //   we are forced to make the promises run fully synchronously.
+
 function isPromise(p) {
   return p && typeof p.then === 'function';
 }
@@ -1982,14 +1970,14 @@ var syncPromiseCommonjs = SyncPromise;
  */
 
 function cmp(first, second) {
-  const encodedKey1 = encode(first);
-  const encodedKey2 = encode(second);
+  const encodedKey1 = encode$2(first);
+  const encodedKey2 = encode$2(second);
   const result = encodedKey1 > encodedKey2 ? 1 : encodedKey1 === encodedKey2 ? 0 : -1;
 
   if (CFG.DEBUG) {
     // verify that the keys encoded correctly
-    let decodedKey1 = decode(encodedKey1);
-    let decodedKey2 = decode(encodedKey2);
+    let decodedKey1 = decode$2(encodedKey1);
+    let decodedKey2 = decode$2(encodedKey2);
 
     if (typeof first === 'object') {
       first = JSON.stringify(first);
@@ -2034,7 +2022,7 @@ const keyTypeToEncodedChar = {
 };
 const keyTypes = Object.keys(keyTypeToEncodedChar);
 keyTypes.forEach(k => {
-  keyTypeToEncodedChar[k] = String.fromCharCode(keyTypeToEncodedChar[k]);
+  keyTypeToEncodedChar[k] = String.fromCodePoint(keyTypeToEncodedChar[k]);
 });
 const encodedCharToKeyType = keyTypes.reduce((o, k) => {
   o[keyTypeToEncodedChar[k]] = k;
@@ -2135,10 +2123,10 @@ const types = {
 
       switch (signValues[sign]) {
         case 'negativeInfinity':
-          return -Infinity;
+          return Number.NEGATIVE_INFINITY;
 
         case 'positiveInfinity':
-          return Infinity;
+          return Number.POSITIVE_INFINITY;
 
         case 'bigPositive':
           return pow32(mantissa, exponent);
@@ -2201,7 +2189,7 @@ const types = {
       const encoded = [];
 
       for (const [i, item] of key.entries()) {
-        const encodedItem = encode(item, true); // encode the array item
+        const encodedItem = encode$2(item, true); // encode the array item
 
         encoded[i] = encodedItem;
       }
@@ -2217,7 +2205,7 @@ const types = {
 
       for (let i = 0; i < decoded.length; i++) {
         const item = decoded[i];
-        const decodedItem = decode(item, true); // decode the item
+        const decodedItem = decode$2(item, true); // decode the item
 
         decoded[i] = decodedItem;
       }
@@ -2240,7 +2228,7 @@ const types = {
   binary: {
     // `ArrayBuffer`/Views on buffers (`TypedArray` or `DataView`)
     encode(key) {
-      return keyTypeToEncodedChar.binary + '-' + (key.byteLength ? [...getCopyBytesHeldByBufferSource(key)].map(b => padStart(b, 3, '0')) // e.g., '255,005,254,000,001,033'
+      return keyTypeToEncodedChar.binary + '-' + (key.byteLength ? [...getCopyBytesHeldByBufferSource(key)].map(b => String(b).padStart(3, '0')) // e.g., '255,005,254,000,001,033'
       : '');
     },
 
@@ -2326,13 +2314,12 @@ function pow32(mantissa, exponent) {
 }
 /**
  * @param {Float} num
- * @param {Float} precision
+ * @param {Float} [precision=16]
  * @returns {Float}
  */
 
 
-function roundToPrecision(num, precision) {
-  precision = precision || 16;
+function roundToPrecision(num, precision = 16) {
   return Number.parseFloat(num.toPrecision(precision));
 }
 /**
@@ -2811,9 +2798,9 @@ function checkKeyCouldBeInjectedIntoValue(value, keyPath) {
 function isKeyInRange(key, range, checkCached) {
   let lowerMatch = range.lower === undefined;
   let upperMatch = range.upper === undefined;
-  const encodedKey = encode(key, true);
-  const lower = checkCached ? range.__lowerCached : encode(range.lower, true);
-  const upper = checkCached ? range.__upperCached : encode(range.upper, true);
+  const encodedKey = encode$2(key, true);
+  const lower = checkCached ? range.__lowerCached : encode$2(range.lower, true);
+  const upper = checkCached ? range.__upperCached : encode$2(range.upper, true);
 
   if (range.lower !== undefined) {
     if (range.lowerOpen && encodedKey > lower) {
@@ -2963,7 +2950,7 @@ function convertKeyToValue(key) {
  */
 
 
-function encode(key, inArray) {
+function encode$2(key, inArray) {
   // Bad keys like `null`, `object`, `boolean`, 'function', 'symbol' should not be passed here due to prior validation
   if (key === undefined) {
     return null;
@@ -2981,7 +2968,7 @@ function encode(key, inArray) {
  */
 
 
-function decode(key, inArray) {
+function decode$2(key, inArray) {
   if (typeof key !== 'string') {
     return undefined;
   }
@@ -2997,7 +2984,7 @@ function decode(key, inArray) {
 
 
 function roundTrip(key, inArray) {
-  return decode(encode(key, inArray), inArray);
+  return decode$2(encode$2(key, inArray), inArray);
 }
 
 const MAX_ALLOWED_CURRENT_NUMBER = 9007199254740992; // 2 ^ 53 (Also equal to `Number.MAX_SAFE_INTEGER + 1`)
@@ -3104,7 +3091,7 @@ function generateKeyForStore(tx, store, cb, sqlFailCb) {
   getCurrentNumber(tx, store, function (key) {
     if (key > MAX_ALLOWED_CURRENT_NUMBER) {
       // 2 ^ 53 (See <https://github.com/w3c/IndexedDB/issues/147>)
-      cb('failure'); // eslint-disable-line standard/no-callback-literal
+      cb('failure'); // eslint-disable-line node/no-callback-literal
 
       return;
     } // Increment current number by 1 (we cannot leverage SQLite's
@@ -3163,8 +3150,8 @@ function possiblyUpdateKeyGenerator(tx, store, key, successCb, sqlFailCb) {
 
 var Key = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  encode: encode,
-  decode: decode,
+  encode: encode$2,
+  decode: decode$2,
   roundTrip: roundTrip,
   convertKeyToValue: convertKeyToValue,
   convertValueToKeyValueDecoded: convertValueToKeyValueDecoded,
@@ -3185,7 +3172,7 @@ var Key = /*#__PURE__*/Object.freeze({
   possiblyUpdateKeyGenerator: possiblyUpdateKeyGenerator
 });
 
-const readonlyProperties$2 = ['lower', 'upper', 'lowerOpen', 'upperOpen'];
+const readonlyProperties$4 = ['lower', 'upper', 'lowerOpen', 'upperOpen'];
 /* eslint-disable jsdoc/check-param-names */
 
 /**
@@ -3229,7 +3216,7 @@ IDBKeyRange.__createInstance = function (lower, upper, lowerOpen, upperOpen) {
     }
 
     if (lower !== undefined && upper !== undefined && lower !== upper) {
-      if (encode(lower) > encode(upper)) {
+      if (encode$2(lower) > encode$2(upper)) {
         throw createDOMException('DataError', '`lower` must not be greater than `upper` argument in `bound()` call.');
       }
     }
@@ -3300,7 +3287,7 @@ IDBKeyRange.bound = function (lower, upper
 };
 
 IDBKeyRange.prototype[Symbol.toStringTag] = 'IDBKeyRangePrototype';
-readonlyProperties$2.forEach(prop => {
+readonlyProperties$4.forEach(prop => {
   Object.defineProperty(IDBKeyRange.prototype, '__' + prop, {
     enumerable: false,
     configurable: false,
@@ -3338,11 +3325,11 @@ function setSQLForKeyRange(range, quotedKeyColumnName, sql, sqlValues, addAnd, c
     const hasUpper = range.upper !== undefined;
 
     if (hasLower) {
-      encodedLowerKey = checkCached ? range.__lowerCached : encode(range.lower);
+      encodedLowerKey = checkCached ? range.__lowerCached : encode$2(range.lower);
     }
 
     if (hasUpper) {
-      encodedUpperKey = checkCached ? range.__upperCached : encode(range.upper);
+      encodedUpperKey = checkCached ? range.__upperCached : encode$2(range.upper);
     }
 
     if (hasLower) {
@@ -3465,12 +3452,12 @@ DOMStringList.prototype = {
   },
 
   forEach(cb, thisArg) {
-    // eslint-disable-next-line unicorn/no-fn-reference-in-iterator
+    // eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument
     this._items.forEach(cb, thisArg);
   },
 
   map(cb, thisArg) {
-    // eslint-disable-next-line unicorn/no-fn-reference-in-iterator
+    // eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument
     return this._items.map(cb, thisArg);
   },
 
@@ -3519,7 +3506,7 @@ DOMStringList.prototype = {
 };
 Object.defineProperty(DOMStringList, Symbol.hasInstance, {
   value(obj) {
-    return {}.toString.call(obj) === 'DOMStringListPrototype';
+    return Object.prototype.toString.call(obj) === 'DOMStringListPrototype';
   }
 
 });
@@ -4021,8 +4008,8 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
       // Store was already created so we restore to name before the rename
       if ('__pendingName' in store && me.db.__oldObjectStoreNames.indexOf(store.__pendingName) > -1 // eslint-disable-line unicorn/prefer-includes
       ) {
-          store.__name = store.__originalName;
-        }
+        store.__name = store.__originalName;
+      }
 
       store.__indexNames = store.__oldIndexNames;
       delete store.__pendingDelete;
@@ -4030,8 +4017,8 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         // Index was already created so we restore to name before the rename
         if ('__pendingName' in index && store.__oldIndexNames.indexOf(index.__pendingName) > -1 // eslint-disable-line unicorn/prefer-includes
         ) {
-            index.__name = index.__originalName;
-          }
+          index.__name = index.__originalName;
+        }
 
         delete index.__pendingDelete;
       });
@@ -4211,54 +4198,20 @@ Object.defineProperty(IDBTransaction, 'prototype', {
   writable: false
 });
 
-function _typeof$1(obj) {
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
   if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof$1 = function (obj) {
+    _typeof = function (obj) {
       return typeof obj;
     };
   } else {
-    _typeof$1 = function (obj) {
+    _typeof = function (obj) {
       return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
     };
   }
 
-  return _typeof$1(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 self = this,
-        args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-
-      _next(undefined);
-    });
-  };
+  return _typeof(obj);
 }
 
 function _classCallCheck(instance, Constructor) {
@@ -4283,7 +4236,7 @@ function _createClass(Constructor, protoProps, staticProps) {
   return Constructor;
 }
 
-function _defineProperty$1(obj, key, value) {
+function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -4298,7 +4251,7 @@ function _defineProperty$1(obj, key, value) {
   return obj;
 }
 
-function ownKeys$1(object, enumerableOnly) {
+function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
 
   if (Object.getOwnPropertySymbols) {
@@ -4312,18 +4265,18 @@ function ownKeys$1(object, enumerableOnly) {
   return keys;
 }
 
-function _objectSpread2$1(target) {
+function _objectSpread2(target) {
   for (var i = 1; i < arguments.length; i++) {
     var source = arguments[i] != null ? arguments[i] : {};
 
     if (i % 2) {
-      ownKeys$1(Object(source), true).forEach(function (key) {
-        _defineProperty$1(target, key, source[key]);
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
       });
     } else if (Object.getOwnPropertyDescriptors) {
       Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
     } else {
-      ownKeys$1(Object(source)).forEach(function (key) {
+      ownKeys(Object(source)).forEach(function (key) {
         Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
       });
     }
@@ -4333,19 +4286,15 @@ function _objectSpread2$1(target) {
 }
 
 function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
 
 function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(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;
-  }
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
 }
 
 function _arrayWithHoles(arr) {
@@ -4353,14 +4302,11 @@ function _arrayWithHoles(arr) {
 }
 
 function _iterableToArray(iter) {
-  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
 }
 
 function _iterableToArrayLimit(arr, i) {
-  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
-    return;
-  }
-
+  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
   var _arr = [];
   var _n = true;
   var _d = false;
@@ -4386,30 +4332,82 @@ function _iterableToArrayLimit(arr, i) {
   return _arr;
 }
 
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
 function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance");
+  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 _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+/**
+* @callback TypesonFulfilled
+* @returns {Promise<any>|any}
+*/
+
+/**
+* @callback TypesonRejected
+* @returns {Promise<any>|any}
+*/
+
+/**
+ * @callback TypesonResolve
+ * @param {any} value
+ * @returns {Promise<any>}
+ */
+
+/**
+ * @callback TypesonReject
+ * @param {Error|any} error
+ * @returns {Promise<any>}
+ */
+
+/**
+ * @callback TypesonResolveReject
+ * @param {TypesonResolve} typesonResolve
+ * @param {TypesonReject} typesonReject
+ * @returns {Promise<any>}
+ */
+
+/* eslint-disable block-spacing, space-before-function-paren,
+  space-before-blocks, space-infix-ops, semi, promise/avoid-new,
+  jsdoc/require-jsdoc */
+
 /**
  * We keep this function minimized so if using two instances of this
  *   library, where one is minimized and one is not, it will still work
  *   with `hasConstructorOf`.
  * With ES6 classes, we may be able to simply use `class TypesonPromise
  *   extends Promise` and add a string tag for detection.
- * @param {function} f
+ * @param {TypesonResolveReject} f
  */
-// eslint-disable-next-line max-len
-// eslint-disable-next-line block-spacing, space-before-function-paren, space-before-blocks, space-infix-ops, semi, promise/avoid-new
 
 
 var TypesonPromise = function TypesonPromise(f) {
   _classCallCheck(this, TypesonPromise);
 
   this.p = new Promise(f);
-}; // eslint-disable-next-line max-len
+};
+/* eslint-enable block-spacing, space-before-function-paren,
+  space-before-blocks, space-infix-ops, semi, promise/avoid-new,
+  jsdoc/require-jsdoc */
+// eslint-disable-next-line max-len
 // class TypesonPromise extends Promise {get[Symbol.toStringTag](){return 'TypesonPromise'};} // eslint-disable-line keyword-spacing, space-before-function-paren, space-before-blocks, block-spacing, semi
 
 
@@ -4423,8 +4421,8 @@ if (typeof Symbol !== 'undefined') {
 }
 /**
  *
- * @param {function} [onFulfilled]
- * @param {function} [onRejected]
+ * @param {TypesonFulfilled} [onFulfilled]
+ * @param {TypesonRejected} [onRejected]
  * @returns {TypesonPromise}
  */
 
@@ -4444,7 +4442,7 @@ TypesonPromise.prototype.then = function (onFulfilled, onRejected) {
 };
 /**
  *
- * @param {function} onRejected
+ * @param {TypesonRejected} onRejected
  * @returns {TypesonPromise}
  */
 
@@ -4454,7 +4452,7 @@ TypesonPromise.prototype["catch"] = function (onRejected) {
 };
 /**
  *
- * @param {Any} v
+ * @param {any} v
  * @returns {TypesonPromise}
  */
 
@@ -4466,7 +4464,7 @@ TypesonPromise.resolve = function (v) {
 };
 /**
  *
- * @param {Any} v
+ * @param {any} v
  * @returns {TypesonPromise}
  */
 
@@ -4477,10 +4475,10 @@ TypesonPromise.reject = function (v) {
   });
 };
 
-['all', 'race'].forEach(function (meth) {
+['all', 'race', 'allSettled'].forEach(function (meth) {
   /**
    *
-   * @param {Promise[]} promArr
+   * @param {Promise<any>[]} promArr
    * @returns {TypesonPromise}
    */
   TypesonPromise[meth] = function (promArr) {
@@ -4499,7 +4497,7 @@ var _ref = {},
     fnToString = hasOwn$1.toString;
 /**
  * Second argument not in use internally, but provided for utility.
- * @param {Any} v
+ * @param {any} v
  * @param {boolean} catchCheck
  * @returns {boolean}
  */
@@ -4509,7 +4507,7 @@ function isThenable(v, catchCheck) {
 }
 /**
  *
- * @param {Any} val
+ * @param {any} val
  * @returns {string}
  */
 
@@ -4520,14 +4518,14 @@ function toStringTag(val) {
 /**
  * This function is dependent on both constructors
  *   being identical so any minimization is expected of both.
- * @param {Any} a
- * @param {function} b
+ * @param {any} a
+ * @param {GenericFunction} b
  * @returns {boolean}
  */
 
 
 function hasConstructorOf(a, b) {
-  if (!a || _typeof$1(a) !== 'object') {
+  if (!a || _typeof(a) !== 'object') {
     return false;
   }
 
@@ -4559,7 +4557,7 @@ function hasConstructorOf(a, b) {
 }
 /**
  *
- * @param {Any} val
+ * @param {any} val
  * @returns {boolean}
  */
 
@@ -4581,7 +4579,7 @@ function isPlainObject(val) {
 }
 /**
  *
- * @param {Any} val
+ * @param {any} val
  * @returns {boolean}
  */
 
@@ -4602,13 +4600,13 @@ function isUserObject(val) {
 }
 /**
  *
- * @param {Any} v
+ * @param {any} v
  * @returns {boolean}
  */
 
 
 function isObject(v) {
-  return v && _typeof$1(v) === 'object';
+  return v && _typeof(v) === 'object';
 }
 /**
  *
@@ -4633,7 +4631,7 @@ function unescapeKeyPathComponent(keyPathComponent) {
 /**
  * @param {PlainObject|GenericArray} obj
  * @param {string} keyPath
- * @returns {Any}
+ * @returns {any}
  */
 
 
@@ -4655,8 +4653,8 @@ function getByKeyPath(obj, keyPath) {
  *
  * @param {PlainObject} obj
  * @param {string} keyPath
- * @param {Any} value
- * @returns {Any}
+ * @param {any} value
+ * @returns {any}
  */
 
 
@@ -4684,12 +4682,24 @@ function setAtKeyPath(obj, keyPath, value) {
 
 
 function getJSONType(value) {
-  return value === null ? 'null' : Array.isArray(value) ? 'array' : _typeof$1(value);
+  return value === null ? 'null' : Array.isArray(value) ? 'array' : _typeof(value);
+}
+
+function _await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+
+  return then ? value.then(then) : value;
 }
 
 var keys = Object.keys,
     isArray = Array.isArray,
-    hasOwn$1$1 = {}.hasOwnProperty,
+    hasOwn = {}.hasOwnProperty,
     internalStateObjPropsToIgnore = ['type', 'replaced', 'iterateIn', 'iterateUnsetNumeric'];
 /**
  * Handle plain object revivers first so reference setting can use
@@ -4700,6 +4710,66 @@ var keys = Object.keys,
  * @returns {1|-1|boolean}
  */
 
+function _async(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+/**
+ * @callback Tester
+ * @param {any} value
+ * @param {StateObject} stateobj
+ * @returns {boolean}
+ */
+
+/**
+* @callback Replacer
+* @param {any} value
+* @param {StateObject} stateObj
+* @returns {any} Should be JSON-stringifiable
+*/
+
+/**
+* @callback Reviver
+* @param {JSON} value
+* @param {StateObject} stateObj
+* @returns {any}
+*/
+
+/**
+* @typedef {PlainObject} TypesonOptions
+* @property {boolean} stringification Auto-set by `stringify`
+*/
+
+/**
+ * An instance of this class can be used to call `stringify()` and `parse()`.
+ * Typeson resolves cyclic references by default. Can also be extended to
+ * support custom types using the register() method.
+ *
+ * @class
+ * @param {{cyclic: boolean}} [options] - if cyclic (default true),
+ *   cyclic references will be handled gracefully.
+ */
+
+
+function _invoke(body, then) {
+  var result = body();
+
+  if (result && result.then) {
+    return result.then(then);
+  }
+
+  return then(result);
+}
+
 function nestedPathsFirst(a, b) {
   if (a.keypath === '') {
     return -1;
@@ -4718,18 +4788,11 @@ function nestedPathsFirst(a, b) {
 
   return as > bs ? -1 : as < bs ? 1 : a.keypath < b.keypath ? -1 : a.keypath > b.keypath;
 }
-/**
- * An instance of this class can be used to call `stringify()` and `parse()`.
- * Typeson resolves cyclic references by default. Can also be extended to
- * support custom types using the register() method.
- *
- * @class
- * @param {{cyclic: boolean}} [options] - if cyclic (default true),
- *   cyclic references will be handled gracefully.
- */
-
 
 var Typeson = /*#__PURE__*/function () {
+  /**
+   * @param {TypesonOptions} options
+   */
   function Typeson(options) {
     _classCallCheck(this, Typeson);
 
@@ -4761,18 +4824,18 @@ var Typeson = /*#__PURE__*/function () {
    * Serialize given object to Typeson.
    * Initial arguments work identical to those of `JSON.stringify`.
    * The `replacer` argument has nothing to do with our replacers.
-   * @param {Any} obj
+   * @param {any} obj
    * @param {JSONReplacer|string[]} replacer
    * @param {number|string} space
-   * @param {object} opts
-   * @returns {string|Promise} Promise resolves to a string
+   * @param {TypesonOptions} opts
+   * @returns {string|Promise<string>} Promise resolves to a string
    */
 
 
   _createClass(Typeson, [{
     key: "stringify",
     value: function stringify(obj, replacer, space, opts) {
-      opts = _objectSpread2$1({}, this.options, {}, opts, {
+      opts = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), opts), {}, {
         stringification: true
       });
       var encapsulated = this.encapsulate(obj, null, opts);
@@ -4787,54 +4850,61 @@ var Typeson = /*#__PURE__*/function () {
     }
     /**
      * Also sync but throws on non-sync result.
-     * @param {Any} obj
+     * @param {any} obj
      * @param {JSONReplacer|string[]} replacer
      * @param {number|string} space
-     * @param {object} opts
+     * @param {TypesonOptions} opts
      * @returns {string}
      */
 
   }, {
     key: "stringifySync",
     value: function stringifySync(obj, replacer, space, opts) {
-      return this.stringify(obj, replacer, space, _objectSpread2$1({
+      return this.stringify(obj, replacer, space, _objectSpread2(_objectSpread2({
         throwOnBadSyncType: true
-      }, opts, {
+      }, opts), {}, {
         sync: true
       }));
     }
     /**
      *
-     * @param {Any} obj
+     * @param {any} obj
      * @param {JSONReplacer|string[]} replacer
      * @param {number|string} space
-     * @param {object} opts
+     * @param {TypesonOptions} opts
      * @returns {Promise<string>}
      */
 
   }, {
     key: "stringifyAsync",
     value: function stringifyAsync(obj, replacer, space, opts) {
-      return this.stringify(obj, replacer, space, _objectSpread2$1({
+      return this.stringify(obj, replacer, space, _objectSpread2(_objectSpread2({
         throwOnBadSyncType: true
-      }, opts, {
+      }, opts), {}, {
         sync: false
       }));
     }
+    /**
+    * @callback JSONReviver
+    * @param {string} key
+    * @param {JSON} value
+    * @returns {JSON}
+    */
+
     /**
      * 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
+     * @param {JSONReviver} reviver This JSON reviver has nothing to do with
      *   our revivers.
-     * @param {object} opts
+     * @param {TypesonOptions} opts
      * @returns {external:JSON}
      */
 
   }, {
     key: "parse",
     value: function parse(text, reviver, opts) {
-      opts = _objectSpread2$1({}, this.options, {}, opts, {
+      opts = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), opts), {}, {
         parse: true
       });
       return this.revive(JSON.parse(text, reviver), opts);
@@ -4842,43 +4912,47 @@ var Typeson = /*#__PURE__*/function () {
     /**
     * Also sync but throws on non-sync result.
     * @param {string} text
-    * @param {function} reviver This JSON reviver has nothing to do with
+    * @param {JSONReviver} reviver This JSON reviver has nothing to do with
     *   our revivers.
-    * @param {object} opts
+    * @param {TypesonOptions} opts
     * @returns {external:JSON}
     */
 
   }, {
     key: "parseSync",
     value: function parseSync(text, reviver, opts) {
-      return this.parse(text, reviver, _objectSpread2$1({
+      return this.parse(text, reviver, _objectSpread2(_objectSpread2({
         throwOnBadSyncType: true
-      }, opts, {
+      }, opts), {}, {
         sync: true
       }));
     }
     /**
     * @param {string} text
-    * @param {function} reviver This JSON reviver has nothing to do with
+    * @param {JSONReviver} reviver This JSON reviver has nothing to do with
     *   our revivers.
-    * @param {object} opts
-    * @returns {Promise} Resolves to `external:JSON`
+    * @param {TypesonOptions} opts
+    * @returns {Promise<external:JSON>} Resolves to `external:JSON`
     */
 
   }, {
     key: "parseAsync",
     value: function parseAsync(text, reviver, opts) {
-      return this.parse(text, reviver, _objectSpread2$1({
+      return this.parse(text, reviver, _objectSpread2(_objectSpread2({
         throwOnBadSyncType: true
-      }, opts, {
+      }, opts), {}, {
         sync: false
       }));
     }
+    /**
+    * @typedef {} StateObject
+    */
+
     /**
      *
-     * @param {Any} obj
-     * @param {object} stateObj
-     * @param {object} [opts={}]
+     * @param {any} obj
+     * @param {StateObject} stateObj
+     * @param {TypesonOptions} [opts={}]
      * @returns {string[]|false}
      */
 
@@ -4891,10 +4965,10 @@ var Typeson = /*#__PURE__*/function () {
     }
     /**
      *
-     * @param {Any} obj
+     * @param {any} obj
      * @param {PlainObject} stateObj
      * @param {PlainObject} [opts={}]
-     * @returns {Promise|GenericArray|PlainObject|string|false}
+     * @returns {Promise<any>|GenericArray|PlainObject|string|false}
      */
 
   }, {
@@ -4909,18 +4983,101 @@ var Typeson = /*#__PURE__*/function () {
      * registered types with plain objects representing the types data.
      *
      * This method is used internally by `Typeson.stringify()`.
-     * @param {Any} obj - Object to encapsulate.
+     * @param {any} obj - Object to encapsulate.
      * @param {PlainObject} stateObj
      * @param {PlainObject} opts
-     * @returns {Promise|GenericArray|PlainObject|string|false}
+     * @returns {Promise<any>|GenericArray|PlainObject|string|false}
      */
 
   }, {
     key: "encapsulate",
     value: function encapsulate(obj, stateObj, opts) {
-      opts = _objectSpread2$1({
+      /**
+       *
+       * @param {any} ret
+       * @param {GenericArray} promisesData
+       * @returns {Promise<any>}
+       */
+      var checkPromises = _async(function (ret, promisesData) {
+        return _await(Promise.all(promisesData.map(function (pd) {
+          return pd[1].p;
+        })), function (promResults) {
+          return _await(Promise.all(promResults.map(_async(function (promResult) {
+            var _exit = false;
+            var newPromisesData = [];
+
+            var _promisesData$splice = promisesData.splice(0, 1),
+                _promisesData$splice2 = _slicedToArray(_promisesData$splice, 1),
+                prData = _promisesData$splice2[0];
+
+            var _prData = _slicedToArray(prData, 7),
+                keyPath = _prData[0],
+                cyclic = _prData[2],
+                stateObj = _prData[3],
+                parentObj = _prData[4],
+                key = _prData[5],
+                detectedType = _prData[6];
+
+            var encaps = _encapsulate(keyPath, promResult, cyclic, stateObj, newPromisesData, true, detectedType);
+
+            var isTypesonPromise = hasConstructorOf(encaps, TypesonPromise); // Handle case where an embedded custom type itself
+            //   returns a `Typeson.Promise`
+
+            return _invoke(function () {
+              if (keyPath && isTypesonPromise) {
+                return _await(encaps.p, function (encaps2) {
+                  parentObj[key] = encaps2;
+                  _exit = true;
+                  return checkPromises(ret, newPromisesData);
+                });
+              }
+            }, function (_result) {
+              if (_exit) return _result;
+
+              if (keyPath) {
+                parentObj[key] = encaps;
+              } else if (isTypesonPromise) {
+                ret = encaps.p;
+              } else {
+                // If this is itself a `Typeson.Promise` (because the
+                //   original value supplied was a `Promise` or
+                //   because the supplied custom type value resolved
+                //   to one), returning it below will be fine since
+                //   a `Promise` is expected anyways given current
+                //   config (and if not a `Promise`, it will be ready
+                //   as the resolve value)
+                ret = encaps;
+              }
+
+              return checkPromises(ret, newPromisesData);
+            });
+          }))), function () {
+            return ret;
+          });
+        });
+      });
+      /**
+      * @typedef {PlainObject} OwnKeysObject
+      * @property {boolean} ownKeys
+      */
+
+      /**
+      * @callback BuiltinStateObjectPropertiesCallback
+      * @returns {void}
+      */
+
+      /**
+       *
+       * @param {StateObject} stateObj
+       * @param {OwnKeysObject} ownKeysObj
+       * @param {BuiltinStateObjectPropertiesCallback} cb
+       * @returns {undefined}
+       */
+
+
+      opts = _objectSpread2(_objectSpread2({
         sync: true
-      }, this.options, {}, opts);
+      }, this.options), opts);
       var _opts = opts,
           sync = _opts.sync;
       var that = this,
@@ -4939,7 +5096,7 @@ var Typeson = /*#__PURE__*/function () {
       var ret = _encapsulate('', obj, cyclic, stateObj || {}, promisesDataRoot);
       /**
        *
-       * @param {Any} ret
+       * @param {any} ret
        * @returns {GenericArray|PlainObject|string|false}
        */
 
@@ -4966,7 +5123,7 @@ var Typeson = /*#__PURE__*/function () {
 
           if (!ret || !isPlainObject(ret) || // Also need to handle if this is an object with its
           //   own `$types` property (to avoid ambiguity)
-          hasOwn$1$1.call(ret, '$types')) {
+          hasOwn.call(ret, '$types')) {
             ret = {
               $: ret,
               $types: {
@@ -4977,7 +5134,7 @@ var Typeson = /*#__PURE__*/function () {
             ret.$types = types;
           } // No special types
 
-        } else if (isObject(ret) && hasOwn$1$1.call(ret, '$types')) {
+        } else if (isObject(ret) && hasOwn.call(ret, '$types')) {
           ret = {
             $: ret,
             $types: true
@@ -4990,112 +5147,6 @@ var Typeson = /*#__PURE__*/function () {
 
         return ret;
       }
-      /**
-       *
-       * @param {Any} ret
-       * @param {GenericArray} promisesData
-       * @returns {Promise<Any>}
-       */
-
-
-      function checkPromises(_x, _x2) {
-        return _checkPromises.apply(this, arguments);
-      }
-      /**
-       *
-       * @param {object} stateObj
-       * @param {object} ownKeysObj
-       * @param {function} cb
-       * @returns {undefined}
-       */
-
-
-      function _checkPromises() {
-        _checkPromises = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(ret, 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 _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(promResult) {
-                      var newPromisesData, _promisesData$splice, _promisesData$splice2, prData, _prData, keyPath, cyclic, stateObj, 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], cyclic = _prData[2], stateObj = _prData[3], parentObj = _prData[4], key = _prData[5], detectedType = _prData[6];
-                              encaps = _encapsulate(keyPath, promResult, cyclic, stateObj, newPromisesData, true, detectedType);
-                              isTypesonPromise = hasConstructorOf(encaps, TypesonPromise); // Handle case where an embedded custom type itself
-                              //   returns a `Typeson.Promise`
-
-                              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(ret, newPromisesData));
-
-                            case 11:
-                              if (keyPath) {
-                                parentObj[key] = encaps;
-                              } else if (isTypesonPromise) {
-                                ret = encaps.p;
-                              } else {
-                                // If this is itself a `Typeson.Promise` (because the
-                                //   original value supplied was a `Promise` or
-                                //   because the supplied custom type value resolved
-                                //   to one), returning it below will be fine since
-                                //   a `Promise` is expected anyways given current
-                                //   config (and if not a `Promise`, it will be ready
-                                //   as the resolve value)
-                                ret = encaps;
-                              }
-
-                              return _context.abrupt("return", checkPromises(ret, newPromisesData));
-
-                            case 13:
-                            case "end":
-                              return _context.stop();
-                          }
-                        }
-                      }, _callee);
-                    }));
-
-                    return function (_x3) {
-                      return _ref.apply(this, arguments);
-                    };
-                  }()));
-
-                case 5:
-                  return _context2.abrupt("return", ret);
-
-                case 6:
-                case "end":
-                  return _context2.stop();
-              }
-            }
-          }, _callee2);
-        }));
-        return _checkPromises.apply(this, arguments);
-      }
 
       function _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, cb) {
         Object.assign(stateObj, ownKeysObj);
@@ -5103,7 +5154,7 @@ var Typeson = /*#__PURE__*/function () {
           var tmp = stateObj[prop];
           delete stateObj[prop];
           return tmp;
-        }); // eslint-disable-next-line callback-return
+        }); // eslint-disable-next-line node/callback-return
 
         cb();
         internalStateObjPropsToIgnore.forEach(function (prop, i) {
@@ -5113,13 +5164,13 @@ var Typeson = /*#__PURE__*/function () {
       /**
        *
        * @param {string} keypath
-       * @param {Any} value
+       * @param {any} value
        * @param {boolean} cyclic
        * @param {PlainObject} stateObj
        * @param {boolean} promisesData
        * @param {boolean} resolvingTypesonPromise
        * @param {string} detectedType
-       * @returns {Any}
+       * @returns {any}
        */
 
 
@@ -5127,7 +5178,7 @@ var Typeson = /*#__PURE__*/function () {
         var ret;
         var observerData = {};
 
-        var $typeof = _typeof$1(value);
+        var $typeof = _typeof(value);
 
         var runObserver = encapsulateObserver ? function (obj) {
           var type = detectedType || stateObj.type || Typeson.getJSONType(value);
@@ -5145,12 +5196,8 @@ var Typeson = /*#__PURE__*/function () {
         } : null;
 
         if (['string', 'boolean', 'number', 'undefined'].includes($typeof)) {
-          if (value === undefined || $typeof === 'number' && (isNaN(value) || value === -Infinity || value === Infinity)) {
-            if (stateObj.replaced) {
-              ret = value;
-            } else {
-              ret = replace(keypath, value, stateObj, promisesData, false, resolvingTypesonPromise, runObserver);
-            }
+          if (value === undefined || Number.isNaN(value) || value === Number.NEGATIVE_INFINITY || value === Number.POSITIVE_INFINITY) {
+            ret = stateObj.replaced ? value : replace(keypath, value, stateObj, promisesData, false, resolvingTypesonPromise, runObserver);
 
             if (ret !== value) {
               observerData = {
@@ -5176,7 +5223,7 @@ var Typeson = /*#__PURE__*/function () {
           return value;
         }
 
-        if (cyclic && !stateObj.iterateIn && !stateObj.iterateUnsetNumeric && value && _typeof$1(value) === 'object') {
+        if (cyclic && !stateObj.iterateIn && !stateObj.iterateUnsetNumeric && value && _typeof(value) === 'object') {
           // Options set to detect cyclic references and be able
           //   to rewrite them.
           var refIndex = refObjs.indexOf(value);
@@ -5219,11 +5266,12 @@ var Typeson = /*#__PURE__*/function () {
             promisesData.push([keypath, value, cyclic, stateObj, undefined, undefined, stateObj.type]);
             ret = value;
           } else if (isArr && stateObj.iterateIn !== 'object' || stateObj.iterateIn === 'array') {
+            // eslint-disable-next-line unicorn/no-new-array -- Sparse
             clone = new Array(value.length);
             observerData = {
               clone: clone
             };
-          } else if (!['function', 'symbol'].includes(_typeof$1(value)) && !('toJSON' in value) && !hasConstructorOf(value, TypesonPromise) && !hasConstructorOf(value, Promise) && !hasConstructorOf(value, ArrayBuffer) || isPlainObj || stateObj.iterateIn === 'object') {
+          } else if (!['function', 'symbol'].includes(_typeof(value)) && !('toJSON' in value) && !hasConstructorOf(value, TypesonPromise) && !hasConstructorOf(value, Promise) && !hasConstructorOf(value, ArrayBuffer) || isPlainObj || stateObj.iterateIn === 'object') {
             clone = {};
 
             if (stateObj.addLength) {
@@ -5254,7 +5302,7 @@ var Typeson = /*#__PURE__*/function () {
         if (stateObj.iterateIn) {
           var _loop = function _loop(key) {
             var ownKeysObj = {
-              ownKeys: hasOwn$1$1.call(value, key)
+              ownKeys: hasOwn.call(value, key)
             };
 
             _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, function () {
@@ -5351,16 +5399,50 @@ var Typeson = /*#__PURE__*/function () {
 
         return clone;
       }
+      /**
+      * @typedef {PlainObject} KeyPathEvent
+      * @property {string} cyclicKeypath
+      */
+
+      /**
+      * @typedef {PlainObject} EndIterateInEvent
+      * @property {boolean} endIterateIn
+      * @property {boolean} end
+      */
+
+      /**
+      * @typedef {PlainObject} EndIterateUnsetNumericEvent
+      * @property {boolean} endIterateUnsetNumeric
+      * @property {boolean} end
+      */
+
+      /**
+      * @typedef {PlainObject} TypeDetectedEvent
+      * @property {boolean} typeDetected
+      */
+
+      /**
+      * @typedef {PlainObject} ReplacingEvent
+      * @property {boolean} replacing
+      */
+
+      /**
+      * @callback Observer
+      * @param {KeyPathEvent|EndIterateInEvent|EndIterateUnsetNumericEvent|
+      * TypeDetectedEvent|ReplacingEvent} [event]
+      * @returns {void}
+      */
+
       /**
        *
        * @param {string} keypath
-       * @param {Any} value
+       * @param {any} value
        * @param {PlainObject} stateObj
        * @param {GenericArray} promisesData
        * @param {boolean} plainObject
        * @param {boolean} resolvingTypesonPromise
-       * @param {function} [runObserver]
-       * @returns {*}
+       * @param {Observer} [runObserver]
+       * @returns {any}
        */
 
 
@@ -5431,46 +5513,47 @@ var Typeson = /*#__PURE__*/function () {
     }
     /**
      * Also sync but throws on non-sync result.
-     * @param {*} obj
-     * @param {object} stateObj
-     * @param {object} opts
-     * @returns {*}
+     * @param {any} obj
+     * @param {StateObject} stateObj
+     * @param {TypesonOptions} opts
+     * @returns {any}
      */
 
   }, {
     key: "encapsulateSync",
     value: function encapsulateSync(obj, stateObj, opts) {
-      return this.encapsulate(obj, stateObj, _objectSpread2$1({
+      return this.encapsulate(obj, stateObj, _objectSpread2(_objectSpread2({
         throwOnBadSyncType: true
-      }, opts, {
+      }, opts), {}, {
         sync: true
       }));
     }
     /**
-     * @param {*} obj
-     * @param {object} stateObj
-     * @param {object} opts
-     * @returns {*}
+     * @param {any} obj
+     * @param {StateObject} stateObj
+     * @param {TypesonOptions} opts
+     * @returns {any}
      */
 
   }, {
     key: "encapsulateAsync",
     value: function encapsulateAsync(obj, stateObj, opts) {
-      return this.encapsulate(obj, stateObj, _objectSpread2$1({
+      return this.encapsulate(obj, stateObj, _objectSpread2(_objectSpread2({
         throwOnBadSyncType: true
-      }, opts, {
+      }, 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
+     * @param {PlainObject} 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 {TypesonOptions} opts
      * @throws TypeError If mismatch between sync/async type and result
-     * @returns {Promise|*} If async, returns a Promise that resolves to `*`
+     * @returns {Promise<any>|any} If async, returns a Promise that resolves
+     * to `any`.
      */
 
   }, {
@@ -5488,9 +5571,9 @@ var Typeson = /*#__PURE__*/function () {
         return obj.$;
       }
 
-      opts = _objectSpread2$1({
+      opts = _objectSpread2(_objectSpread2({
         sync: true
-      }, this.options, {}, opts);
+      }, this.options), opts);
       var _opts3 = opts,
           sync = _opts3.sync;
       var keyPathResolutions = [];
@@ -5508,22 +5591,23 @@ var Typeson = /*#__PURE__*/function () {
       var that = this;
       /**
        * @callback RevivalReducer
-       * @param {Any} value
+       * @param {any} value
        * @param {string} type
-       * @returns {Any}
+       * @returns {any}
        */
 
       /**
        *
        * @param {string} type
-       * @param {Any} val
-       * @returns {[type]} [description]
+       * @param {any} val
+       * @throws {Error}
+       * @returns {any}
        */
 
       function executeReviver(type, val) {
-        var _ref2 = that.revivers[type] || [],
-            _ref3 = _slicedToArray(_ref2, 1),
-            reviver = _ref3[0];
+        var _ref = that.revivers[type] || [],
+            _ref2 = _slicedToArray(_ref, 1),
+            reviver = _ref2[0];
 
         if (!reviver) {
           throw new Error('Unregistered type: ' + type);
@@ -5550,10 +5634,10 @@ var Typeson = /*#__PURE__*/function () {
         // const references = [];
         // const reviveTypes = [];
         var plainObjectTypes = [];
-        Object.entries(types).forEach(function (_ref4) {
-          var _ref5 = _slicedToArray(_ref4, 2),
-              keypath = _ref5[0],
-              type = _ref5[1];
+        Object.entries(types).forEach(function (_ref3) {
+          var _ref4 = _slicedToArray(_ref3, 2),
+              keypath = _ref4[0],
+              type = _ref4[1];
 
           if (type === '#') {
             /*
@@ -5566,9 +5650,9 @@ var Typeson = /*#__PURE__*/function () {
           }
 
           [].concat(type).forEach(function (type) {
-            var _ref6 = that.revivers[type] || [null, {}],
-                _ref7 = _slicedToArray(_ref6, 2),
-                plain = _ref7[1].plain;
+            var _ref5 = that.revivers[type] || [null, {}],
+                _ref6 = _slicedToArray(_ref5, 2),
+                plain = _ref6[1].plain;
 
             if (!plain) {
               // reviveTypes.push({keypath, type});
@@ -5594,9 +5678,9 @@ var Typeson = /*#__PURE__*/function () {
         */
 
 
-        return plainObjectTypes.sort(nestedPathsFirst).reduce(function reducer(possibleTypesonPromise, _ref8) {
-          var keypath = _ref8.keypath,
-              type = _ref8.type;
+        return plainObjectTypes.sort(nestedPathsFirst).reduce(function reducer(possibleTypesonPromise, _ref7) {
+          var keypath = _ref7.keypath,
+              type = _ref7.type;
 
           if (isThenable(possibleTypesonPromise)) {
             return possibleTypesonPromise.then(function (val) {
@@ -5639,11 +5723,11 @@ var Typeson = /*#__PURE__*/function () {
       /**
        *
        * @param {string} keypath
-       * @param {Any} value
-       * @param {?(Array|object)} target
-       * @param {Array|object} [clone]
+       * @param {any} value
+       * @param {?(GenericArray|PlainObject)} target
+       * @param {GenericArray|PlainObject} [clone]
        * @param {string} [key]
-       * @returns {Any}
+       * @returns {any}
        */
 
       function _revive(keypath, value, target, clone, key) {
@@ -5655,6 +5739,7 @@ var Typeson = /*#__PURE__*/function () {
         var isArr = isArray(value);
 
         if (isArr || isPlainObject(value)) {
+          // eslint-disable-next-line unicorn/no-new-array -- Sparse
           var _clone = isArr ? new Array(value.length) : {}; // Iterate object or array
 
 
@@ -5730,8 +5815,8 @@ var Typeson = /*#__PURE__*/function () {
       }
       /**
        *
-       * @param {Any} retrn
-       * @returns {undefined|Any}
+       * @param {any} retrn
+       * @returns {undefined|any}
        */
 
 
@@ -5754,9 +5839,9 @@ var Typeson = /*#__PURE__*/function () {
           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];
+          }).then(function (_ref8) {
+            var _ref9 = _slicedToArray(_ref8, 1),
+                r = _ref9[0];
 
             return r;
           });
@@ -5771,42 +5856,46 @@ var Typeson = /*#__PURE__*/function () {
     }
     /**
      * Also sync but throws on non-sync result.
-     * @param {Any} obj
-     * @param {object} opts
-     * @returns {Any}
+     * @param {any} obj
+     * @param {TypesonOptions} opts
+     * @returns {any}
      */
 
   }, {
     key: "reviveSync",
     value: function reviveSync(obj, opts) {
-      return this.revive(obj, _objectSpread2$1({
+      return this.revive(obj, _objectSpread2(_objectSpread2({
         throwOnBadSyncType: true
-      }, opts, {
+      }, opts), {}, {
         sync: true
       }));
     }
     /**
-    * @param {Any} obj
-    * @param {object} opts
-    * @returns {Promise} Resolves to `*`
+    * @param {any} obj
+    * @param {TypesonOptions} opts
+    * @returns {Promise<any>}
     */
 
   }, {
     key: "reviveAsync",
     value: function reviveAsync(obj, opts) {
-      return this.revive(obj, _objectSpread2$1({
+      return this.revive(obj, _objectSpread2(_objectSpread2({
         throwOnBadSyncType: true
-      }, opts, {
+      }, opts), {}, {
         sync: false
       }));
     }
+    /**
+    * @typedef {Tester|Replacer|Reviver} Spec
+    */
+
     /**
      * 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
+     * @param {object<string,Spec[]>[]} typeSpecSets -
+     * Types and their functions [test, encapsulate, revive];
+     * @param {TypesonOptions} opts
      * @returns {Typeson}
      */
 
@@ -5852,7 +5941,7 @@ var Typeson = /*#__PURE__*/function () {
                 return x && x.constructor === Class;
               },
               replace: function replace(x) {
-                return _objectSpread2$1({}, x);
+                return _objectSpread2({}, x);
               },
               revive: function revive(x) {
                 return Object.assign(Object.create(Class.prototype), x);
@@ -5889,7 +5978,7 @@ var Typeson = /*#__PURE__*/function () {
             replacerObj.replaceAsync = spec.replaceAsync.bind(spec);
           }
 
-          var start = typeof opts.fallback === 'number' ? opts.fallback : opts.fallback ? 0 : Infinity;
+          var start = typeof opts.fallback === 'number' ? opts.fallback : opts.fallback ? 0 : Number.POSITIVE_INFINITY;
 
           if (spec.testPlainObjects) {
             this.plainObjectReplacers.splice(start, 0, replacerObj);
@@ -5956,8 +6045,6 @@ Typeson.getByKeyPath = getByKeyPath;
 Typeson.getJSONType = getJSONType;
 Typeson.JSON_TYPES = ['null', 'boolean', 'number', 'string', 'array', 'object'];
 
-/* eslint-disable node/no-unsupported-features/es-syntax */
-
 /*
  * base64-arraybuffer
  * https://github.com/niklasvh/base64-arraybuffer
@@ -6197,9 +6284,7 @@ const blob = {
     replace(b) {
       // Sync
       const req = new XMLHttpRequest();
-      req.overrideMimeType('text/plain; charset=x-user-defined'); // eslint-disable-next-line max-len
-      // eslint-disable-next-line node/no-unsupported-features/node-builtins
-
+      req.overrideMimeType('text/plain; charset=x-user-defined');
       req.open('GET', URL.createObjectURL(b), false); // Sync
 
       req.send(); // Seems not feasible to accurately simulate
@@ -6267,11 +6352,12 @@ function generateUUID() {
   //  Adapted from original: public domain/MIT: http://stackoverflow.com/a/8809472/271577
 
   /* istanbul ignore next */
-  let d = new Date().getTime() + ( // use high-precision timer if available
+  let d = Date.now() + ( // use high-precision timer if available
+  // istanbul ignore next
   typeof performance !== 'undefined' && typeof performance.now === 'function' ? performance.now() : 0);
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/gu, function (c) {
     /* eslint-disable no-bitwise */
-    const r = (d + Math.random() * 16) % 16 | 0;
+    const r = Math.trunc((d + Math.random() * 16) % 16);
     d = Math.floor(d / 16);
     return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
     /* eslint-enable no-bitwise */
@@ -6305,6 +6391,47 @@ const cloneable = {
   }
 };
 
+/* globals crypto */
+const cryptokey = {
+  cryptokey: {
+    test(x) {
+      return Typeson.toStringTag(x) === 'CryptoKey' && x.extractable;
+    },
+
+    replaceAsync(key) {
+      return new Typeson.Promise((resolve, reject) => {
+        // eslint-disable-next-line promise/catch-or-return
+        crypto.subtle.exportKey('jwk', key).catch(
+        /* eslint-disable promise/prefer-await-to-callbacks */
+        // istanbul ignore next
+        err => {
+          /* eslint-enable promise/prefer-await-to-callbacks */
+          // eslint-disable-next-line max-len
+          // istanbul ignore next -- Our format should be valid and our key extractable
+          reject(err);
+        } // eslint-disable-next-line max-len
+        // eslint-disable-next-line promise/always-return, promise/prefer-await-to-then
+        ).then(jwk => {
+          resolve({
+            jwk,
+            algorithm: key.algorithm,
+            usages: key.usages
+          });
+        });
+      });
+    },
+
+    revive({
+      jwk,
+      algorithm,
+      usages
+    }) {
+      return crypto.subtle.importKey('jwk', jwk, algorithm, true, usages);
+    }
+
+  }
+};
+
 const dataview = {
   dataview: {
     test(x) {
@@ -6422,13 +6549,13 @@ const error = {
 /* eslint-env browser, node */
 /* istanbul ignore next */
 
-const _global = typeof self === 'undefined' ? global : self;
+const _global$2 = typeof self === 'undefined' ? global : self;
 
 const errors = {}; // Comprises all built-in errors.
 
 ['TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'EvalError', 'URIError', 'InternalError' // non-standard
 ].forEach(errName => {
-  const Cnstrctr = _global[errName];
+  const Cnstrctr = _global$2[errName];
 
   if (Cnstrctr) {
     errors[errName.toLowerCase()] = {
@@ -6458,9 +6585,7 @@ const file = {
     replace(f) {
       // Sync
       const req = new XMLHttpRequest();
-      req.overrideMimeType('text/plain; charset=x-user-defined'); // eslint-disable-next-line max-len
-      // eslint-disable-next-line node/no-unsupported-features/node-builtins
-
+      req.overrideMimeType('text/plain; charset=x-user-defined');
       req.open('GET', URL.createObjectURL(f), false); // Sync
 
       req.send(); // Seems not feasible to accurately simulate
@@ -6667,7 +6792,7 @@ const imagedata = {
 const infinity = {
   infinity: {
     test(x) {
-      return x === Infinity;
+      return x === Number.POSITIVE_INFINITY;
     },
 
     replace(n) {
@@ -6675,7 +6800,7 @@ const infinity = {
     },
 
     revive(s) {
-      return Infinity;
+      return Number.POSITIVE_INFINITY;
     }
 
   }
@@ -6729,7 +6854,7 @@ const intlTypes = {
   IntlNumberFormat
 };
 
-const map$1 = {
+const map = {
   map: {
     test(x) {
       return Typeson.toStringTag(x) === 'Map';
@@ -6766,7 +6891,7 @@ const nan = {
 const negativeInfinity = {
   negativeInfinity: {
     test(x) {
-      return x === -Infinity;
+      return x === Number.NEGATIVE_INFINITY;
     },
 
     replace(n) {
@@ -6774,7 +6899,7 @@ const negativeInfinity = {
     },
 
     revive(s) {
-      return -Infinity;
+      return Number.NEGATIVE_INFINITY;
     }
 
   }
@@ -6956,12 +7081,12 @@ const typedArraysSocketIO = {};
 /* eslint-env browser, node */
 /* istanbul ignore next */
 
-const _global$2 = typeof self === 'undefined' ? global : self;
+const _global = typeof self === 'undefined' ? global : self;
 
 const typedArrays = {};
 ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'].forEach(function (typeName) {
   const arrType = typeName;
-  const TypedArray = _global$2[arrType];
+  const TypedArray = _global[arrType];
   /* istanbul ignore if */
 
   if (!TypedArray) {
@@ -7027,7 +7152,7 @@ const typedArrays = {};
 });
 
 // This does not preserve `undefined` in sparse arrays; see the `undefined`
-const undef = {
+const undef$1 = {
   undef: {
     test(x, stateObj) {
       return typeof x === 'undefined' && (stateObj.ownKeys || !('ownKeys' in stateObj));
@@ -7053,7 +7178,7 @@ const userObject = {
     },
 
     replace(n) {
-      return _objectSpread2({}, n);
+      return _objectSpread2$1({}, n);
     },
 
     revive(s) {
@@ -7152,11 +7277,11 @@ const specialNumbers = [nan, infinity, negativeInfinity];
 
   Symbols are similarly not included.
 */
-const expObj = [undef, // ES5
+const expObj$1 = [undef$1, // ES5
 arrayNonindexKeys, primitiveObjects, specialNumbers, date, error, errors, regexp].concat( // ES2015 (ES6)
 
 /* istanbul ignore next */
-typeof Map === 'function' ? map$1 : [],
+typeof Map === 'function' ? map : [],
 /* istanbul ignore next */
 typeof Set === 'function' ? set : [],
 /* istanbul ignore next */
@@ -7187,7 +7312,7 @@ custom types after having registered these.
 */
 const postmessage = [error, errors];
 
-const socketio = [expObj, // Leave ArrayBuffer as is, and let socket.io stream it instead.
+const socketio = [expObj$1, // Leave ArrayBuffer as is, and let socket.io stream it instead.
 {
   arraybuffer: null
 }, // Encapsulate TypedArrays in ArrayBuffers instead of base64 strings.
@@ -7226,16 +7351,16 @@ const sparseUndefined = [{
 }];
 
 /* This preset includes types for the Structured Cloning Algorithm. */
-const expObj$1 = [// Todo: Might also register synchronous `ImageBitmap` and
+const expObj = [// Todo: Might also register synchronous `ImageBitmap` and
 //    `Blob`/`File`/`FileList`?
 // ES5
 userObject, // Processed last (non-builtin)
-undef, arrayNonindexKeys, primitiveObjects, specialNumbers, date, regexp, // Non-built-ins
+undef$1, arrayNonindexKeys, primitiveObjects, specialNumbers, date, regexp, // Non-built-ins
 imagedata, imagebitmap, // Async return
 file, filelist, blob].concat( // ES2015 (ES6)
 
 /* istanbul ignore next */
-typeof Map === 'function' ? map$1 : [],
+typeof Map === 'function' ? map : [],
 /* istanbul ignore next */
 typeof Set === 'function' ? set : [],
 /* istanbul ignore next */
@@ -7247,10 +7372,12 @@ typeof DataView === 'function' ? dataview : [],
 /* istanbul ignore next */
 typeof Intl !== 'undefined' ? intlTypes : [],
 /* istanbul ignore next */
+typeof crypto !== 'undefined' ? cryptokey : [],
+/* istanbul ignore next */
 typeof BigInt !== 'undefined' ? [bigint, bigintObject] : []);
 
 /* globals DOMException */
-var structuredCloningThrowing = expObj$1.concat({
+var structuredCloningThrowing = expObj.concat({
   checkDataCloneException: {
     test(val) {
       // Should also throw with:
@@ -7308,9 +7435,9 @@ var structuredCloningThrowing = expObj$1.concat({
   }
 });
 
-const undef$1 = [sparseUndefined, undef];
+const undef = [sparseUndefined, undef$1];
 
-const universal = [expObj // TODO: Add types that are de-facto universal even though not
+const universal = [expObj$1 // TODO: Add types that are de-facto universal even though not
 //   built-in into ecmasript standard.
 ];
 
@@ -7321,6 +7448,7 @@ Typeson.types = {
   bigint,
   blob,
   cloneable,
+  cryptokey,
   dataview,
   date,
   error,
@@ -7331,7 +7459,7 @@ Typeson.types = {
   imagedata,
   infinity,
   intlTypes,
-  map: map$1,
+  map,
   nan,
   negativeInfinity,
   nonbuiltinIgnore,
@@ -7341,19 +7469,19 @@ Typeson.types = {
   set,
   typedArraysSocketio: typedArraysSocketIO,
   typedArrays,
-  undef,
+  undef: undef$1,
   userObject
 };
 Typeson.presets = {
   arrayNonindexKeys,
-  builtin: expObj,
+  builtin: expObj$1,
   postmessage,
   socketio,
   sparseUndefined,
   specialNumbers,
   structuredCloningThrowing,
-  structuredCloning: expObj$1,
-  undef: undef$1,
+  structuredCloning: expObj,
+  undef: undef,
   universal
 };
 
@@ -7366,7 +7494,7 @@ function register(func) {
 //   should probably refactor as a Promise)
 
 
-function encode$2(obj, func) {
+function encode(obj, func) {
   let ret;
 
   try {
@@ -7378,7 +7506,7 @@ function encode$2(obj, func) {
     //   supporting environment (e.g., the browser) where `ShimDOMException` is
     //   an alias for `DOMException`; if typeson-registry ever uses our shim
     //   to throw, we can use this condition alone.
-    Typeson.hasConstructorOf(err, ShimDOMException$1)) {
+    Typeson.hasConstructorOf(err, ShimDOMException)) {
       throw createDOMException('DataCloneError', 'The object cannot be cloned.');
     } // We should rethrow non-cloning exceptions like from
     //  throwing getters (as in the W3C test, key-conversion-exceptions.htm)
@@ -7391,25 +7519,25 @@ function encode$2(obj, func) {
   return ret;
 }
 
-function decode$2(obj) {
+function decode(obj) {
   return typeson.parse(obj);
 }
 
 function clone(val) {
   // We don't return the intermediate `encode` as we'll need to reencode
   //   the clone as it may differ
-  return decode$2(encode$2(val));
+  return decode(encode(val));
 }
 
 var Sca = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  encode: encode$2,
-  decode: decode$2,
+  encode: encode,
+  decode: decode,
   clone: clone,
   register: register
 });
 
-const readonlyProperties$4 = ['objectStore', 'keyPath', 'multiEntry', 'unique'];
+const readonlyProperties$2 = ['objectStore', 'keyPath', 'multiEntry', 'unique'];
 /* eslint-disable jsdoc/check-param-names */
 
 /**
@@ -7431,7 +7559,7 @@ IDBIndex.__createInstance = function (store, indexProperties) {
   function IDBIndex() {
     const me = this;
     me[Symbol.toStringTag] = 'IDBIndex';
-    defineReadonlyProperties(me, readonlyProperties$4);
+    defineReadonlyProperties(me, readonlyProperties$2);
     me.__objectStore = store;
     me.__name = me.__originalName = indexProperties.columnName;
     me.__keyPath = Array.isArray(indexProperties.keyPath) ? indexProperties.keyPath.slice() : indexProperties.keyPath;
@@ -7586,7 +7714,7 @@ IDBIndex.__createIndex = function (store, index) {
           function addIndexEntry(i) {
             if (i < data.rows.length) {
               try {
-                const value = decode$2(unescapeSQLiteResponse(data.rows.item(i).value));
+                const value = decode(unescapeSQLiteResponse(data.rows.item(i).value));
                 let indexKey = extractKeyValueDecodedFromValueUsingKeyPath(value, index.keyPath, index.multiEntry); // Todo: Do we need this stricter error checking?
 
                 if (indexKey.invalid || indexKey.failure) {
@@ -7594,7 +7722,7 @@ IDBIndex.__createIndex = function (store, index) {
                   throw new Error('Go to catch; ignore bad indexKey');
                 }
 
-                indexKey = encode(indexKey.value, index.multiEntry);
+                indexKey = encode$2(indexKey.value, index.multiEntry);
 
                 if (index.unique) {
                   if (indexValues[indexKey]) {
@@ -7793,9 +7921,9 @@ IDBIndex.prototype.__fetchIndexData = function (range, opType, nullDisallowed, c
  */
 
 
-IDBIndex.prototype.openCursor = function ()
-/* query, direction */
-{
+IDBIndex.prototype.openCursor = function
+  /* query, direction */
+() {
   /* eslint-enable jsdoc/check-param-names */
   const me = this; // eslint-disable-next-line prefer-rest-params
 
@@ -7817,9 +7945,9 @@ IDBIndex.prototype.openCursor = function ()
  */
 
 
-IDBIndex.prototype.openKeyCursor = function ()
-/* query, direction */
-{
+IDBIndex.prototype.openKeyCursor = function
+  /* query, direction */
+() {
   /* eslint-enable jsdoc/check-param-names */
   const me = this; // eslint-disable-next-line prefer-rest-params
 
@@ -7850,25 +7978,25 @@ IDBIndex.prototype.getKey = function (query) {
   return this.__fetchIndexData(query, 'key', true);
 };
 
-IDBIndex.prototype.getAll = function ()
-/* query, count */
-{
+IDBIndex.prototype.getAll = function
+  /* query, count */
+() {
   // eslint-disable-next-line prefer-rest-params
   const [query, count] = arguments;
   return this.__fetchIndexData(query, 'value', false, count);
 };
 
-IDBIndex.prototype.getAllKeys = function ()
-/* query, count */
-{
+IDBIndex.prototype.getAllKeys = function
+  /* query, count */
+() {
   // eslint-disable-next-line prefer-rest-params
   const [query, count] = arguments;
   return this.__fetchIndexData(query, 'key', false, count);
 };
 
-IDBIndex.prototype.count = function ()
-/* query */
-{
+IDBIndex.prototype.count = function
+  /* query */
+() {
   const me = this; // eslint-disable-next-line prefer-rest-params
 
   const query = arguments[0]; // With the exception of needing to check whether the index has been
@@ -7974,7 +8102,7 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
 Object.defineProperty(IDBIndex, Symbol.hasInstance, {
   value: obj => isObj(obj) && typeof obj.openCursor === 'function' && typeof obj.multiEntry === 'boolean'
 });
-defineReadonlyOuterInterface(IDBIndex.prototype, readonlyProperties$4);
+defineReadonlyOuterInterface(IDBIndex.prototype, readonlyProperties$2);
 defineOuterInterface(IDBIndex.prototype, ['name']);
 IDBIndex.prototype[Symbol.toStringTag] = 'IDBIndexPrototype';
 Object.defineProperty(IDBIndex, 'prototype', {
@@ -7999,19 +8127,19 @@ function executeFetchIndexData(count, unboundedDisallowed, index, hasKey, range,
       /* */
     } : opType === 'key' ? record => {
       // Key.convertValueToKey(record.key); // Already validated before storage
-      return decode(unescapeSQLiteResponse(record.key));
+      return decode$2(unescapeSQLiteResponse(record.key));
     } : record => {
       // when opType is value
-      return decode$2(unescapeSQLiteResponse(record.value));
+      return decode(unescapeSQLiteResponse(record.value));
     };
 
     if (index.multiEntry) {
       const escapedIndexNameForKeyCol = escapeIndexNameForSQLKeyColumn(index.name);
-      const encodedKey = encode(range, index.multiEntry);
+      const encodedKey = encode$2(range, index.multiEntry);
 
       for (let i = 0; i < data.rows.length; i++) {
         const row = data.rows.item(i);
-        const rowKey = decode(row[escapedIndexNameForKeyCol]);
+        const rowKey = decode$2(row[escapedIndexNameForKeyCol]);
         let record;
 
         if (hasKey && (multiChecks && range.some(check => rowKey.includes(check)) || // More precise than our SQL
@@ -8068,12 +8196,12 @@ function buildFetchIndexDataSQL(nullDisallowed, index, range, opType, multiCheck
       range.forEach((innerKey, i) => {
         if (i > 0) sql.push('OR');
         sql.push(escapeIndexNameForSQL(index.name), "LIKE ? ESCAPE '^' ");
-        sqlValues.push('%' + sqlLIKEEscape(encode(innerKey, index.multiEntry)) + '%');
+        sqlValues.push('%' + sqlLIKEEscape(encode$2(innerKey, index.multiEntry)) + '%');
       });
       sql.push(')');
     } else if (index.multiEntry) {
       sql.push('AND', escapeIndexNameForSQL(index.name), "LIKE ? ESCAPE '^'");
-      sqlValues.push('%' + sqlLIKEEscape(encode(range, index.multiEntry)) + '%');
+      sqlValues.push('%' + sqlLIKEEscape(encode$2(range, index.multiEntry)) + '%');
     } else {
       const convertedRange = convertValueToKeyRange(range, nullDisallowed);
       setSQLForKeyRange(convertedRange, escapeIndexNameForSQL(index.name), sql, sqlValues, true, false);
@@ -8083,7 +8211,7 @@ function buildFetchIndexDataSQL(nullDisallowed, index, range, opType, multiCheck
   return [nullDisallowed, index, hasRange, range, opType, multiChecks, sql, sqlValues];
 }
 
-const readonlyProperties$5 = ['keyPath', 'indexNames', 'transaction', 'autoIncrement'];
+const readonlyProperties$1 = ['keyPath', 'indexNames', 'transaction', 'autoIncrement'];
 /* eslint-disable jsdoc/check-param-names */
 
 /**
@@ -8105,7 +8233,7 @@ IDBObjectStore.__createInstance = function (storeProperties, transaction) {
   function IDBObjectStore() {
     const me = this;
     me[Symbol.toStringTag] = 'IDBObjectStore';
-    defineReadonlyProperties(this, readonlyProperties$5);
+    defineReadonlyProperties(this, readonlyProperties$1);
     me.__name = me.__originalName = storeProperties.name;
     me.__keyPath = Array.isArray(storeProperties.keyPath) ? storeProperties.keyPath.slice() : storeProperties.keyPath;
     me.__transaction = transaction;
@@ -8121,7 +8249,7 @@ IDBObjectStore.__createInstance = function (storeProperties, transaction) {
     } = storeProperties;
 
     for (const indexName in indexList) {
-      if (hasOwn(indexList, indexName)) {
+      if (hasOwn$2(indexList, indexName)) {
         const index = IDBIndex.__createInstance(me, indexList[indexName]);
 
         me.__indexes[index.name] = index;
@@ -8444,8 +8572,8 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
 
   function keyCloneThenSuccess(oldCn) {
     // We want to return the original key, so we don't need to accept an argument here
-    encode$2(key, function (key) {
-      key = decode$2(key);
+    encode(key, function (key) {
+      key = decode(key);
       success(key, oldCn);
     });
   }
@@ -8527,7 +8655,7 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
           return;
         }
 
-        paramMap[index.__currentName] = encode(indexKey, index.multiEntry);
+        paramMap[index.__currentName] = encode$2(indexKey, index.multiEntry);
       }
 
       if (index.unique) {
@@ -8557,7 +8685,7 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
       // Key.convertValueToKey(primaryKey); // Already run
       sqlStart.push(sqlQuote('key'), ',');
       sqlEnd.push('?,');
-      insertSqlValues.push(escapeSQLiteStatement(encode(clonedKeyOrCurrentNumber)));
+      insertSqlValues.push(escapeSQLiteStatement(encode$2(clonedKeyOrCurrentNumber)));
     }
 
     Object.entries(paramMap).forEach(([key, stmt]) => {
@@ -8580,7 +8708,8 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
     return undefined;
   }).catch(function (err) {
     function fail() {
-      // Todo: Add a different error object here if `assignCurrentNumber` fails in reverting?
+      // Todo: Add a different error object here if `assignCurrentNumber`
+      //  fails in reverting?
       error(err);
     }
 
@@ -8658,7 +8787,7 @@ IDBObjectStore.prototype.__overwrite = function (tx, key, cb, error) {
   // Key.convertValueToKey(key); // Already run
 
   const sql = 'DELETE FROM ' + escapeStoreNameForSQL(me.__currentName) + ' WHERE "key" = ?';
-  const encodedKey = encode(key);
+  const encodedKey = encode$2(key);
   tx.executeSql(sql, [escapeSQLiteStatement(encodedKey)], function (tx, data) {
     CFG.DEBUG && console.log('Did the row with the', key, 'exist?', data.rowsAffected);
     cb(tx);
@@ -8675,7 +8804,7 @@ IDBObjectStore.__storingRecordObjectStore = function (request, store, invalidate
 
   store.transaction.__pushToQueue(request, function (tx, args, success, error) {
     store.__deriveKey(tx, value, key, function (clonedKeyOrCurrentNumber, oldCn) {
-      encode$2(value, function (encoded) {
+      encode(value, function (encoded) {
         function insert(tx) {
           store.__insertData(tx, encoded, value, clonedKeyOrCurrentNumber, oldCn, function (...args) {
             if (invalidateCache) {
@@ -8757,11 +8886,11 @@ IDBObjectStore.prototype.__get = function (query, getKey, getAll, count) {
         if (getKey) {
           for (let i = 0; i < data.rows.length; i++) {
             // Key.convertValueToKey(data.rows.item(i).key); // Already validated before storage
-            ret.push(decode(unescapeSQLiteResponse(data.rows.item(i).key), false));
+            ret.push(decode$2(unescapeSQLiteResponse(data.rows.item(i).key), false));
           }
         } else {
           for (let i = 0; i < data.rows.length; i++) {
-            ret.push(decode$2(unescapeSQLiteResponse(data.rows.item(i).value)));
+            ret.push(decode(unescapeSQLiteResponse(data.rows.item(i).value)));
           }
         }
 
@@ -8796,17 +8925,17 @@ IDBObjectStore.prototype.getKey = function (query) {
   return this.__get(query, true);
 };
 
-IDBObjectStore.prototype.getAll = function ()
-/* query, count */
-{
+IDBObjectStore.prototype.getAll = function
+  /* query, count */
+() {
   // eslint-disable-next-line prefer-rest-params
   const [query, count] = arguments;
   return this.__get(query, false, true, count);
 };
 
-IDBObjectStore.prototype.getAllKeys = function ()
-/* query, count */
-{
+IDBObjectStore.prototype.getAllKeys = function
+  /* query, count */
+() {
   // eslint-disable-next-line prefer-rest-params
   const [query, count] = arguments;
   return this.__get(query, true, true, count);
@@ -8880,9 +9009,9 @@ IDBObjectStore.prototype.clear = function () {
   }, undefined, me);
 };
 
-IDBObjectStore.prototype.count = function ()
-/* query */
-{
+IDBObjectStore.prototype.count = function
+  /* query */
+() {
   const me = this; // eslint-disable-next-line prefer-rest-params
 
   const query = arguments[0];
@@ -8899,9 +9028,9 @@ IDBObjectStore.prototype.count = function ()
   return IDBCursorWithValue.__createInstance(query, 'next', me, me, 'key', 'value', true).__request;
 };
 
-IDBObjectStore.prototype.openCursor = function ()
-/* query, direction */
-{
+IDBObjectStore.prototype.openCursor = function
+  /* query, direction */
+() {
   const me = this; // eslint-disable-next-line prefer-rest-params
 
   const [query, direction] = arguments;
@@ -8919,9 +9048,9 @@ IDBObjectStore.prototype.openCursor = function ()
   return cursor.__request;
 };
 
-IDBObjectStore.prototype.openKeyCursor = function ()
-/* query, direction */
-{
+IDBObjectStore.prototype.openKeyCursor = function
+  /* query, direction */
+() {
   const me = this;
 
   if (!(me instanceof IDBObjectStore)) {
@@ -9021,7 +9150,7 @@ IDBObjectStore.prototype.createIndex = function (indexName, keyPath
   }
 
   optionalParameters = optionalParameters || {};
-  /** @name IDBIndexProperties **/
+  /** @name IDBIndexProperties */
 
   const indexProperties = {
     columnName: indexName,
@@ -9065,15 +9194,15 @@ IDBObjectStore.prototype.deleteIndex = function (name) {
   IDBIndex.__deleteIndex(me, index);
 };
 
-defineReadonlyOuterInterface(IDBObjectStore.prototype, readonlyProperties$5);
+defineReadonlyOuterInterface(IDBObjectStore.prototype, readonlyProperties$1);
 defineOuterInterface(IDBObjectStore.prototype, ['name']);
 IDBObjectStore.prototype[Symbol.toStringTag] = 'IDBObjectStorePrototype';
 Object.defineProperty(IDBObjectStore, 'prototype', {
   writable: false
 });
 
-const listeners$2 = ['onabort', 'onclose', 'onerror', 'onversionchange'];
-const readonlyProperties$6 = ['name', 'version', 'objectStoreNames'];
+const listeners = ['onabort', 'onclose', 'onerror', 'onversionchange'];
+const readonlyProperties = ['name', 'version', 'objectStoreNames'];
 /**
  * IDB Database Object.
  * @see http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#database-interface
@@ -9089,14 +9218,14 @@ const IDBDatabaseAlias = IDBDatabase;
 IDBDatabase.__createInstance = function (db, name, oldVersion, version, storeProperties) {
   function IDBDatabase() {
     this[Symbol.toStringTag] = 'IDBDatabase';
-    defineReadonlyProperties(this, readonlyProperties$6);
+    defineReadonlyProperties(this, readonlyProperties);
     this.__db = db;
     this.__closePending = false;
     this.__oldVersion = oldVersion;
     this.__version = version;
     this.__name = name;
     this.__upgradeTransaction = null;
-    defineListenerProperties(this, listeners$2);
+    defineListenerProperties(this, listeners);
 
     this.__setOptions({
       legacyOutputDidListenersThrowFlag: true // Event hook for IndexedB
@@ -9172,7 +9301,7 @@ IDBDatabase.prototype.createObjectStore = function (storeName
 
   IDBTransaction.__assertActive(this.__versionTransaction);
 
-  createOptions = _objectSpread2({}, createOptions);
+  createOptions = _objectSpread2$1({}, createOptions);
   let {
     keyPath
   } = createOptions;
@@ -9191,7 +9320,7 @@ IDBDatabase.prototype.createObjectStore = function (storeName
   if (autoInc && (keyPath === '' || Array.isArray(keyPath))) {
     throw createDOMException('InvalidAccessError', 'With autoIncrement set, the keyPath argument must not be an array or empty string.');
   }
-  /** @name IDBObjectStoreProperties **/
+  /** @name IDBObjectStoreProperties */
 
 
   const storeProperties = {
@@ -9357,8 +9486,8 @@ IDBDatabase.prototype.__forceClose = function (msg) {
   });
 };
 
-defineOuterInterface(IDBDatabase.prototype, listeners$2);
-defineReadonlyOuterInterface(IDBDatabase.prototype, readonlyProperties$6);
+defineOuterInterface(IDBDatabase.prototype, listeners);
+defineReadonlyOuterInterface(IDBDatabase.prototype, readonlyProperties);
 Object.defineProperty(IDBDatabase.prototype, 'constructor', {
   enumerable: false,
   writable: true,
@@ -9370,10 +9499,10 @@ Object.defineProperty(IDBDatabase, 'prototype', {
 });
 
 /* globals location */
-let fs;
+let fs$1;
 
 const setFS = _fs => {
-  fs = _fs;
+  fs$1 = _fs;
 };
 
 const getOrigin = () => {
@@ -9541,8 +9670,8 @@ function cleanupDatabaseResources(__openDatabase, name, escapedDatabaseName, dat
     return;
   }
 
-  if (fs && CFG.deleteDatabaseFiles !== false) {
-    fs.unlink(path.join(CFG.databaseBasePath || '', escapedDatabaseName), err => {
+  if (fs$1 && CFG.deleteDatabaseFiles !== false) {
+    fs$1.unlink(path__default["default"].join(CFG.databaseBasePath || '', escapedDatabaseName), err => {
       if (err && err.code !== 'ENOENT') {
         // Ignore if file is already deleted
         dbError({
@@ -9557,7 +9686,7 @@ function cleanupDatabaseResources(__openDatabase, name, escapedDatabaseName, dat
     return;
   }
 
-  const sqliteDB = __openDatabase(path.join(CFG.databaseBasePath || '', escapedDatabaseName), 1, name, CFG.DEFAULT_DB_SIZE);
+  const sqliteDB = __openDatabase(path__default["default"].join(CFG.databaseBasePath || '', escapedDatabaseName), 1, name, CFG.DEFAULT_DB_SIZE);
 
   sqliteDB.transaction(function (tx) {
     tx.executeSql('SELECT "name" FROM __sys__', [], function (tx, data) {
@@ -9609,7 +9738,7 @@ function createSysDB(__openDatabase, success, failure) {
   if (sysdb) {
     success();
   } else {
-    sysdb = __openDatabase(typeof CFG.memoryDatabase === 'string' ? CFG.memoryDatabase : path.join(typeof CFG.sysDatabaseBasePath === 'string' ? CFG.sysDatabaseBasePath : CFG.databaseBasePath || '', '__sysdb__' + (CFG.addSQLiteExtension !== false ? '.sqlite' : '')), 1, 'System Database', CFG.DEFAULT_DB_SIZE);
+    sysdb = __openDatabase(typeof CFG.memoryDatabase === 'string' ? CFG.memoryDatabase : path__default["default"].join(typeof CFG.sysDatabaseBasePath === 'string' ? CFG.sysDatabaseBasePath : CFG.databaseBasePath || '', '__sysdb__' + (CFG.addSQLiteExtension !== false ? '.sqlite' : '')), 1, 'System Database', CFG.DEFAULT_DB_SIZE);
     sysdb.transaction(function (systx) {
       systx.executeSql('CREATE TABLE IF NOT EXISTS dbVersions (name BLOB, version INT);', [], function (systx) {
         if (!CFG.useSQLiteIndexes) {
@@ -9903,7 +10032,7 @@ IDBFactory.prototype.open = function (name
     if ((useMemoryDatabase || useDatabaseCache) && name in websqlDBCache && websqlDBCache[name][version]) {
       db = websqlDBCache[name][version];
     } else {
-      db = me.__openDatabase(useMemoryDatabase ? CFG.memoryDatabase : path.join(CFG.databaseBasePath || '', escapedDatabaseName), 1, name, CFG.DEFAULT_DB_SIZE);
+      db = me.__openDatabase(useMemoryDatabase ? CFG.memoryDatabase : path__default["default"].join(CFG.databaseBasePath || '', escapedDatabaseName), 1, name, CFG.DEFAULT_DB_SIZE);
 
       if (useDatabaseCache) {
         if (!(name in websqlDBCache)) {
@@ -10310,8 +10439,8 @@ IDBCursor.__super = function IDBCursor(query, direction, store, source, keyColum
 
   if (range !== undefined) {
     // Encode the key range and cache the encoded values, so we don't have to re-encode them over and over
-    range.__lowerCached = range.lower !== undefined && encode(range.lower, this.__multiEntryIndex);
-    range.__upperCached = range.upper !== undefined && encode(range.upper, this.__multiEntryIndex);
+    range.__lowerCached = range.lower !== undefined && encode$2(range.lower, this.__multiEntryIndex);
+    range.__upperCached = range.upper !== undefined && encode$2(range.upper, this.__multiEntryIndex);
   }
 
   this.__gotValue = true;
@@ -10351,17 +10480,17 @@ IDBCursor.prototype.__findBasic = function (key, primaryKey, tx, success, error,
   if (primaryKey !== undefined) {
     sql.push('AND', quotedKey, op + '= ?'); // Key.convertValueToKey(primaryKey); // Already checked by `continuePrimaryKey`
 
-    sqlValues.push(encode(primaryKey));
+    sqlValues.push(encode$2(primaryKey));
   }
 
   if (key !== undefined) {
     sql.push('AND', quotedKeyColumnName, op + '= ?'); // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
 
-    sqlValues.push(encode(key));
+    sqlValues.push(encode$2(key));
   } else if (continueCall && me.__key !== undefined) {
     sql.push('AND', quotedKeyColumnName, op + ' ?'); // Key.convertValueToKey(me.__key); // Already checked when stored
 
-    sqlValues.push(encode(me.__key));
+    sqlValues.push(encode$2(me.__key));
   }
 
   if (!me.__count) {
@@ -10442,17 +10571,17 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
   if (primaryKey !== undefined) {
     sql.push('AND', quotedKey, op + '= ?'); // Key.convertValueToKey(primaryKey); // Already checked by `continuePrimaryKey`
 
-    sqlValues.push(encode(primaryKey));
+    sqlValues.push(encode$2(primaryKey));
   }
 
   if (key !== undefined) {
     sql.push('AND', quotedKeyColumnName, op + '= ?'); // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
 
-    sqlValues.push(encode(key));
+    sqlValues.push(encode$2(key));
   } else if (me.__key !== undefined) {
     sql.push('AND', quotedKeyColumnName, op + ' ?'); // Key.convertValueToKey(me.__key); // Already checked when entered
 
-    sqlValues.push(encode(me.__key));
+    sqlValues.push(encode$2(me.__key));
   }
 
   if (!me.__count) {
@@ -10481,7 +10610,7 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
 
         for (let i = 0; i < data.rows.length; i++) {
           const rowItem = data.rows.item(i);
-          const rowKey = decode(rowItem[me.__keyColumnName], true);
+          const rowKey = decode$2(rowItem[me.__keyColumnName], true);
           const matches = findMultiEntryMatches(rowKey, me.__range);
           ct += matches.length;
         }
@@ -10494,12 +10623,12 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
 
       for (let i = 0; i < data.rows.length; i++) {
         const rowItem = data.rows.item(i);
-        const rowKey = decode(rowItem[me.__keyColumnName], true);
+        const rowKey = decode$2(rowItem[me.__keyColumnName], true);
         const matches = findMultiEntryMatches(rowKey, me.__range);
 
         for (const matchingKey of matches) {
           const clone = {
-            matchingKey: encode(matchingKey, true),
+            matchingKey: encode$2(matchingKey, true),
             key: rowItem.key
           };
           clone[me.__keyColumnName] = rowItem[me.__keyColumnName];
@@ -10621,11 +10750,11 @@ IDBCursor.prototype.__decode = function (rowItem, callback) {
   const encKey = unescapeSQLiteResponse(me.__multiEntryIndex ? rowItem.matchingKey : rowItem[me.__keyColumnName]);
   const encVal = unescapeSQLiteResponse(rowItem[me.__valueColumnName]);
   const encPrimaryKey = unescapeSQLiteResponse(rowItem.key);
-  const key = decode(encKey, me.__multiEntryIndex);
+  const key = decode$2(encKey, me.__multiEntryIndex);
 
   const val = me.__valueDecoder.decode(encVal);
 
-  const primaryKey = decode(encPrimaryKey);
+  const primaryKey = decode$2(encPrimaryKey);
   callback(key, val, primaryKey, encKey
   /*, encVal, encPrimaryKey */
   );
@@ -10708,7 +10837,7 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
             cursorContinue(tx, args, success, error);
           }
 
-          if (me.__unique && !me.__multiEntryIndex && encKey === encode(me.key, me.__multiEntryIndex)) {
+          if (me.__unique && !me.__multiEntryIndex && encKey === encode$2(me.key, me.__multiEntryIndex)) {
             cursorContinue(tx, args, success, error);
             return;
           }
@@ -10728,9 +10857,9 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
   });
 };
 
-IDBCursor.prototype.continue = function ()
-/* key */
-{
+IDBCursor.prototype.continue = function
+  /* key */
+() {
   // eslint-disable-next-line prefer-rest-params
   this.__continue(arguments[0]);
 };
@@ -10767,8 +10896,8 @@ IDBCursor.prototype.continuePrimaryKey = function (key, primaryKey) {
   }
 
   if (cmpResult === 0) {
-    encode$2(primaryKey, function (encPrimaryKey) {
-      encode$2(me.primaryKey, function (encObjectStorePos) {
+    encode(primaryKey, function (encPrimaryKey) {
+      encode(me.primaryKey, function (encObjectStorePos) {
         if (encPrimaryKey === encObjectStorePos || me.direction === 'next' && encPrimaryKey < encObjectStorePos || me.direction === 'prev' && encPrimaryKey > encObjectStorePos) {
           throw createDOMException('DataError', 'Cannot continue the cursor in an unexpected direction');
         }
@@ -10862,7 +10991,7 @@ IDBCursor.prototype.delete = function () {
       const sql = 'DELETE FROM  ' + escapeStoreNameForSQL(me.__store.__currentName) + ' WHERE "key" = ?';
       CFG.DEBUG && console.log(sql, key, primaryKey); // Key.convertValueToKey(primaryKey); // Already checked when entered
 
-      tx.executeSql(sql, [escapeSQLiteStatement(encode(primaryKey))], function (tx, data) {
+      tx.executeSql(sql, [escapeSQLiteStatement(encode$2(primaryKey))], function (tx, data) {
         if (data.rowsAffected === 1) {
           // We don't invalidate the cache (as we don't access it anymore
           //    and it will set the index off)
@@ -10997,7 +11126,7 @@ function setGlobalVars(idb, initialConfig) {
   if (IDB.shimIndexedDB) {
     IDB.shimIndexedDB.__useShim = function () {
       function setNonIDBGlobals(prefix = '') {
-        shim(prefix + 'DOMException', ShimDOMException$1);
+        shim(prefix + 'DOMException', ShimDOMException);
         shim(prefix + 'DOMStringList', DOMStringList, {
           enumerable: false,
           configurable: true,
@@ -11063,8 +11192,8 @@ function setGlobalVars(idb, initialConfig) {
           Object.setPrototypeOf(IDBRequest, EventTarget);
           Object.setPrototypeOf(IDBTransaction, EventTarget);
           Object.setPrototypeOf(IDBVersionChangeEvent, ShimEvent);
-          Object.setPrototypeOf(ShimDOMException$1, Error);
-          Object.setPrototypeOf(ShimDOMException$1.prototype, Error.prototype);
+          Object.setPrototypeOf(ShimDOMException, Error);
+          Object.setPrototypeOf(ShimDOMException.prototype, Error.prototype);
           setPrototypeOfCustomEvent();
         }
 
@@ -11161,17 +11290,18 @@ function setGlobalVars(idb, initialConfig) {
   return IDB;
 } // Expose for ease in simulating such exceptions during testing
 
-function SQLiteResult(error, insertId, rowsAffected, rows) {
+function SQLiteResult$1(error, insertId, rowsAffected, rows) {
   this.error = error;
   this.insertId = insertId;
   this.rowsAffected = rowsAffected;
   this.rows = rows;
 }
 
-var SQLiteResult_1 = SQLiteResult;
+var SQLiteResult_1 = SQLiteResult$1;
 
 var sqlite3 = require('sqlite3');
 
+var SQLiteResult = SQLiteResult_1;
 var READ_ONLY_ERROR = new Error('could not prepare statement (23 not authorized)');
 
 function SQLiteDatabase(name, opts) {
@@ -11195,12 +11325,12 @@ function SQLiteDatabase(name, opts) {
 function runSelect(db, sql, args, cb) {
   db.all(sql, args, function (err, rows) {
     if (err) {
-      return cb(new SQLiteResult_1(err));
+      return cb(new SQLiteResult(err));
     }
 
     var insertId = void 0;
     var rowsAffected = 0;
-    var resultSet = new SQLiteResult_1(null, insertId, rowsAffected, rows);
+    var resultSet = new SQLiteResult(null, insertId, rowsAffected, rows);
     cb(resultSet);
   });
 }
@@ -11208,7 +11338,7 @@ function runSelect(db, sql, args, cb) {
 function runNonSelect(db, sql, args, cb) {
   db.run(sql, args, function (err) {
     if (err) {
-      return cb(new SQLiteResult_1(err));
+      return cb(new SQLiteResult(err));
     }
     /* jshint validthis:true */
 
@@ -11217,7 +11347,7 @@ function runNonSelect(db, sql, args, cb) {
     var insertId = executionResult.lastID;
     var rowsAffected = executionResult.changes;
     var rows = [];
-    var resultSet = new SQLiteResult_1(null, insertId, rowsAffected, rows);
+    var resultSet = new SQLiteResult(null, insertId, rowsAffected, rows);
     cb(resultSet);
   });
 }
@@ -11256,7 +11386,7 @@ SQLiteDatabase.prototype.exec = function exec(queries, readOnly, callback) {
     var isSelect = /^\s*SELECT\b/i.test(sql);
 
     if (readOnly && !isSelect) {
-      onQueryComplete(i)(new SQLiteResult_1(READ_ONLY_ERROR));
+      onQueryComplete(i)(new SQLiteResult(READ_ONLY_ERROR));
     } else if (isSelect) {
       runSelect(db, sql, args, onQueryComplete(i));
     } else {
@@ -11288,7 +11418,7 @@ function wrappedSQLiteDatabase(name) {
   return db;
 }
 
-const nodeWebSQL = customOpenDatabase(wrappedSQLiteDatabase);
+const nodeWebSQL = customOpenDatabase__default["default"](wrappedSQLiteDatabase);
 
 // ID_Start (includes Other_ID_Start)
 const UnicodeIDStart = '(?:[$A-Z_a-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309B-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDF00-\\uDF19]|\\uD806[\\uDCA0-\\uDCDF\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC72-\\uDC8F]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50\\uDF93-\\uDF9F\\uDFE0]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB]|\\uD83A[\\uDC00-\\uDCC4\\uDD00-\\uDD43]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D])'; // ID_Continue (includes Other_ID_Continue)
@@ -11301,15 +11431,15 @@ var UnicodeIdentifiers = /*#__PURE__*/Object.freeze({
   UnicodeIDContinue: UnicodeIDContinue
 });
 
-const fs$1 = require('fs');
+const fs = require('fs');
 
 CFG.win = {
   openDatabase: nodeWebSQL
 };
 
 const __setGlobalVars = function (idb, initialConfig = {}) {
-  const obj = setGlobalVars(idb, _objectSpread2({
-    fs: fs$1
+  const obj = setGlobalVars(idb, _objectSpread2$1({
+    fs
   }, initialConfig));
 
   obj.shimIndexedDB.__setUnicodeIdentifiers(UnicodeIdentifiers);