indexeddbshim 9.0.0 → 10.0.0

package/dist/indexeddbshim.js

@@ -1,11 +1,11 @@
-/*! indexeddbshim - v9.0.0 - 1/5/2022 */
+/*! indexeddbshim - v9.0.0 - 2/26/2022 */
 
 (function (factory) {
   typeof define === 'function' && define.amd ? define(factory) :
   factory();
 })((function () { 'use strict';
 
-  function ownKeys(object, enumerableOnly) {
+  function ownKeys$1(object, enumerableOnly) {
     var keys = Object.keys(object);
 
     if (Object.getOwnPropertySymbols) {
@@ -18,12 +18,12 @@
     return keys;
   }
 
-  function _objectSpread2(target) {
+  function _objectSpread2$1(target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = null != arguments[i] ? arguments[i] : {};
-      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-        _defineProperty(target, key, source[key]);
-      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      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));
       });
     }
@@ -31,23 +31,59 @@
     return target;
   }
 
-  function _typeof$1(obj) {
+  function _typeof$2(obj) {
     "@babel/helpers - typeof";
 
-    return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
       return typeof obj;
     } : function (obj) {
       return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    }, _typeof$1(obj);
+    }, _typeof$2(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);
+      });
+    };
   }
 
-  function _classCallCheck(instance, Constructor) {
+  function _classCallCheck$1(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
     }
   }
 
-  function _defineProperties(target, props) {
+  function _defineProperties$1(target, props) {
     for (var i = 0; i < props.length; i++) {
       var descriptor = props[i];
       descriptor.enumerable = descriptor.enumerable || false;
@@ -57,9 +93,9 @@
     }
   }
 
-  function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
+  function _createClass$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$1(Constructor, staticProps);
     Object.defineProperty(Constructor, "prototype", {
       writable: false
     });
@@ -89,7 +125,7 @@
     return obj;
   }
 
-  function _defineProperty(obj, key, value) {
+  function _defineProperty$1(obj, key, value) {
     if (key in obj) {
       Object.defineProperty(obj, key, {
         value: value,
@@ -143,16 +179,16 @@
     return _construct.apply(null, arguments);
   }
 
-  function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+  function _slicedToArray$1(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
   }
 
   function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
   }
 
   function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+    if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
   }
 
   function _arrayWithHoles(arr) {
@@ -193,16 +229,16 @@
     return _arr;
   }
 
-  function _unsupportedIterableToArray(o, minLen) {
+  function _unsupportedIterableToArray$1(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    if (typeof o === "string") return _arrayLikeToArray$1(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);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen);
   }
 
-  function _arrayLikeToArray(arr, len) {
+  function _arrayLikeToArray$1(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];
@@ -222,7 +258,7 @@
     var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
 
     if (!it) {
-      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") {
         if (it) o = it;
         var i = 0;
 
@@ -275,24 +311,24 @@
     };
   }
 
-  var global$2 = typeof global$1 !== "undefined" ? global$1 : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
+  var global$1 = typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
 
-  var global$1 = typeof global$2 !== "undefined" ? global$2 : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
+  var global = typeof global$1 !== "undefined" ? global$1 : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
 
-  function _typeof(obj) {
+  function _typeof$1(obj) {
     "@babel/helpers - typeof";
 
     if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-      _typeof = function _typeof(obj) {
+      _typeof$1 = function _typeof(obj) {
         return typeof obj;
       };
     } else {
-      _typeof = function _typeof(obj) {
+      _typeof$1 = function _typeof(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
@@ -991,7 +1027,7 @@
       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() {
@@ -1073,7 +1109,7 @@
     Object.setPrototypeOf(ShimCustomEvent.prototype, ShimEvent.prototype);
   } // Todo: Move to own library (but allowing WeakMaps to be passed in for sharing here)
 
-  var map$1 = {};
+  var map = {};
   var CFG = {};
   [// Boolean for verbose reporting
   'DEBUG', // Effectively defaults to false (ignored unless `true`)
@@ -1175,7 +1211,7 @@
     if (Array.isArray(prop)) {
       var _prop = prop;
 
-      var _prop2 = _slicedToArray(_prop, 2);
+      var _prop2 = _slicedToArray$1(_prop, 2);
 
       prop = _prop2[0];
       validator = _prop2[1];
@@ -1183,14 +1219,14 @@
 
     Object.defineProperty(CFG, prop, {
       get: function get() {
-        return map$1[prop];
+        return map[prop];
       },
       set: function set(val) {
         if (validator) {
           validator(val);
         }
 
-        map$1[prop] = val;
+        map[prop] = val;
       }
     });
   });
@@ -1311,7 +1347,7 @@
   }
 
   function isObj(obj) {
-    return obj && _typeof$1(obj) === 'object';
+    return obj && _typeof$2(obj) === 'object';
   }
 
   function isDate(obj) {
@@ -1786,7 +1822,7 @@
   }
 
   function isErrorOrDOMErrorOrDOMException(obj) {
-    return obj && _typeof$1(obj) === 'object' && // We don't use util.isObj here as mutual dependency causing problems in Babel with browser
+    return obj && _typeof$2(obj) === 'object' && // We don't use util.isObj here as mutual dependency causing problems in Babel with browser
     typeof obj.name === 'string';
   }
   /**
@@ -2026,8 +2062,6 @@
     writable: false
   });
 
-  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
   //   not doing the trick for our WebSQL transactions (at least in Node),
   //   we are forced to make the promises run fully synchronously.
 
@@ -2214,12 +2248,12 @@
       var decodedKey1 = _decode(encodedKey1);
       var decodedKey2 = _decode(encodedKey2);
 
-      if (_typeof$1(first) === 'object') {
+      if (_typeof$2(first) === 'object') {
         first = JSON.stringify(first);
         decodedKey1 = JSON.stringify(decodedKey1);
       }
 
-      if (_typeof$1(second) === 'object') {
+      if (_typeof$2(second) === 'object') {
         second = JSON.stringify(second);
         decodedKey2 = JSON.stringify(decodedKey2);
       } // Encoding/decoding mismatches are usually due to a loss of
@@ -2422,7 +2456,7 @@
 
         try {
           for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var _step$value = _slicedToArray(_step.value, 2),
+            var _step$value = _slicedToArray$1(_step.value, 2),
                 i = _step$value[0],
                 item = _step$value[1];
 
@@ -2611,7 +2645,7 @@
     if (isDate(key)) return 'date';
     if (isBinary(key)) return 'binary';
 
-    var keyType = _typeof$1(key);
+    var keyType = _typeof$2(key);
 
     return ['string', 'number'].includes(keyType) ? keyType : 'invalid';
   }
@@ -2786,7 +2820,7 @@
               }();
 
               if (_ret === "continue") continue;
-              if (_typeof$1(_ret) === "object") return _ret.v;
+              if (_typeof$2(_ret) === "object") return _ret.v;
             } catch (err) {
               if (!multiEntry) {
                 throw err;
@@ -2824,7 +2858,7 @@
         {
           // Other `typeof` types which are not valid keys:
           //    'undefined', 'boolean', 'object' (including `null`), 'symbol', 'function
-          var _type = input === null ? 'null' : _typeof$1(input); // Convert `null` for convenience of consumers in reporting errors
+          var _type = input === null ? 'null' : _typeof$2(input); // Convert `null` for convenience of consumers in reporting errors
 
 
           return {
@@ -3770,7 +3804,7 @@
 
       this.sortList();
     }
-  }, _defineProperty(_DOMStringList$protot, Symbol.toStringTag, 'DOMStringListPrototype'), _defineProperty(_DOMStringList$protot, Symbol.iterator, /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+  }, _defineProperty$1(_DOMStringList$protot, Symbol.toStringTag, 'DOMStringListPrototype'), _defineProperty$1(_DOMStringList$protot, Symbol.iterator, /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
     var i;
     return regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
@@ -4492,3187 +4526,1421 @@
     writable: false
   });
 
-  var typeson$1 = {exports: {}};
-
-  (function (module, exports) {
-    (function (global, factory) {
-      module.exports = factory() ;
-    })(commonjsGlobal, function () {
-
-      function _typeof(obj) {
-        "@babel/helpers - typeof";
-
-        if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-          _typeof = function _typeof(obj) {
-            return typeof obj;
-          };
-        } else {
-          _typeof = function _typeof(obj) {
-            return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-          };
-        }
-
-        return _typeof(obj);
-      }
-
-      function _classCallCheck(instance, Constructor) {
-        if (!(instance instanceof Constructor)) {
-          throw new TypeError("Cannot call a class as a function");
-        }
-      }
-
-      function _defineProperties(target, props) {
-        for (var i = 0; i < props.length; i++) {
-          var descriptor = props[i];
-          descriptor.enumerable = descriptor.enumerable || false;
-          descriptor.configurable = true;
-          if ("value" in descriptor) descriptor.writable = true;
-          Object.defineProperty(target, descriptor.key, descriptor);
-        }
-      }
-
-      function _createClass(Constructor, protoProps, staticProps) {
-        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-        if (staticProps) _defineProperties(Constructor, staticProps);
-        return Constructor;
-      }
-
-      function _defineProperty(obj, key, value) {
-        if (key in obj) {
-          Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-          });
-        } else {
-          obj[key] = value;
-        }
-
-        return obj;
-      }
-
-      function ownKeys(object, enumerableOnly) {
-        var keys = Object.keys(object);
+  function ownKeys(e, t) {
+    var r = Object.keys(e);
 
-        if (Object.getOwnPropertySymbols) {
-          var symbols = Object.getOwnPropertySymbols(object);
-          if (enumerableOnly) symbols = symbols.filter(function (sym) {
-            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-          });
-          keys.push.apply(keys, symbols);
-        }
+    if (Object.getOwnPropertySymbols) {
+      var n = Object.getOwnPropertySymbols(e);
+      t && (n = n.filter(function (t) {
+        return Object.getOwnPropertyDescriptor(e, t).enumerable;
+      })), r.push.apply(r, n);
+    }
 
-        return keys;
-      }
+    return r;
+  }
 
-      function _objectSpread2(target) {
-        for (var i = 1; i < arguments.length; i++) {
-          var source = arguments[i] != null ? arguments[i] : {};
+  function _objectSpread2(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var r = null != arguments[t] ? arguments[t] : {};
+      t % 2 ? ownKeys(Object(r), !0).forEach(function (t) {
+        _defineProperty(e, t, r[t]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : ownKeys(Object(r)).forEach(function (t) {
+        Object.defineProperty(e, t, Object.getOwnPropertyDescriptor(r, t));
+      });
+    }
 
-          if (i % 2) {
-            ownKeys(Object(source), true).forEach(function (key) {
-              _defineProperty(target, key, source[key]);
-            });
-          } else if (Object.getOwnPropertyDescriptors) {
-            Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-          } else {
-            ownKeys(Object(source)).forEach(function (key) {
-              Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-            });
-          }
-        }
+    return e;
+  }
 
-        return target;
-      }
+  function _typeof(e) {
+    return (_typeof = "function" == typeof Symbol && "symbol" == _typeof$2(Symbol.iterator) ? function (e) {
+      return _typeof$2(e);
+    } : function (e) {
+      return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : _typeof$2(e);
+    })(e);
+  }
 
-      function _slicedToArray(arr, i) {
-        return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-      }
+  function _classCallCheck(e, t) {
+    if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+  }
 
-      function _toConsumableArray(arr) {
-        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-      }
+  function _defineProperties(e, t) {
+    for (var r = 0; r < t.length; r++) {
+      var n = t[r];
+      n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, n.key, n);
+    }
+  }
 
-      function _arrayWithoutHoles(arr) {
-        if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-      }
+  function _createClass(e, t, r) {
+    return t && _defineProperties(e.prototype, t), r && _defineProperties(e, r), Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
 
-      function _arrayWithHoles(arr) {
-        if (Array.isArray(arr)) return arr;
-      }
+  function _defineProperty(e, t, r) {
+    return t in e ? Object.defineProperty(e, t, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[t] = r, e;
+  }
 
-      function _iterableToArray(iter) {
-        if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
-      }
+  function _slicedToArray(e, t) {
+    return function _arrayWithHoles(e) {
+      if (Array.isArray(e)) return e;
+    }(e) || function _iterableToArrayLimit(e, t) {
+      var r = null == e ? null : "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"];
 
-      function _iterableToArrayLimit(arr, i) {
-        if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-        var _arr = [];
-        var _n = true;
-        var _d = false;
-        var _e = undefined;
+      if (null != r) {
+        var n,
+            a,
+            o = [],
+            i = !0,
+            s = !1;
 
         try {
-          for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-            _arr.push(_s.value);
-
-            if (i && _arr.length === i) break;
+          for (r = r.call(e); !(i = (n = r.next()).done) && (o.push(n.value), !t || o.length !== t); i = !0) {
+            ;
           }
-        } catch (err) {
-          _d = true;
-          _e = err;
+        } catch (e) {
+          s = !0, a = e;
         } finally {
           try {
-            if (!_n && _i["return"] != null) _i["return"]();
+            i || null == r["return"] || r["return"]();
           } finally {
-            if (_d) throw _e;
+            if (s) throw a;
           }
         }
 
-        return _arr;
+        return o;
       }
+    }(e, t) || _unsupportedIterableToArray(e, t) || function _nonIterableRest() {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }();
+  }
 
-      function _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 _unsupportedIterableToArray(e, t) {
+    if (e) {
+      if ("string" == typeof e) return _arrayLikeToArray(e, t);
+      var r = Object.prototype.toString.call(e).slice(8, -1);
+      return "Object" === r && e.constructor && (r = e.constructor.name), "Map" === r || "Set" === r ? Array.from(e) : "Arguments" === r || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? _arrayLikeToArray(e, t) : void 0;
+    }
+  }
 
-      function _arrayLikeToArray(arr, len) {
-        if (len == null || len > arr.length) len = arr.length;
+  function _arrayLikeToArray(e, t) {
+    (null == t || t > e.length) && (t = e.length);
 
-        for (var i = 0, arr2 = new Array(len); i < len; i++) {
-          arr2[i] = arr[i];
-        }
+    for (var r = 0, n = new Array(t); r < t; r++) {
+      n[r] = e[r];
+    }
 
-        return arr2;
-      }
+    return n;
+  }
 
-      function _nonIterableSpread() {
-        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-      }
+  var e = _createClass(function TypesonPromise(e) {
+    _classCallCheck(this, TypesonPromise), this.p = new Promise(e);
+  });
 
-      function _nonIterableRest() {
-        throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-      }
-      /**
-      * @callback TypesonFulfilled
-      * @returns {Promise<any>|any}
-      */
+  e.__typeson__type__ = "TypesonPromise", "undefined" != typeof Symbol && (e.prototype[Symbol.toStringTag] = "TypesonPromise"), e.prototype.then = function (t, r) {
+    var n = this;
+    return new e(function (e, a) {
+      n.p.then(function (r) {
+        e(t ? t(r) : r);
+      })["catch"](function (e) {
+        return r ? r(e) : Promise.reject(e);
+      }).then(e, a);
+    });
+  }, e.prototype["catch"] = function (e) {
+    return this.then(null, e);
+  }, e.resolve = function (t) {
+    return new e(function (e) {
+      e(t);
+    });
+  }, e.reject = function (t) {
+    return new e(function (e, r) {
+      r(t);
+    });
+  }, ["all", "race", "allSettled"].forEach(function (t) {
+    e[t] = function (r) {
+      return new e(function (e, n) {
+        Promise[t](r.map(function (e) {
+          return e && e.constructor && "TypesonPromise" === e.constructor.__typeson__type__ ? e.p : e;
+        })).then(e, n);
+      });
+    };
+  });
+  var t = {}.toString,
+      r = {}.hasOwnProperty,
+      n = Object.getPrototypeOf,
+      a = r.toString;
 
-      /**
-      * @callback TypesonRejected
-      * @returns {Promise<any>|any}
-      */
+  function isThenable(e, t) {
+    return isObject(e) && "function" == typeof e.then && (!t || "function" == typeof e["catch"]);
+  }
 
-      /**
-       * @callback TypesonResolve
-       * @param {any} value
-       * @returns {Promise<any>}
-       */
+  function toStringTag(e) {
+    return t.call(e).slice(8, -1);
+  }
 
-      /**
-       * @callback TypesonReject
-       * @param {Error|any} error
-       * @returns {Promise<any>}
-       */
+  function hasConstructorOf(e, t) {
+    if (!e || "object" !== _typeof(e)) return !1;
+    var o = n(e);
+    if (!o) return null === t;
+    var i = r.call(o, "constructor") && o.constructor;
+    return "function" != typeof i ? null === t : t === i || null !== t && a.call(i) === a.call(t) || "function" == typeof t && "string" == typeof i.__typeson__type__ && i.__typeson__type__ === t.__typeson__type__;
+  }
 
-      /**
-       * @callback TypesonResolveReject
-       * @param {TypesonResolve} typesonResolve
-       * @param {TypesonReject} typesonReject
-       * @returns {Promise<any>}
-       */
+  function isPlainObject(e) {
+    return !(!e || "Object" !== toStringTag(e)) && (!n(e) || hasConstructorOf(e, Object));
+  }
 
-      /* eslint-disable block-spacing, space-before-function-paren,
-        space-before-blocks, space-infix-ops, semi, promise/avoid-new,
-        jsdoc/require-jsdoc */
+  function isUserObject(e) {
+    if (!e || "Object" !== toStringTag(e)) return !1;
+    var t = n(e);
+    return !t || hasConstructorOf(e, Object) || isUserObject(t);
+  }
 
-      /**
-       * 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 {TypesonResolveReject} f
-       */
+  function isObject(e) {
+    return e && "object" === _typeof(e);
+  }
 
+  function escapeKeyPathComponent(e) {
+    return e.replace(/~/g, "~0").replace(/\./g, "~1");
+  }
 
-      var TypesonPromise = function TypesonPromise(f) {
-        _classCallCheck(this, TypesonPromise);
+  function unescapeKeyPathComponent(e) {
+    return e.replace(/~1/g, ".").replace(/~0/g, "~");
+  }
 
-        this.p = new Promise(f);
-      };
-      /* 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
+  function getByKeyPath(e, t) {
+    if ("" === t) return e;
+    var r = t.indexOf(".");
 
+    if (r > -1) {
+      var n = e[unescapeKeyPathComponent(t.slice(0, r))];
+      return void 0 === n ? void 0 : getByKeyPath(n, t.slice(r + 1));
+    }
 
-      TypesonPromise.__typeson__type__ = 'TypesonPromise'; // Note: core-js-bundle provides a `Symbol` polyfill
+    return e[unescapeKeyPathComponent(t)];
+  }
 
-      /* istanbul ignore else */
+  function setAtKeyPath(e, t, r) {
+    if ("" === t) return r;
+    var n = t.indexOf(".");
+    return n > -1 ? setAtKeyPath(e[unescapeKeyPathComponent(t.slice(0, n))], t.slice(n + 1), r) : (e[unescapeKeyPathComponent(t)] = r, e);
+  }
 
-      if (typeof Symbol !== 'undefined') {
-        // Ensure `isUserObject` will return `false` for `TypesonPromise`
-        TypesonPromise.prototype[Symbol.toStringTag] = 'TypesonPromise';
-      }
-      /**
-       *
-       * @param {TypesonFulfilled} [onFulfilled]
-       * @param {TypesonRejected} [onRejected]
-       * @returns {TypesonPromise}
-       */
+  function getJSONType(e) {
+    return null === e ? "null" : Array.isArray(e) ? "array" : _typeof(e);
+  }
 
+  function _await(e, t, r) {
+    return r ? t ? t(e) : e : (e && e.then || (e = Promise.resolve(e)), t ? e.then(t) : e);
+  }
 
-      TypesonPromise.prototype.then = function (onFulfilled, onRejected) {
-        var _this = this;
+  var o = Object.keys,
+      i = Array.isArray,
+      s = {}.hasOwnProperty,
+      c = ["type", "replaced", "iterateIn", "iterateUnsetNumeric"];
 
-        return new TypesonPromise(function (typesonResolve, typesonReject) {
-          // eslint-disable-next-line promise/catch-or-return
-          _this.p.then(function (res) {
-            // eslint-disable-next-line promise/always-return
-            typesonResolve(onFulfilled ? onFulfilled(res) : res);
-          })["catch"](function (res) {
-            return onRejected ? onRejected(res) : Promise.reject(res);
-          }).then(typesonResolve, typesonReject);
-        });
-      };
-      /**
-       *
-       * @param {TypesonRejected} onRejected
-       * @returns {TypesonPromise}
-       */
+  function _async(e) {
+    return function () {
+      for (var t = [], r = 0; r < arguments.length; r++) {
+        t[r] = arguments[r];
+      }
 
+      try {
+        return Promise.resolve(e.apply(this, t));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+  }
 
-      TypesonPromise.prototype["catch"] = function (onRejected) {
-        return this.then(null, onRejected);
-      };
-      /**
-       *
-       * @param {any} v
-       * @returns {TypesonPromise}
-       */
+  function nestedPathsFirst(e, t) {
+    if ("" === e.keypath) return -1;
+    var r = e.keypath.match(/\./g) || 0,
+        n = t.keypath.match(/\./g) || 0;
+    return r && (r = r.length), n && (n = n.length), r > n ? -1 : r < n ? 1 : e.keypath < t.keypath ? -1 : e.keypath > t.keypath;
+  }
 
+  var u = function () {
+    function Typeson(e) {
+      _classCallCheck(this, Typeson), this.options = e, this.plainObjectReplacers = [], this.nonplainObjectReplacers = [], this.revivers = {}, this.types = {};
+    }
 
-      TypesonPromise.resolve = function (v) {
-        return new TypesonPromise(function (typesonResolve) {
-          typesonResolve(v);
+    return _createClass(Typeson, [{
+      key: "stringify",
+      value: function stringify(e, t, r, n) {
+        n = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), n), {}, {
+          stringification: !0
         });
-      };
-      /**
-       *
-       * @param {any} v
-       * @returns {TypesonPromise}
-       */
-
-
-      TypesonPromise.reject = function (v) {
-        return new TypesonPromise(function (typesonResolve, typesonReject) {
-          typesonReject(v);
+        var a = this.encapsulate(e, null, n);
+        return i(a) ? JSON.stringify(a[0], t, r) : a.then(function (e) {
+          return JSON.stringify(e, t, r);
         });
-      };
-
-      ['all', 'race', 'allSettled'].forEach(function (meth) {
-        /**
-         *
-         * @param {Promise<any>[]} promArr
-         * @returns {TypesonPromise}
-         */
-        TypesonPromise[meth] = function (promArr) {
-          return new TypesonPromise(function (typesonResolve, typesonReject) {
-            // eslint-disable-next-line promise/catch-or-return
-            Promise[meth](promArr.map(function (prom) {
-              return prom && prom.constructor && prom.constructor.__typeson__type__ === 'TypesonPromise' ? prom.p : prom;
-            })).then(typesonResolve, typesonReject);
+      }
+    }, {
+      key: "stringifySync",
+      value: function stringifySync(e, t, r, n) {
+        return this.stringify(e, t, r, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, n), {}, {
+          sync: !0
+        }));
+      }
+    }, {
+      key: "stringifyAsync",
+      value: function stringifyAsync(e, t, r, n) {
+        return this.stringify(e, t, r, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, n), {}, {
+          sync: !1
+        }));
+      }
+    }, {
+      key: "parse",
+      value: function parse(e, t, r) {
+        return r = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), r), {}, {
+          parse: !0
+        }), this.revive(JSON.parse(e, t), r);
+      }
+    }, {
+      key: "parseSync",
+      value: function parseSync(e, t, r) {
+        return this.parse(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, r), {}, {
+          sync: !0
+        }));
+      }
+    }, {
+      key: "parseAsync",
+      value: function parseAsync(e, t, r) {
+        return this.parse(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, r), {}, {
+          sync: !1
+        }));
+      }
+    }, {
+      key: "specialTypeNames",
+      value: function specialTypeNames(e, t) {
+        var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+        return r.returnTypeNames = !0, this.encapsulate(e, t, r);
+      }
+    }, {
+      key: "rootTypeName",
+      value: function rootTypeName(e, t) {
+        var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+        return r.iterateNone = !0, this.encapsulate(e, t, r);
+      }
+    }, {
+      key: "encapsulate",
+      value: function encapsulate(t, r, n) {
+        var a = _async(function (t, r) {
+          return _await(Promise.all(r.map(function (e) {
+            return e[1].p;
+          })), function (n) {
+            return _await(Promise.all(n.map(_async(function (n) {
+              var o = !1,
+                  i = [],
+                  s = _slicedToArray(r.splice(0, 1), 1),
+                  c = _slicedToArray(s[0], 7),
+                  u = c[0],
+                  l = c[2],
+                  f = c[3],
+                  y = c[4],
+                  p = c[5],
+                  d = c[6],
+                  v = _encapsulate(u, n, l, f, i, !0, d),
+                  b = hasConstructorOf(v, e);
+
+              return function _invoke(e, t) {
+                var r = e();
+                return r && r.then ? r.then(t) : t(r);
+              }(function () {
+                if (u && b) return _await(v.p, function (e) {
+                  y[p] = e;
+                  var r = a(t, i);
+                  return o = !0, r;
+                });
+              }, function (e) {
+                return o ? e : (u ? y[p] = v : t = b ? v.p : v, a(t, i));
+              });
+            }))), function () {
+              return t;
+            });
+          });
+        }),
+            u = (n = _objectSpread2(_objectSpread2({
+          sync: !0
+        }, this.options), n)).sync,
+            l = this,
+            f = {},
+            y = [],
+            p = [],
+            d = [],
+            v = !("cyclic" in n) || n.cyclic,
+            b = n.encapsulateObserver,
+            h = _encapsulate("", t, v, r || {}, d);
+
+        function finish(e) {
+          var t = Object.values(f);
+          if (n.iterateNone) return t.length ? t[0] : getJSONType(e);
+
+          if (t.length) {
+            if (n.returnTypeNames) return function _toConsumableArray(e) {
+              return function _arrayWithoutHoles(e) {
+                if (Array.isArray(e)) return _arrayLikeToArray(e);
+              }(e) || function _iterableToArray(e) {
+                if ("undefined" != typeof Symbol && null != e[Symbol.iterator] || null != e["@@iterator"]) return Array.from(e);
+              }(e) || _unsupportedIterableToArray(e) || function _nonIterableSpread() {
+                throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+              }();
+            }(new Set(t));
+            e && isPlainObject(e) && !s.call(e, "$types") ? e.$types = f : e = {
+              $: e,
+              $types: {
+                $: f
+              }
+            };
+          } else isObject(e) && s.call(e, "$types") && (e = {
+            $: e,
+            $types: !0
           });
-        };
-      });
-      var _ref = {},
-          toStr = _ref.toString,
-          hasOwn$1 = {}.hasOwnProperty,
-          getProto = Object.getPrototypeOf,
-          fnToString = hasOwn$1.toString;
-      /**
-       * Second argument not in use internally, but provided for utility.
-       * @param {any} v
-       * @param {boolean} catchCheck
-       * @returns {boolean}
-       */
 
-      function isThenable(v, catchCheck) {
-        return isObject(v) && typeof v.then === 'function' && (!catchCheck || typeof v["catch"] === 'function');
-      }
-      /**
-       *
-       * @param {any} val
-       * @returns {string}
-       */
+          return !n.returnTypeNames && e;
+        }
 
+        function _adaptBuiltinStateObjectProperties(e, t, r) {
+          Object.assign(e, t);
+          var n = c.map(function (t) {
+            var r = e[t];
+            return delete e[t], r;
+          });
+          r(), c.forEach(function (t, r) {
+            e[t] = n[r];
+          });
+        }
 
-      function toStringTag(val) {
-        return toStr.call(val).slice(8, -1);
-      }
-      /**
-       * This function is dependent on both constructors
-       *   being identical so any minimization is expected of both.
-       * @param {any} a
-       * @param {GenericFunction} b
-       * @returns {boolean}
-       */
+        function _encapsulate(t, r, a, c, u, d, v) {
+          var h,
+              g = {},
+              m = _typeof(r),
+              O = b ? function (n) {
+            var o = v || c.type || getJSONType(r);
+            b(Object.assign(n || g, {
+              keypath: t,
+              value: r,
+              cyclic: a,
+              stateObj: c,
+              promisesData: u,
+              resolvingTypesonPromise: d,
+              awaitingTypesonPromise: hasConstructorOf(r, e)
+            }, {
+              type: o
+            }));
+          } : null;
+
+          if (["string", "boolean", "number", "undefined"].includes(m)) return void 0 === r || Number.isNaN(r) || r === Number.NEGATIVE_INFINITY || r === Number.POSITIVE_INFINITY ? (h = c.replaced ? r : replace(t, r, c, u, !1, d, O)) !== r && (g = {
+            replaced: h
+          }) : h = r, O && O(), h;
+          if (null === r) return O && O(), r;
+
+          if (a && !c.iterateIn && !c.iterateUnsetNumeric && r && "object" === _typeof(r)) {
+            var S = y.indexOf(r);
+            if (!(S < 0)) return f[t] = "#", O && O({
+              cyclicKeypath: p[S]
+            }), "#" + p[S];
+            !0 === a && (y.push(r), p.push(t));
+          }
 
+          var _,
+              w = isPlainObject(r),
+              A = i(r),
+              j = (w || A) && (!l.plainObjectReplacers.length || c.replaced) || c.iterateIn ? r : replace(t, r, c, u, w || A, null, O);
+
+          if (j !== r ? (h = j, g = {
+            replaced: j
+          }) : "" === t && hasConstructorOf(r, e) ? (u.push([t, r, a, c, void 0, void 0, c.type]), h = r) : A && "object" !== c.iterateIn || "array" === c.iterateIn ? (_ = new Array(r.length), g = {
+            clone: _
+          }) : (["function", "symbol"].includes(_typeof(r)) || "toJSON" in r || hasConstructorOf(r, e) || hasConstructorOf(r, Promise) || hasConstructorOf(r, ArrayBuffer)) && !w && "object" !== c.iterateIn ? h = r : (_ = {}, c.addLength && (_.length = r.length), g = {
+            clone: _
+          }), O && O(), n.iterateNone) return _ || h;
+          if (!_) return h;
+
+          if (c.iterateIn) {
+            var T = function _loop(n) {
+              var o = {
+                ownKeys: s.call(r, n)
+              };
 
-      function hasConstructorOf(a, b) {
-        if (!a || _typeof(a) !== 'object') {
-          return false;
-        }
+              _adaptBuiltinStateObjectProperties(c, o, function () {
+                var o = t + (t ? "." : "") + escapeKeyPathComponent(n),
+                    i = _encapsulate(o, r[n], Boolean(a), c, u, d);
 
-        var proto = getProto(a);
+                hasConstructorOf(i, e) ? u.push([o, i, Boolean(a), c, _, n, c.type]) : void 0 !== i && (_[n] = i);
+              });
+            };
 
-        if (!proto) {
-          return b === null;
-        }
+            for (var I in r) {
+              T(I);
+            }
 
-        var Ctor = hasOwn$1.call(proto, 'constructor') && proto.constructor;
+            O && O({
+              endIterateIn: !0,
+              end: !0
+            });
+          } else o(r).forEach(function (n) {
+            var o = t + (t ? "." : "") + escapeKeyPathComponent(n);
 
-        if (typeof Ctor !== 'function') {
-          return b === null;
-        }
+            _adaptBuiltinStateObjectProperties(c, {
+              ownKeys: !0
+            }, function () {
+              var t = _encapsulate(o, r[n], Boolean(a), c, u, d);
 
-        if (b === Ctor) {
-          return true;
-        }
+              hasConstructorOf(t, e) ? u.push([o, t, Boolean(a), c, _, n, c.type]) : void 0 !== t && (_[n] = t);
+            });
+          }), O && O({
+            endIterateOwn: !0,
+            end: !0
+          });
 
-        if (b !== null && fnToString.call(Ctor) === fnToString.call(b)) {
-          return true;
-        }
+          if (c.iterateUnsetNumeric) {
+            for (var P = r.length, N = function _loop2(n) {
+              if (!(n in r)) {
+                var o = t + (t ? "." : "") + n;
 
-        if (typeof b === 'function' && typeof Ctor.__typeson__type__ === 'string' && Ctor.__typeson__type__ === b.__typeson__type__) {
-          return true;
-        }
+                _adaptBuiltinStateObjectProperties(c, {
+                  ownKeys: !1
+                }, function () {
+                  var t = _encapsulate(o, void 0, Boolean(a), c, u, d);
 
-        return false;
-      }
-      /**
-       *
-       * @param {any} val
-       * @returns {boolean}
-       */
+                  hasConstructorOf(t, e) ? u.push([o, t, Boolean(a), c, _, n, c.type]) : void 0 !== t && (_[n] = t);
+                });
+              }
+            }, C = 0; C < P; C++) {
+              N(C);
+            }
 
+            O && O({
+              endIterateUnsetNumeric: !0,
+              end: !0
+            });
+          }
 
-      function isPlainObject(val) {
-        // Mirrors jQuery's
-        if (!val || toStringTag(val) !== 'Object') {
-          return false;
+          return _;
         }
 
-        var proto = getProto(val);
+        function replace(e, t, r, n, a, o, i) {
+          for (var s = a ? l.plainObjectReplacers : l.nonplainObjectReplacers, c = s.length; c--;) {
+            var y = s[c];
 
-        if (!proto) {
-          // `Object.create(null)`
-          return true;
-        }
+            if (y.test(t, r)) {
+              var p = y.type;
 
-        return hasConstructorOf(val, Object);
-      }
-      /**
-       *
-       * @param {any} val
-       * @returns {boolean}
-       */
+              if (l.revivers[p]) {
+                var d = f[e];
+                f[e] = d ? [p].concat(d) : p;
+              }
 
+              return Object.assign(r, {
+                type: p,
+                replaced: !0
+              }), !u && y.replaceAsync || y.replace ? (i && i({
+                replacing: !0
+              }), _encapsulate(e, y[u || !y.replaceAsync ? "replace" : "replaceAsync"](t, r), v && "readonly", r, n, o, p)) : (i && i({
+                typeDetected: !0
+              }), _encapsulate(e, t, v && "readonly", r, n, o, p));
+            }
+          }
 
-      function isUserObject(val) {
-        if (!val || toStringTag(val) !== 'Object') {
-          return false;
-        }
+          return t;
+        }
+
+        return d.length ? u && n.throwOnBadSyncType ? function () {
+          throw new TypeError("Sync method requested but async result obtained");
+        }() : Promise.resolve(a(h, d)).then(finish) : !u && n.throwOnBadSyncType ? function () {
+          throw new TypeError("Async method requested but sync result obtained");
+        }() : n.stringification && u ? [finish(h)] : u ? finish(h) : Promise.resolve(finish(h));
+      }
+    }, {
+      key: "encapsulateSync",
+      value: function encapsulateSync(e, t, r) {
+        return this.encapsulate(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, r), {}, {
+          sync: !0
+        }));
+      }
+    }, {
+      key: "encapsulateAsync",
+      value: function encapsulateAsync(e, t, r) {
+        return this.encapsulate(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, r), {}, {
+          sync: !1
+        }));
+      }
+    }, {
+      key: "revive",
+      value: function revive(t, r) {
+        var n = t && t.$types;
+        if (!n) return t;
+        if (!0 === n) return t.$;
+
+        var a = (r = _objectSpread2(_objectSpread2({
+          sync: !0
+        }, this.options), r)).sync,
+            s = [],
+            c = {},
+            u = !0;
+
+        n.$ && isPlainObject(n.$) && (t = t.$, n = n.$, u = !1);
+        var f = this;
+
+        function executeReviver(e, t) {
+          var r = _slicedToArray(f.revivers[e] || [], 1)[0];
+
+          if (!r) throw new Error("Unregistered type: " + e);
+          return a && !("revive" in r) ? t : r[a && r.revive ? "revive" : !a && r.reviveAsync ? "reviveAsync" : "revive"](t, c);
+        }
+
+        var y = [];
+
+        function checkUndefined(e) {
+          return hasConstructorOf(e, l) ? void 0 : e;
+        }
+
+        var p,
+            d = function revivePlainObjects() {
+          var r = [];
+          if (Object.entries(n).forEach(function (e) {
+            var t = _slicedToArray(e, 2),
+                a = t[0],
+                o = t[1];
+
+            "#" !== o && [].concat(o).forEach(function (e) {
+              _slicedToArray(f.revivers[e] || [null, {}], 2)[1].plain && (r.push({
+                keypath: a,
+                type: e
+              }), delete n[a]);
+            });
+          }), r.length) return r.sort(nestedPathsFirst).reduce(function reducer(r, n) {
+            var a = n.keypath,
+                o = n.type;
+            if (isThenable(r)) return r.then(function (e) {
+              return reducer(e, {
+                keypath: a,
+                type: o
+              });
+            });
+            var i = getByKeyPath(t, a);
+            if (hasConstructorOf(i = executeReviver(o, i), e)) return i.then(function (e) {
+              var r = setAtKeyPath(t, a, e);
+              r === e && (t = r);
+            });
+            var s = setAtKeyPath(t, a, i);
+            s === i && (t = s);
+          }, void 0);
+        }();
+
+        return hasConstructorOf(d, e) ? p = d.then(function () {
+          return t;
+        }) : (p = function _revive(t, r, a, c, f) {
+          if (!u || "$types" !== t) {
+            var p = n[t],
+                d = i(r);
+
+            if (d || isPlainObject(r)) {
+              var v = d ? new Array(r.length) : {};
+
+              for (o(r).forEach(function (n) {
+                var o = _revive(t + (t ? "." : "") + escapeKeyPathComponent(n), r[n], a || v, v, n),
+                    i = function set(e) {
+                  return hasConstructorOf(e, l) ? v[n] = void 0 : void 0 !== e && (v[n] = e), e;
+                };
 
-        var proto = getProto(val);
+                hasConstructorOf(o, e) ? y.push(o.then(function (e) {
+                  return i(e);
+                })) : i(o);
+              }), r = v; s.length;) {
+                var b = _slicedToArray(s[0], 4),
+                    h = b[0],
+                    g = b[1],
+                    m = b[2],
+                    O = b[3],
+                    S = getByKeyPath(h, g);
+
+                if (void 0 === S) break;
+                m[O] = S, s.splice(0, 1);
+              }
+            }
 
-        if (!proto) {
-          // `Object.create(null)`
-          return true;
-        }
+            if (!p) return r;
 
-        return hasConstructorOf(val, Object) || isUserObject(proto);
-      }
-      /**
-       *
-       * @param {any} v
-       * @returns {boolean}
-       */
+            if ("#" === p) {
+              var _ = getByKeyPath(a, r.slice(1));
 
+              return void 0 === _ && s.push([a, r.slice(1), c, f]), _;
+            }
 
-      function isObject(v) {
-        return v && _typeof(v) === 'object';
-      }
-      /**
-       *
-       * @param {string} keyPathComponent
-       * @returns {string}
-       */
+            return [].concat(p).reduce(function reducer(t, r) {
+              return hasConstructorOf(t, e) ? t.then(function (e) {
+                return reducer(e, r);
+              }) : executeReviver(r, t);
+            }, r);
+          }
+        }("", t, null), y.length && (p = e.resolve(p).then(function (t) {
+          return e.all([t].concat(y));
+        }).then(function (e) {
+          return _slicedToArray(e, 1)[0];
+        }))), isThenable(p) ? a && r.throwOnBadSyncType ? function () {
+          throw new TypeError("Sync method requested but async result obtained");
+        }() : hasConstructorOf(p, e) ? p.p.then(checkUndefined) : p : !a && r.throwOnBadSyncType ? function () {
+          throw new TypeError("Async method requested but sync result obtained");
+        }() : a ? checkUndefined(p) : Promise.resolve(checkUndefined(p));
+      }
+    }, {
+      key: "reviveSync",
+      value: function reviveSync(e, t) {
+        return this.revive(e, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, t), {}, {
+          sync: !0
+        }));
+      }
+    }, {
+      key: "reviveAsync",
+      value: function reviveAsync(e, t) {
+        return this.revive(e, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, t), {}, {
+          sync: !1
+        }));
+      }
+    }, {
+      key: "register",
+      value: function register(e, t) {
+        var r = this;
+        t = t || {};
+
+        var n = function R(e) {
+          i(e) ? e.forEach(function (e) {
+            return R(e);
+          }) : e && o(e).forEach(function (n) {
+            if ("#" === n) throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");
+            if (f.includes(n)) throw new TypeError("Plain JSON object types are reserved as type names");
+            var a = e[n],
+                o = a && a.testPlainObjects ? r.plainObjectReplacers : r.nonplainObjectReplacers,
+                s = o.filter(function (e) {
+              return e.type === n;
+            });
+
+            if (s.length && (o.splice(o.indexOf(s[0]), 1), delete r.revivers[n], delete r.types[n]), "function" == typeof a) {
+              var c = a;
+              a = {
+                test: function test(e) {
+                  return e && e.constructor === c;
+                },
+                replace: function replace(e) {
+                  return _objectSpread2({}, e);
+                },
+                revive: function revive(e) {
+                  return Object.assign(Object.create(c.prototype), e);
+                }
+              };
+            } else if (i(a)) {
+              var u = _slicedToArray(a, 3);
 
+              a = {
+                test: u[0],
+                replace: u[1],
+                revive: u[2]
+              };
+            }
 
-      function escapeKeyPathComponent(keyPathComponent) {
-        return keyPathComponent.replace(/~/g, '~0').replace(/\./g, '~1');
-      }
-      /**
-       *
-       * @param {string} keyPathComponent
-       * @returns {string}
-       */
+            if (a && a.test) {
+              var l = {
+                type: n,
+                test: a.test.bind(a)
+              };
+              a.replace && (l.replace = a.replace.bind(a)), a.replaceAsync && (l.replaceAsync = a.replaceAsync.bind(a));
+              var y = "number" == typeof t.fallback ? t.fallback : t.fallback ? 0 : Number.POSITIVE_INFINITY;
+
+              if (a.testPlainObjects ? r.plainObjectReplacers.splice(y, 0, l) : r.nonplainObjectReplacers.splice(y, 0, l), a.revive || a.reviveAsync) {
+                var p = {};
+                a.revive && (p.revive = a.revive.bind(a)), a.reviveAsync && (p.reviveAsync = a.reviveAsync.bind(a)), r.revivers[n] = [p, {
+                  plain: a.testPlainObjects
+                }];
+              }
 
+              r.types[n] = a;
+            }
+          });
+        };
 
-      function unescapeKeyPathComponent(keyPathComponent) {
-        return keyPathComponent.replace(/~1/g, '.').replace(/~0/g, '~');
+        return [].concat(e).forEach(function (e) {
+          return n(e);
+        }), this;
       }
-      /**
-       * @param {PlainObject|GenericArray} obj
-       * @param {string} keyPath
-       * @returns {any}
-       */
+    }]), Typeson;
+  }(),
+      l = _createClass(function Undefined() {
+    _classCallCheck(this, Undefined);
+  });
 
+  l.__typeson__type__ = "TypesonUndefined";
 
-      function getByKeyPath(obj, keyPath) {
-        if (keyPath === '') {
-          return obj;
-        }
+  for (var f = ["null", "boolean", "number", "string", "array", "object"], y = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", p = new Uint8Array(256), d = 0; d < y.length; d++) {
+    p[y.codePointAt(d)] = d;
+  }
 
-        var period = keyPath.indexOf('.');
+  var v = function encode(e, t, r) {
+    null == r && (r = e.byteLength);
 
-        if (period > -1) {
-          var innerObj = obj[unescapeKeyPathComponent(keyPath.slice(0, period))];
-          return innerObj === undefined ? undefined : getByKeyPath(innerObj, keyPath.slice(period + 1));
-        }
+    for (var n = new Uint8Array(e, t || 0, r), a = n.length, o = "", i = 0; i < a; i += 3) {
+      o += y[n[i] >> 2], o += y[(3 & n[i]) << 4 | n[i + 1] >> 4], o += y[(15 & n[i + 1]) << 2 | n[i + 2] >> 6], o += y[63 & n[i + 2]];
+    }
 
-        return obj[unescapeKeyPathComponent(keyPath)];
-      }
-      /**
-       *
-       * @param {PlainObject} obj
-       * @param {string} keyPath
-       * @param {any} value
-       * @returns {any}
-       */
+    return a % 3 == 2 ? o = o.slice(0, -1) + "=" : a % 3 == 1 && (o = o.slice(0, -2) + "=="), o;
+  },
+      b = function decode(e) {
+    var t,
+        r,
+        n,
+        a,
+        o = e.length,
+        i = .75 * e.length,
+        s = 0;
+    "=" === e[e.length - 1] && (i--, "=" === e[e.length - 2] && i--);
 
-
-      function setAtKeyPath(obj, keyPath, value) {
-        if (keyPath === '') {
-          return value;
-        }
-
-        var period = keyPath.indexOf('.');
-
-        if (period > -1) {
-          var innerObj = obj[unescapeKeyPathComponent(keyPath.slice(0, period))];
-          return setAtKeyPath(innerObj, keyPath.slice(period + 1), value);
-        }
-
-        obj[unescapeKeyPathComponent(keyPath)] = value;
-        return obj;
-      }
-      /**
-       *
-       * @param {external:JSON} value
-       * @returns {"null"|"array"|"undefined"|"boolean"|"number"|"string"|
-       *  "object"|"symbol"}
-       */
-
-
-      function getJSONType(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 = {}.hasOwnProperty,
-          internalStateObjPropsToIgnore = ['type', 'replaced', 'iterateIn', 'iterateUnsetNumeric'];
-      /**
-       * Handle plain object revivers first so reference setting can use
-       * revived type (e.g., array instead of object); assumes revived
-       * has same structure or will otherwise break subsequent references.
-       * @param {PlainObjectType} a
-       * @param {PlainObjectType} b
-       * @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;
-        }
-
-        var as = a.keypath.match(/\./g) || 0;
-        var bs = b.keypath.match(/\./g) || 0;
-
-        if (as) {
-          as = as.length;
-        }
-
-        if (bs) {
-          bs = bs.length;
-        }
-
-        return as > bs ? -1 : as < bs ? 1 : a.keypath < b.keypath ? -1 : a.keypath > b.keypath;
-      }
-
-      var Typeson = /*#__PURE__*/function () {
-        /**
-         * @param {TypesonOptions} options
-         */
-        function Typeson(options) {
-          _classCallCheck(this, Typeson);
-
-          this.options = options; // Replacers signature: replace (value). Returns falsy if not
-          //   replacing. Otherwise ['Date', value.getTime()]
-
-          this.plainObjectReplacers = [];
-          this.nonplainObjectReplacers = []; // Revivers: [{type => reviver}, {plain: boolean}].
-          //   Sample: [{'Date': value => new Date(value)}, {plain: false}]
-
-          this.revivers = {};
-          /** Types registered via `register()`. */
-
-          this.types = {};
-        }
-        /**
-        * @typedef {null|boolean|number|string|GenericArray|PlainObject} JSON
-        */
-
-        /**
-        * @callback JSONReplacer
-        * @param {""|string} key
-        * @param {JSON} value
-        * @returns {number|string|boolean|null|PlainObject|undefined}
-        * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The%20replacer%20parameter
-        */
-
-        /**
-         * 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 {JSONReplacer|string[]} replacer
-         * @param {number|string} space
-         * @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(_objectSpread2(_objectSpread2({}, this.options), opts), {}, {
-              stringification: true
-            });
-            var encapsulated = this.encapsulate(obj, null, opts);
-
-            if (isArray(encapsulated)) {
-              return JSON.stringify(encapsulated[0], replacer, space);
-            }
-
-            return encapsulated.then(function (res) {
-              return JSON.stringify(res, replacer, space);
-            });
-          }
-          /**
-           * Also sync but throws on non-sync result.
-           * @param {any} obj
-           * @param {JSONReplacer|string[]} replacer
-           * @param {number|string} space
-           * @param {TypesonOptions} opts
-           * @returns {string}
-           */
-
-        }, {
-          key: "stringifySync",
-          value: function stringifySync(obj, replacer, space, opts) {
-            return this.stringify(obj, replacer, space, _objectSpread2(_objectSpread2({
-              throwOnBadSyncType: true
-            }, opts), {}, {
-              sync: true
-            }));
-          }
-          /**
-           *
-           * @param {any} obj
-           * @param {JSONReplacer|string[]} replacer
-           * @param {number|string} space
-           * @param {TypesonOptions} opts
-           * @returns {Promise<string>}
-           */
-
-        }, {
-          key: "stringifyAsync",
-          value: function stringifyAsync(obj, replacer, space, opts) {
-            return this.stringify(obj, replacer, space, _objectSpread2(_objectSpread2({
-              throwOnBadSyncType: true
-            }, 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 {JSONReviver} reviver This JSON reviver has nothing to do with
-           *   our revivers.
-           * @param {TypesonOptions} opts
-           * @returns {external:JSON}
-           */
-
-        }, {
-          key: "parse",
-          value: function parse(text, reviver, opts) {
-            opts = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), opts), {}, {
-              parse: true
-            });
-            return this.revive(JSON.parse(text, reviver), opts);
-          }
-          /**
-          * Also sync but throws on non-sync result.
-          * @param {string} text
-          * @param {JSONReviver} reviver This JSON reviver has nothing to do with
-          *   our revivers.
-          * @param {TypesonOptions} opts
-          * @returns {external:JSON}
-          */
-
-        }, {
-          key: "parseSync",
-          value: function parseSync(text, reviver, opts) {
-            return this.parse(text, reviver, _objectSpread2(_objectSpread2({
-              throwOnBadSyncType: true
-            }, opts), {}, {
-              sync: true
-            }));
-          }
-          /**
-          * @param {string} text
-          * @param {JSONReviver} reviver This JSON reviver has nothing to do with
-          *   our revivers.
-          * @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(_objectSpread2({
-              throwOnBadSyncType: true
-            }, opts), {}, {
-              sync: false
-            }));
-          }
-          /**
-          * @typedef {} StateObject
-          */
-
-          /**
-           *
-           * @param {any} obj
-           * @param {StateObject} stateObj
-           * @param {TypesonOptions} [opts={}]
-           * @returns {string[]|false}
-           */
-
-        }, {
-          key: "specialTypeNames",
-          value: function specialTypeNames(obj, stateObj) {
-            var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-            opts.returnTypeNames = true;
-            return this.encapsulate(obj, stateObj, opts);
-          }
-          /**
-           *
-           * @param {any} obj
-           * @param {PlainObject} stateObj
-           * @param {PlainObject} [opts={}]
-           * @returns {Promise<any>|GenericArray|PlainObject|string|false}
-           */
-
-        }, {
-          key: "rootTypeName",
-          value: function rootTypeName(obj, stateObj) {
-            var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-            opts.iterateNone = true;
-            return this.encapsulate(obj, stateObj, opts);
-          }
-          /**
-           * Encapsulate a complex object into a plain Object by replacing
-           * registered types with plain objects representing the types data.
-           *
-           * This method is used internally by `Typeson.stringify()`.
-           * @param {any} obj - Object to encapsulate.
-           * @param {PlainObject} stateObj
-           * @param {PlainObject} opts
-           * @returns {Promise<any>|GenericArray|PlainObject|string|false}
-           */
-
-        }, {
-          key: "encapsulate",
-          value: function encapsulate(obj, stateObj, opts) {
-            /**
-             *
-             * @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);
-            var _opts = opts,
-                sync = _opts.sync;
-            var that = this,
-                types = {},
-                refObjs = [],
-                // For checking cyclic references
-            refKeys = [],
-                // For checking cyclic references
-            promisesDataRoot = []; // Clone the object deeply while at the same time replacing any
-            //   special types or cyclic reference:
-
-            var cyclic = 'cyclic' in opts ? opts.cyclic : true;
-            var _opts2 = opts,
-                encapsulateObserver = _opts2.encapsulateObserver;
-
-            var ret = _encapsulate('', obj, cyclic, stateObj || {}, promisesDataRoot);
-            /**
-             *
-             * @param {any} ret
-             * @returns {GenericArray|PlainObject|string|false}
-             */
-
-
-            function finish(ret) {
-              // Add `$types` to result only if we ever bumped into a
-              //  special type (or special case where object has own `$types`)
-              var typeNames = Object.values(types);
-
-              if (opts.iterateNone) {
-                if (typeNames.length) {
-                  return typeNames[0];
-                }
-
-                return Typeson.getJSONType(ret);
-              }
-
-              if (typeNames.length) {
-                if (opts.returnTypeNames) {
-                  return _toConsumableArray(new Set(typeNames));
-                } // Special if array (or a primitive) was serialized
-                //   because JSON would ignore custom `$types` prop on it
-
-
-                if (!ret || !isPlainObject(ret) || // Also need to handle if this is an object with its
-                //   own `$types` property (to avoid ambiguity)
-                hasOwn.call(ret, '$types')) {
-                  ret = {
-                    $: ret,
-                    $types: {
-                      $: types
-                    }
-                  };
-                } else {
-                  ret.$types = types;
-                } // No special types
-
-              } else if (isObject(ret) && hasOwn.call(ret, '$types')) {
-                ret = {
-                  $: ret,
-                  $types: true
-                };
-              }
-
-              if (opts.returnTypeNames) {
-                return false;
-              }
-
-              return ret;
-            }
-
-            function _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, cb) {
-              Object.assign(stateObj, ownKeysObj);
-              var vals = internalStateObjPropsToIgnore.map(function (prop) {
-                var tmp = stateObj[prop];
-                delete stateObj[prop];
-                return tmp;
-              }); // eslint-disable-next-line node/callback-return
-
-              cb();
-              internalStateObjPropsToIgnore.forEach(function (prop, i) {
-                stateObj[prop] = vals[i];
-              });
-            }
-            /**
-             *
-             * @param {string} keypath
-             * @param {any} value
-             * @param {boolean} cyclic
-             * @param {PlainObject} stateObj
-             * @param {boolean} promisesData
-             * @param {boolean} resolvingTypesonPromise
-             * @param {string} detectedType
-             * @returns {any}
-             */
-
-
-            function _encapsulate(keypath, value, cyclic, stateObj, promisesData, resolvingTypesonPromise, detectedType) {
-              var ret;
-              var observerData = {};
-
-              var $typeof = _typeof(value);
-
-              var runObserver = encapsulateObserver ? function (obj) {
-                var type = detectedType || stateObj.type || Typeson.getJSONType(value);
-                encapsulateObserver(Object.assign(obj || observerData, {
-                  keypath: keypath,
-                  value: value,
-                  cyclic: cyclic,
-                  stateObj: stateObj,
-                  promisesData: promisesData,
-                  resolvingTypesonPromise: resolvingTypesonPromise,
-                  awaitingTypesonPromise: hasConstructorOf(value, TypesonPromise)
-                }, {
-                  type: type
-                }));
-              } : null;
-
-              if (['string', 'boolean', 'number', 'undefined'].includes($typeof)) {
-                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 = {
-                      replaced: ret
-                    };
-                  }
-                } else {
-                  ret = value;
-                }
-
-                if (runObserver) {
-                  runObserver();
-                }
-
-                return ret;
-              }
-
-              if (value === null) {
-                if (runObserver) {
-                  runObserver();
-                }
-
-                return value;
-              }
-
-              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);
-
-                if (refIndex < 0) {
-                  if (cyclic === true) {
-                    refObjs.push(value);
-                    refKeys.push(keypath);
-                  }
-                } else {
-                  types[keypath] = '#';
-
-                  if (runObserver) {
-                    runObserver({
-                      cyclicKeypath: refKeys[refIndex]
-                    });
-                  }
-
-                  return '#' + refKeys[refIndex];
-                }
-              }
-
-              var isPlainObj = isPlainObject(value);
-              var isArr = isArray(value);
-              var replaced = // Running replace will cause infinite loop as will test
-              //   positive again
-              (isPlainObj || isArr) && (!that.plainObjectReplacers.length || stateObj.replaced) || stateObj.iterateIn ? // Optimization: if plain object and no plain-object
-              //   replacers, don't try finding a replacer
-              value : replace(keypath, value, stateObj, promisesData, isPlainObj || isArr, null, runObserver);
-              var clone;
-
-              if (replaced !== value) {
-                ret = replaced;
-                observerData = {
-                  replaced: replaced
-                };
-              } else {
-                // eslint-disable-next-line no-lonely-if
-                if (keypath === '' && hasConstructorOf(value, TypesonPromise)) {
-                  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(value)) && !('toJSON' in value) && !hasConstructorOf(value, TypesonPromise) && !hasConstructorOf(value, Promise) && !hasConstructorOf(value, ArrayBuffer) || isPlainObj || stateObj.iterateIn === 'object') {
-                  clone = {};
-
-                  if (stateObj.addLength) {
-                    clone.length = value.length;
-                  }
-
-                  observerData = {
-                    clone: clone
-                  };
-                } else {
-                  ret = value; // Only clone vanilla objects and arrays
-                }
-              }
-
-              if (runObserver) {
-                runObserver();
-              }
-
-              if (opts.iterateNone) {
-                return clone || ret;
-              }
-
-              if (!clone) {
-                return ret;
-              } // Iterate object or array
-
-
-              if (stateObj.iterateIn) {
-                var _loop = function _loop(key) {
-                  var ownKeysObj = {
-                    ownKeys: hasOwn.call(value, key)
-                  };
-
-                  _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, function () {
-                    var kp = keypath + (keypath ? '.' : '') + escapeKeyPathComponent(key);
-
-                    var val = _encapsulate(kp, value[key], Boolean(cyclic), stateObj, promisesData, resolvingTypesonPromise);
-
-                    if (hasConstructorOf(val, TypesonPromise)) {
-                      promisesData.push([kp, val, Boolean(cyclic), stateObj, clone, key, stateObj.type]);
-                    } else if (val !== undefined) {
-                      clone[key] = val;
-                    }
-                  });
-                }; // eslint-disable-next-line guard-for-in
-
-
-                for (var key in value) {
-                  _loop(key);
-                }
-
-                if (runObserver) {
-                  runObserver({
-                    endIterateIn: true,
-                    end: true
-                  });
-                }
-              } else {
-                // Note: Non-indexes on arrays won't survive stringify so
-                //  somewhat wasteful for arrays, but so too is iterating
-                //  all numeric indexes on sparse arrays when not wanted
-                //  or filtering own keys for positive integers
-                keys(value).forEach(function (key) {
-                  var kp = keypath + (keypath ? '.' : '') + escapeKeyPathComponent(key);
-                  var ownKeysObj = {
-                    ownKeys: true
-                  };
-
-                  _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, function () {
-                    var val = _encapsulate(kp, value[key], Boolean(cyclic), stateObj, promisesData, resolvingTypesonPromise);
-
-                    if (hasConstructorOf(val, TypesonPromise)) {
-                      promisesData.push([kp, val, Boolean(cyclic), stateObj, clone, key, stateObj.type]);
-                    } else if (val !== undefined) {
-                      clone[key] = val;
-                    }
-                  });
-                });
-
-                if (runObserver) {
-                  runObserver({
-                    endIterateOwn: true,
-                    end: true
-                  });
-                }
-              } // Iterate array for non-own numeric properties (we can't
-              //   replace the prior loop though as it iterates non-integer
-              //   keys)
-
-
-              if (stateObj.iterateUnsetNumeric) {
-                var vl = value.length;
-
-                var _loop2 = function _loop2(i) {
-                  if (!(i in value)) {
-                    // No need to escape numeric
-                    var kp = keypath + (keypath ? '.' : '') + i;
-                    var ownKeysObj = {
-                      ownKeys: false
-                    };
-
-                    _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, function () {
-                      var val = _encapsulate(kp, undefined, Boolean(cyclic), stateObj, promisesData, resolvingTypesonPromise);
-
-                      if (hasConstructorOf(val, TypesonPromise)) {
-                        promisesData.push([kp, val, Boolean(cyclic), stateObj, clone, i, stateObj.type]);
-                      } else if (val !== undefined) {
-                        clone[i] = val;
-                      }
-                    });
-                  }
-                };
-
-                for (var i = 0; i < vl; i++) {
-                  _loop2(i);
-                }
-
-                if (runObserver) {
-                  runObserver({
-                    endIterateUnsetNumeric: true,
-                    end: true
-                  });
-                }
-              }
-
-              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 {PlainObject} stateObj
-             * @param {GenericArray} promisesData
-             * @param {boolean} plainObject
-             * @param {boolean} resolvingTypesonPromise
-             * @param {Observer} [runObserver]
-             * @returns {any}
-             */
-
-
-            function replace(keypath, value, stateObj, promisesData, plainObject, resolvingTypesonPromise, runObserver) {
-              // Encapsulate registered types
-              var replacers = plainObject ? that.plainObjectReplacers : that.nonplainObjectReplacers;
-              var i = replacers.length;
-
-              while (i--) {
-                var replacer = replacers[i];
-
-                if (replacer.test(value, stateObj)) {
-                  var type = replacer.type;
-
-                  if (that.revivers[type]) {
-                    // Record the type only if a corresponding reviver
-                    //   exists. This is to support specs where only
-                    //   replacement is done.
-                    // For example, ensuring deep cloning of the object,
-                    //   or replacing a type to its equivalent without
-                    //   the need to revive it.
-                    var existing = types[keypath]; // type can comprise an array of types (see test
-                    //   "should support intermediate types")
-
-                    types[keypath] = existing ? [type].concat(existing) : type;
-                  }
-
-                  Object.assign(stateObj, {
-                    type: type,
-                    replaced: true
-                  });
-
-                  if ((sync || !replacer.replaceAsync) && !replacer.replace) {
-                    if (runObserver) {
-                      runObserver({
-                        typeDetected: true
-                      });
-                    }
-
-                    return _encapsulate(keypath, value, cyclic && 'readonly', stateObj, promisesData, resolvingTypesonPromise, type);
-                  }
-
-                  if (runObserver) {
-                    runObserver({
-                      replacing: true
-                    });
-                  } // Now, also traverse the result in case it contains its
-                  //   own types to replace
-
-
-                  var replaceMethod = sync || !replacer.replaceAsync ? 'replace' : 'replaceAsync';
-                  return _encapsulate(keypath, replacer[replaceMethod](value, stateObj), cyclic && 'readonly', stateObj, promisesData, resolvingTypesonPromise, type);
-                }
-              }
-
-              return value;
-            }
-
-            return promisesDataRoot.length ? sync && opts.throwOnBadSyncType ? function () {
-              throw new TypeError('Sync method requested but async result obtained');
-            }() : Promise.resolve(checkPromises(ret, promisesDataRoot)).then(finish) : !sync && opts.throwOnBadSyncType ? function () {
-              throw new TypeError('Async method requested but sync result obtained');
-            }() // If this is a synchronous request for stringification, yet
-            //   a promise is the result, we don't want to resolve leading
-            //   to an async result, so we return an array to avoid
-            //   ambiguity
-            : opts.stringification && sync ? [finish(ret)] : sync ? finish(ret) : Promise.resolve(finish(ret));
-          }
-          /**
-           * Also sync but throws on non-sync result.
-           * @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(_objectSpread2({
-              throwOnBadSyncType: true
-            }, opts), {}, {
-              sync: true
-            }));
-          }
-          /**
-           * @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(_objectSpread2({
-              throwOnBadSyncType: true
-            }, opts), {}, {
-              sync: false
-            }));
-          }
-          /**
-           * Revive an encapsulated object.
-           * This method is used internally by `Typeson.parse()`.
-           * @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<any>|any} If async, returns a Promise that resolves
-           * to `any`.
-           */
-
-        }, {
-          key: "revive",
-          value: function revive(obj, opts) {
-            var types = obj && obj.$types; // No type info added. Revival not needed.
-
-            if (!types) {
-              return obj;
-            } // Object happened to have own `$types` property but with
-            //   no actual types, so we unescape and return that object
-
-
-            if (types === true) {
-              return obj.$;
-            }
-
-            opts = _objectSpread2(_objectSpread2({
-              sync: true
-            }, this.options), opts);
-            var _opts3 = opts,
-                sync = _opts3.sync;
-            var keyPathResolutions = [];
-            var stateObj = {};
-            var ignore$Types = true; // Special when root object is not a trivial Object, it will
-            //   be encapsulated in `$`. It will also be encapsulated in
-            //   `$` if it has its own `$` property to avoid ambiguity
-
-            if (types.$ && isPlainObject(types.$)) {
-              obj = obj.$;
-              types = types.$;
-              ignore$Types = false;
-            }
-
-            var that = this;
-            /**
-             * @callback RevivalReducer
-             * @param {any} value
-             * @param {string} type
-             * @returns {any}
-             */
-
-            /**
-             *
-             * @param {string} type
-             * @param {any} val
-             * @throws {Error}
-             * @returns {any}
-             */
-
-            function executeReviver(type, val) {
-              var _ref = that.revivers[type] || [],
-                  _ref2 = _slicedToArray(_ref, 1),
-                  reviver = _ref2[0];
-
-              if (!reviver) {
-                throw new Error('Unregistered type: ' + type);
-              } // Only `sync` expected here, as problematic async would
-              //  be missing both `reviver` and `reviverAsync`, and
-              //  encapsulation shouldn't have added types, so
-              //  should have made an early exit
-
-
-              if (sync && !('revive' in reviver)) {
-                // Just return value as is
-                return val;
-              }
-
-              return reviver[sync && reviver.revive ? 'revive' : !sync && reviver.reviveAsync ? 'reviveAsync' : 'revive'](val, stateObj);
-            }
-            /**
-             *
-             * @returns {void|TypesonPromise<void>}
-             */
-
-
-            function revivePlainObjects() {
-              // const references = [];
-              // const reviveTypes = [];
-              var plainObjectTypes = [];
-              Object.entries(types).forEach(function (_ref3) {
-                var _ref4 = _slicedToArray(_ref3, 2),
-                    keypath = _ref4[0],
-                    type = _ref4[1];
-
-                if (type === '#') {
-                  /*
-                  references.push({
-                      keypath,
-                      reference: getByKeyPath(obj, keypath)
-                  });
-                  */
-                  return;
-                }
-
-                [].concat(type).forEach(function (type) {
-                  var _ref5 = that.revivers[type] || [null, {}],
-                      _ref6 = _slicedToArray(_ref5, 2),
-                      plain = _ref6[1].plain;
-
-                  if (!plain) {
-                    // reviveTypes.push({keypath, type});
-                    return;
-                  }
-
-                  plainObjectTypes.push({
-                    keypath: keypath,
-                    type: type
-                  });
-                  delete types[keypath]; // Avoid repeating
-                });
-              });
-
-              if (!plainObjectTypes.length) {
-                return undefined;
-              } // console.log(plainObjectTypes.sort(nestedPathsFirst));
-
-              /**
-              * @typedef {PlainObject} PlainObjectType
-              * @property {string} keypath
-              * @property {string} 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) {
-                    return reducer(val, {
-                      keypath: keypath,
-                      type: type
-                    });
-                  });
-                } // console.log('obj', JSON.stringify(keypath), obj);
-
-
-                var val = getByKeyPath(obj, keypath);
-                val = executeReviver(type, val);
-
-                if (hasConstructorOf(val, TypesonPromise)) {
-                  return val.then(function (v) {
-                    var newVal = setAtKeyPath(obj, keypath, v);
-
-                    if (newVal === v) {
-                      obj = newVal;
-                    }
-
-                    return undefined;
-                  });
-                }
-
-                var newVal = setAtKeyPath(obj, keypath, val);
-
-                if (newVal === val) {
-                  obj = newVal;
-                }
-
-                return undefined;
-              }, undefined // This argument must be explicit
-              ); // references.forEach(({keypath, reference}) => {});
-              // reviveTypes.sort(nestedPathsFirst).forEach(() => {});
-            }
-
-            var revivalPromises = [];
-            /**
-             *
-             * @param {string} keypath
-             * @param {any} value
-             * @param {?(GenericArray|PlainObject)} target
-             * @param {GenericArray|PlainObject} [clone]
-             * @param {string} [key]
-             * @returns {any}
-             */
-
-            function _revive(keypath, value, target, clone, key) {
-              if (ignore$Types && keypath === '$types') {
-                return undefined;
-              }
-
-              var type = types[keypath];
-              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
-
-
-                keys(value).forEach(function (k) {
-                  var val = _revive(keypath + (keypath ? '.' : '') + escapeKeyPathComponent(k), value[k], target || _clone, _clone, k);
-
-                  var set = function set(v) {
-                    if (hasConstructorOf(v, Undefined)) {
-                      _clone[k] = undefined;
-                    } else if (v !== undefined) {
-                      _clone[k] = v;
-                    }
-
-                    return v;
-                  };
-
-                  if (hasConstructorOf(val, TypesonPromise)) {
-                    revivalPromises.push(val.then(function (ret) {
-                      return set(ret);
-                    }));
-                  } else {
-                    set(val);
-                  }
-                });
-                value = _clone; // Try to resolve cyclic reference as soon as available
-
-                while (keyPathResolutions.length) {
-                  var _keyPathResolutions$ = _slicedToArray(keyPathResolutions[0], 4),
-                      _target = _keyPathResolutions$[0],
-                      keyPath = _keyPathResolutions$[1],
-                      _clone2 = _keyPathResolutions$[2],
-                      k = _keyPathResolutions$[3];
-
-                  var val = getByKeyPath(_target, keyPath); // Typeson.Undefined not expected here as not cyclic or
-                  //   `undefined`
-
-                  if (val !== undefined) {
-                    _clone2[k] = val;
-                  } else {
-                    break;
-                  }
-
-                  keyPathResolutions.splice(0, 1);
-                }
-              }
-
-              if (!type) {
-                return value;
-              }
-
-              if (type === '#') {
-                var _ret = getByKeyPath(target, value.slice(1));
-
-                if (_ret === undefined) {
-                  // Cyclic reference not yet available
-                  keyPathResolutions.push([target, value.slice(1), clone, key]);
-                }
-
-                return _ret;
-              } // `type` can be an array here
-
-
-              return [].concat(type).reduce(function reducer(val, typ) {
-                if (hasConstructorOf(val, TypesonPromise)) {
-                  return val.then(function (v) {
-                    // TypesonPromise here too
-                    return reducer(v, typ);
-                  });
-                }
-
-                return executeReviver(typ, val);
-              }, value);
-            }
-            /**
-             *
-             * @param {any} retrn
-             * @returns {undefined|any}
-             */
-
-
-            function checkUndefined(retrn) {
-              return hasConstructorOf(retrn, Undefined) ? undefined : retrn;
-            }
-
-            var possibleTypesonPromise = revivePlainObjects();
-            var ret;
-
-            if (hasConstructorOf(possibleTypesonPromise, TypesonPromise)) {
-              ret = possibleTypesonPromise.then(function () {
-                return obj;
-              });
-            } else {
-              ret = _revive('', obj, null);
-
-              if (revivalPromises.length) {
-                // Ensure children resolved
-                ret = TypesonPromise.resolve(ret).then(function (r) {
-                  return TypesonPromise.all([// May be a TypesonPromise or not
-                  r].concat(revivalPromises));
-                }).then(function (_ref8) {
-                  var _ref9 = _slicedToArray(_ref8, 1),
-                      r = _ref9[0];
-
-                  return r;
-                });
-              }
-            }
-
-            return isThenable(ret) ? sync && opts.throwOnBadSyncType ? function () {
-              throw new TypeError('Sync method requested but async result obtained');
-            }() : hasConstructorOf(ret, TypesonPromise) ? ret.p.then(checkUndefined) : ret : !sync && opts.throwOnBadSyncType ? function () {
-              throw new TypeError('Async method requested but sync result obtained');
-            }() : sync ? checkUndefined(ret) : Promise.resolve(checkUndefined(ret));
-          }
-          /**
-           * Also sync but throws on non-sync result.
-           * @param {any} obj
-           * @param {TypesonOptions} opts
-           * @returns {any}
-           */
-
-        }, {
-          key: "reviveSync",
-          value: function reviveSync(obj, opts) {
-            return this.revive(obj, _objectSpread2(_objectSpread2({
-              throwOnBadSyncType: true
-            }, opts), {}, {
-              sync: true
-            }));
-          }
-          /**
-          * @param {any} obj
-          * @param {TypesonOptions} opts
-          * @returns {Promise<any>}
-          */
-
-        }, {
-          key: "reviveAsync",
-          value: function reviveAsync(obj, opts) {
-            return this.revive(obj, _objectSpread2(_objectSpread2({
-              throwOnBadSyncType: true
-            }, 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,Spec[]>[]} typeSpecSets -
-           * Types and their functions [test, encapsulate, revive];
-           * @param {TypesonOptions} opts
-           * @returns {Typeson}
-           */
-
-        }, {
-          key: "register",
-          value: function register(typeSpecSets, opts) {
-            opts = opts || {};
-            [].concat(typeSpecSets).forEach(function R(typeSpec) {
-              var _this = this; // Allow arrays of arrays of arrays...
-
-
-              if (isArray(typeSpec)) {
-                return typeSpec.map(function (typSpec) {
-                  return R.call(_this, typSpec);
-                });
-              }
-
-              typeSpec && keys(typeSpec).forEach(function (typeId) {
-                if (typeId === '#') {
-                  throw new TypeError('# cannot be used as a type name as it is reserved ' + 'for cyclic objects');
-                } else if (Typeson.JSON_TYPES.includes(typeId)) {
-                  throw new TypeError('Plain JSON object types are reserved as type names');
-                }
-
-                var spec = typeSpec[typeId];
-                var replacers = spec && spec.testPlainObjects ? this.plainObjectReplacers : this.nonplainObjectReplacers;
-                var existingReplacer = replacers.filter(function (r) {
-                  return r.type === typeId;
-                });
-
-                if (existingReplacer.length) {
-                  // Remove existing spec and replace with this one.
-                  replacers.splice(replacers.indexOf(existingReplacer[0]), 1);
-                  delete this.revivers[typeId];
-                  delete this.types[typeId];
-                }
-
-                if (typeof spec === 'function') {
-                  // Support registering just a class without replacer/reviver
-                  var Class = spec;
-                  spec = {
-                    test: function test(x) {
-                      return x && x.constructor === Class;
-                    },
-                    replace: function replace(x) {
-                      return _objectSpread2({}, x);
-                    },
-                    revive: function revive(x) {
-                      return Object.assign(Object.create(Class.prototype), x);
-                    }
-                  };
-                } else if (isArray(spec)) {
-                  var _spec = spec,
-                      _spec2 = _slicedToArray(_spec, 3),
-                      test = _spec2[0],
-                      replace = _spec2[1],
-                      revive = _spec2[2];
-
-                  spec = {
-                    test: test,
-                    replace: replace,
-                    revive: revive
-                  };
-                }
-
-                if (!spec || !spec.test) {
-                  return;
-                }
-
-                var replacerObj = {
-                  type: typeId,
-                  test: spec.test.bind(spec)
-                };
-
-                if (spec.replace) {
-                  replacerObj.replace = spec.replace.bind(spec);
-                }
-
-                if (spec.replaceAsync) {
-                  replacerObj.replaceAsync = spec.replaceAsync.bind(spec);
-                }
-
-                var start = typeof opts.fallback === 'number' ? opts.fallback : opts.fallback ? 0 : Number.POSITIVE_INFINITY;
-
-                if (spec.testPlainObjects) {
-                  this.plainObjectReplacers.splice(start, 0, replacerObj);
-                } else {
-                  this.nonplainObjectReplacers.splice(start, 0, replacerObj);
-                } // Todo: We might consider a testAsync type
-
-
-                if (spec.revive || spec.reviveAsync) {
-                  var reviverObj = {};
-
-                  if (spec.revive) {
-                    reviverObj.revive = spec.revive.bind(spec);
-                  }
-
-                  if (spec.reviveAsync) {
-                    reviverObj.reviveAsync = spec.reviveAsync.bind(spec);
-                  }
-
-                  this.revivers[typeId] = [reviverObj, {
-                    plain: spec.testPlainObjects
-                  }];
-                } // Record to be retrieved via public types property.
-
-
-                this.types[typeId] = spec;
-              }, this);
-            }, this);
-            return this;
-          }
-        }]);
-
-        return Typeson;
-      }();
-      /**
-       * 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`.
-       * @class
-       */
-
-
-      var Undefined = function Undefined() {
-        _classCallCheck(this, Undefined);
-      }; // eslint-disable-line space-before-blocks
-
-
-      Undefined.__typeson__type__ = 'TypesonUndefined'; // The following provide classes meant to avoid clashes with other values
-      // To insist `undefined` should be added
-
-      Typeson.Undefined = Undefined; // To support async encapsulation/stringification
-
-      Typeson.Promise = TypesonPromise; // Some fundamental type-checking utilities
-
-      Typeson.isThenable = isThenable;
-      Typeson.toStringTag = toStringTag;
-      Typeson.hasConstructorOf = hasConstructorOf;
-      Typeson.isObject = isObject;
-      Typeson.isPlainObject = isPlainObject;
-      Typeson.isUserObject = isUserObject;
-      Typeson.escapeKeyPathComponent = escapeKeyPathComponent;
-      Typeson.unescapeKeyPathComponent = unescapeKeyPathComponent;
-      Typeson.getByKeyPath = getByKeyPath;
-      Typeson.getJSONType = getJSONType;
-      Typeson.JSON_TYPES = ['null', 'boolean', 'number', 'string', 'array', 'object'];
-      return Typeson;
-    });
-  })(typeson$1);
-
-  var Typeson = typeson$1.exports;
-
-  /*
-   * base64-arraybuffer
-   * https://github.com/niklasvh/base64-arraybuffer
-   *
-   * Copyright (c) 2017 Brett Zamir, 2012 Niklas von Hertzen
-   * Licensed under the MIT license.
-   */
-  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; // Use a lookup table to find the index.
-
-  var lookup = new Uint8Array(256);
-
-  for (var i = 0; i < chars.length; i++) {
-    lookup[chars.charCodeAt(i)] = i;
-  }
-  /**
-   * @param {ArrayBuffer} arraybuffer
-   * @param {Integer} byteOffset
-   * @param {Integer} lngth
-   * @returns {string}
-   */
-
-
-  var encode$1 = function encode(arraybuffer, byteOffset, lngth) {
-    if (lngth === null || lngth === undefined) {
-      lngth = arraybuffer.byteLength; // Needed for Safari
+    for (var c = new ArrayBuffer(i), u = new Uint8Array(c), l = 0; l < o; l += 4) {
+      t = p[e.codePointAt(l)], r = p[e.codePointAt(l + 1)], n = p[e.codePointAt(l + 2)], a = p[e.codePointAt(l + 3)], u[s++] = t << 2 | r >> 4, u[s++] = (15 & r) << 4 | n >> 2, u[s++] = (3 & n) << 6 | 63 & a;
     }
 
-    var bytes = new Uint8Array(arraybuffer, byteOffset || 0, // Default needed for Safari
-    lngth);
-    var len = bytes.length;
-    var base64 = '';
-
-    for (var _i = 0; _i < len; _i += 3) {
-      base64 += chars[bytes[_i] >> 2];
-      base64 += chars[(bytes[_i] & 3) << 4 | bytes[_i + 1] >> 4];
-      base64 += chars[(bytes[_i + 1] & 15) << 2 | bytes[_i + 2] >> 6];
-      base64 += chars[bytes[_i + 2] & 63];
-    }
-
-    if (len % 3 === 2) {
-      base64 = base64.slice(0, -1) + '=';
-    } else if (len % 3 === 1) {
-      base64 = base64.slice(0, -2) + '==';
-    }
-
-    return base64;
-  };
-  /**
-   * @param {string} base64
-   * @returns {ArrayBuffer}
-   */
-
-
-  var decode$1 = function decode(base64) {
-    var len = base64.length;
-    var bufferLength = base64.length * 0.75;
-    var p = 0;
-    var encoded1, encoded2, encoded3, encoded4;
-
-    if (base64[base64.length - 1] === '=') {
-      bufferLength--;
-
-      if (base64[base64.length - 2] === '=') {
-        bufferLength--;
-      }
-    }
-
-    var arraybuffer = new ArrayBuffer(bufferLength),
-        bytes = new Uint8Array(arraybuffer);
-
-    for (var _i2 = 0; _i2 < len; _i2 += 4) {
-      encoded1 = lookup[base64.charCodeAt(_i2)];
-      encoded2 = lookup[base64.charCodeAt(_i2 + 1)];
-      encoded3 = lookup[base64.charCodeAt(_i2 + 2)];
-      encoded4 = lookup[base64.charCodeAt(_i2 + 3)];
-      bytes[p++] = encoded1 << 2 | encoded2 >> 4;
-      bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
-      bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
-    }
-
-    return arraybuffer;
-  };
-
-  var arraybuffer = {
-    arraybuffer: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'ArrayBuffer';
-      },
-      replace: function replace(b, stateObj) {
-        if (!stateObj.buffers) {
-          stateObj.buffers = [];
-        }
-
-        var index = stateObj.buffers.indexOf(b);
-
-        if (index > -1) {
-          return {
-            index: index
-          };
-        }
-
-        stateObj.buffers.push(b);
-        return encode$1(b);
-      },
-      revive: function revive(b64, stateObj) {
-        if (!stateObj.buffers) {
-          stateObj.buffers = [];
-        }
-
-        if (_typeof$1(b64) === 'object') {
-          return stateObj.buffers[b64.index];
-        }
-
-        var buffer = decode$1(b64);
-        stateObj.buffers.push(buffer);
-        return buffer;
-      }
-    }
+    return c;
   };
-   // See also typed-arrays!
 
-  var bigintObject = {
+  var h = {
+    arraybuffer: {
+      test: function test(e) {
+        return "ArrayBuffer" === toStringTag(e);
+      },
+      replace: function replace(e, t) {
+        t.buffers || (t.buffers = []);
+        var r = t.buffers.indexOf(e);
+        return r > -1 ? {
+          index: r
+        } : (t.buffers.push(e), v(e));
+      },
+      revive: function revive(e, t) {
+        if (t.buffers || (t.buffers = []), "object" == _typeof$2(e)) return t.buffers[e.index];
+        var r = b(e);
+        return t.buffers.push(r), r;
+      }
+    }
+  },
+      g = {
     bigintObject: {
-      test: function test(x) {
-        return _typeof$1(x) === 'object' && Typeson.hasConstructorOf(x, BigInt);
+      test: function test(e) {
+        return "object" == _typeof$2(e) && hasConstructorOf(e, BigInt);
       },
-      replace: function replace(n) {
-        return String(n);
+      replace: function replace(e) {
+        return String(e);
       },
-      revive: function revive(s) {
-        // Filed this to avoid error: https://github.com/eslint/eslint/issues/11810
-        // eslint-disable-next-line no-new-object
-        return new Object(BigInt(s));
+      revive: function revive(e) {
+        return new Object(BigInt(e));
       }
     }
-  };
-
-  /* globals BigInt */
-  var bigint = {
+  },
+      m = {
     bigint: {
-      test: function test(x) {
-        return typeof x === 'bigint';
+      test: function test(e) {
+        return "bigint" == typeof e;
       },
-      replace: function replace(n) {
-        return String(n);
+      replace: function replace(e) {
+        return String(e);
       },
-      revive: function revive(s) {
-        return BigInt(s);
+      revive: function revive(e) {
+        return BigInt(e);
       }
     }
   };
 
-  /**
-   * Not currently in use internally, but provided for parity.
-   * @param {ArrayBuffer} buf
-   * @returns {Uint8Array}
-   */
-  /**
-   *
-   * @param {string} str
-   * @returns {ArrayBuffer}
-   */
-
-
-  function string2arraybuffer(str) {
-    /*
-    // UTF-8 approaches
-    const utf8 = unescape(encodeURIComponent(str));
-    const arr = new Uint8Array(utf8.length);
-    for (let i = 0; i < utf8.length; i++) {
-        arr[i] = utf8.charCodeAt(i);
-    }
-    return arr.buffer;
-     const utf8 = [];
-    for (let i = 0; i < str.length; i++) {
-        let charcode = str.charCodeAt(i);
-        if (charcode < 0x80) utf8.push(charcode);
-        else if (charcode < 0x800) {
-            utf8.push(0xc0 | (charcode >> 6),
-                0x80 | (charcode & 0x3f));
-        } else if (charcode < 0xd800 || charcode >= 0xe000) {
-            utf8.push(0xe0 | (charcode >> 12),
-                0x80 | ((charcode >> 6) & 0x3f),
-                0x80 | (charcode & 0x3f));
-        // surrogate pair
-        } else {
-            i++;
-            // UTF-16 encodes 0x10000-0x10FFFF by
-            // subtracting 0x10000 and splitting the
-            // 20 bits of 0x0-0xFFFFF into two halves
-            charcode = 0x10000 + (((charcode & 0x3ff) << 10) |
-                (str.charCodeAt(i) & 0x3ff));
-            utf8.push(0xf0 | (charcode >> 18),
-                0x80 | ((charcode >> 12) & 0x3f),
-                0x80 | ((charcode >> 6) & 0x3f),
-                0x80 | (charcode & 0x3f));
-        }
-    }
-    return utf8;
-    */
-
-    /*
-    // Working UTF-16 options (equivalents)
-    const buf = new ArrayBuffer(str.length * 2); // 2 bytes for each char
-    const bufView = new Uint16Array(buf);
-    for (let i = 0, strLen = str.length; i < strLen; i++) {
-        bufView[i] = str.charCodeAt(i);
-    }
-    return buf;
-    */
-    var array = new Uint8Array(str.length);
+  function string2arraybuffer(e) {
+    var t = new Uint8Array(e.length);
 
-    for (var i = 0; i < str.length; i++) {
-      array[i] = str.charCodeAt(i); // & 0xff;
+    for (var _r = 0; _r < e.length; _r++) {
+      t[_r] = e.charCodeAt(_r);
     }
 
-    return array.buffer;
+    return t.buffer;
   }
 
-  /* globals XMLHttpRequest, Blob, FileReader */
-  var blob = {
+  var O = {
     blob: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'Blob';
+      test: function test(e) {
+        return "Blob" === toStringTag(e);
       },
-      replace: function replace(b) {
-        // Sync
-        var req = new XMLHttpRequest();
-        req.overrideMimeType('text/plain; charset=x-user-defined');
-        req.open('GET', URL.createObjectURL(b), false); // Sync
-
-        req.send(); // Seems not feasible to accurately simulate
-
-        /* istanbul ignore next */
-
-        if (req.status !== 200 && req.status !== 0) {
-          throw new Error('Bad Blob access: ' + req.status);
-        }
-
+      replace: function replace(e) {
+        var t = new XMLHttpRequest();
+        if (t.overrideMimeType("text/plain; charset=x-user-defined"), t.open("GET", URL.createObjectURL(e), !1), t.send(), 200 !== t.status && 0 !== t.status) throw new Error("Bad Blob access: " + t.status);
         return {
-          type: b.type,
-          stringContents: req.responseText
+          type: e.type,
+          stringContents: t.responseText
         };
       },
       revive: function revive(_ref) {
-        var type = _ref.type,
-            stringContents = _ref.stringContents;
-        return new Blob([string2arraybuffer(stringContents)], {
-          type: type
+        var e = _ref.type,
+            t = _ref.stringContents;
+        return new Blob([string2arraybuffer(t)], {
+          type: e
         });
       },
-      replaceAsync: function replaceAsync(b) {
-        return new Typeson.Promise(function (resolve, reject) {
-          /*
-          if (b.isClosed) { // On MDN, but not in https://w3c.github.io/FileAPI/#dfn-Blob
-              reject(new Error('The Blob is closed'));
-              return;
-          }
-          */
-          var reader = new FileReader();
-          reader.addEventListener('load', function () {
-            resolve({
-              type: b.type,
-              stringContents: reader.result
+      replaceAsync: function replaceAsync(t) {
+        return new e(function (e, r) {
+          var n = new FileReader();
+          n.addEventListener("load", function () {
+            e({
+              type: t.type,
+              stringContents: n.result
             });
-          }); // Seems not feasible to accurately simulate
-
-          /* istanbul ignore next */
-
-          reader.addEventListener('error', function () {
-            reject(reader.error);
-          });
-          reader.readAsBinaryString(b);
+          }), n.addEventListener("error", function () {
+            r(n.error);
+          }), n.readAsBinaryString(t);
         });
       }
     }
   };
 
-  /* globals performance */
-  // The `performance` global is optional
-
-  /**
-   * @todo We could use `import generateUUID from 'uuid/v4';` (but it needs
-   *   crypto library, etc.; `rollup-plugin-node-builtins` doesn't recommend
-   *   using its own version and though there is <https://www.npmjs.com/package/crypto-browserify>,
-   *   it may be troublesome to bundle and not strongly needed)
-   * @returns {string}
-   */
-  function generateUUID() {
-    //  Adapted from original: public domain/MIT: http://stackoverflow.com/a/8809472/271577
-
-    /* istanbul ignore next */
-    var 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]/g, function (c) {
-      /* eslint-disable no-bitwise */
-      var 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 */
-    });
-  }
-
-  var cloneableObjectsByUUID = {};
-  var cloneable = {
-    cloneable: {
-      test: function test(x) {
-        return x && _typeof$1(x) === 'object' && typeof x[Symbol["for"]('cloneEncapsulate')] === 'function';
-      },
-      replace: function replace(clonable) {
-        var encapsulated = clonable[Symbol["for"]('cloneEncapsulate')]();
-        var uuid = generateUUID();
-        cloneableObjectsByUUID[uuid] = clonable;
-        return {
-          uuid: uuid,
-          encapsulated: encapsulated
-        };
-      },
-      revive: function revive(_ref) {
-        var uuid = _ref.uuid,
-            encapsulated = _ref.encapsulated;
-        return cloneableObjectsByUUID[uuid][Symbol["for"]('cloneRevive')](encapsulated);
-      }
-    }
-  };
-
-  /* globals crypto */
-  var cryptokey = {
+  var w = {
     cryptokey: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'CryptoKey' && x.extractable;
-      },
-      replaceAsync: function replaceAsync(key) {
-        return new Typeson.Promise(function (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
-          function (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(function (jwk) {
-            resolve({
-              jwk: jwk,
-              algorithm: key.algorithm,
-              usages: key.usages
-            });
-          });
-        });
+      test: function test(e) {
+        return "CryptoKey" === toStringTag(e) && e.extractable;
       },
-      revive: function revive(_ref) {
-        var jwk = _ref.jwk,
-            algorithm = _ref.algorithm,
-            usages = _ref.usages;
-        return crypto.subtle.importKey('jwk', jwk, algorithm, true, usages);
-      }
-    }
-  };
+      replaceAsync: function replaceAsync(t) {
+        return new e( /*#__PURE__*/function () {
+          var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(e, r) {
+            var n;
+            return regeneratorRuntime.wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    _context.prev = 0;
+                    _context.next = 3;
+                    return crypto.subtle.exportKey("jwk", t);
+
+                  case 3:
+                    n = _context.sent;
+                    _context.next = 9;
+                    break;
 
-  var dataview = {
-    dataview: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'DataView';
-      },
-      replace: function replace(_ref, stateObj) {
-        var buffer = _ref.buffer,
-            byteOffset = _ref.byteOffset,
-            byteLength = _ref.byteLength;
+                  case 6:
+                    _context.prev = 6;
+                    _context.t0 = _context["catch"](0);
+                    return _context.abrupt("return", void r(_context.t0));
 
-        if (!stateObj.buffers) {
-          stateObj.buffers = [];
-        }
+                  case 9:
+                    e({
+                      jwk: n,
+                      algorithm: t.algorithm,
+                      usages: t.usages
+                    });
 
-        var index = stateObj.buffers.indexOf(buffer);
+                  case 10:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee, null, [[0, 6]]);
+          }));
 
-        if (index > -1) {
-          return {
-            index: index,
-            byteOffset: byteOffset,
-            byteLength: byteLength
+          return function (_x, _x2) {
+            return _ref3.apply(this, arguments);
           };
-        }
-
-        stateObj.buffers.push(buffer);
-        return {
-          encoded: encode$1(buffer),
-          byteOffset: byteOffset,
-          byteLength: byteLength
-        };
+        }());
       },
-      revive: function revive(b64Obj, stateObj) {
-        if (!stateObj.buffers) {
-          stateObj.buffers = [];
-        }
-
-        var byteOffset = b64Obj.byteOffset,
-            byteLength = b64Obj.byteLength,
-            encoded = b64Obj.encoded,
-            index = b64Obj.index;
-        var buffer;
-
-        if ('index' in b64Obj) {
-          buffer = stateObj.buffers[index];
-        } else {
-          buffer = decode$1(encoded);
-          stateObj.buffers.push(buffer);
-        }
-
-        return new DataView(buffer, byteOffset, byteLength);
+      revive: function revive(_ref4) {
+        var e = _ref4.jwk,
+            t = _ref4.algorithm,
+            r = _ref4.usages;
+        return crypto.subtle.importKey("jwk", e, t, !0, r);
       }
     }
-  };
-
-  var date = {
+  },
+      A = {
+    dataview: {
+      test: function test(e) {
+        return "DataView" === toStringTag(e);
+      },
+      replace: function replace(_ref5, n) {
+        var e = _ref5.buffer,
+            t = _ref5.byteOffset,
+            r = _ref5.byteLength;
+        n.buffers || (n.buffers = []);
+        var a = n.buffers.indexOf(e);
+        return a > -1 ? {
+          index: a,
+          byteOffset: t,
+          byteLength: r
+        } : (n.buffers.push(e), {
+          encoded: v(e),
+          byteOffset: t,
+          byteLength: r
+        });
+      },
+      revive: function revive(e, t) {
+        t.buffers || (t.buffers = []);
+        var r = e.byteOffset,
+            n = e.byteLength,
+            a = e.encoded,
+            o = e.index;
+        var i;
+        return "index" in e ? i = t.buffers[o] : (i = b(a), t.buffers.push(i)), new DataView(i, r, n);
+      }
+    }
+  },
+      j = {
     date: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'Date';
+      test: function test(e) {
+        return "Date" === toStringTag(e);
       },
-      replace: function replace(dt) {
-        var time = dt.getTime();
-
-        if (Number.isNaN(time)) {
-          return 'NaN';
-        }
-
-        return time;
+      replace: function replace(e) {
+        var t = e.getTime();
+        return Number.isNaN(t) ? "NaN" : t;
       },
-      revive: function revive(time) {
-        if (time === 'NaN') {
-          return new Date(Number.NaN);
-        }
-
-        return new Date(time);
-      }
-    }
-  };
-
-  var error = {
-    error: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'Error';
+      revive: function revive(e) {
+        return "NaN" === e ? new Date(Number.NaN) : new Date(e);
+      }
+    }
+  },
+      I = "undefined" == typeof self ? global : self,
+      P = {};
+  ["TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "InternalError"].forEach(function (e) {
+    var t = I[e];
+    t && (P[e.toLowerCase()] = {
+      test: function test(e) {
+        return hasConstructorOf(e, t);
       },
-      replace: function replace(_ref) {
-        var name = _ref.name,
-            message = _ref.message;
-        return {
-          name: name,
-          message: message
-        };
+      replace: function replace(e) {
+        return e.message;
       },
-      revive: function revive(_ref2) {
-        var name = _ref2.name,
-            message = _ref2.message;
-        var e = new Error(message);
-        e.name = name;
-        return e;
+      revive: function revive(e) {
+        return new t(e);
       }
-    }
-  }; // See also errors.js that may be registered after having registered this type.
-
-  /* istanbul ignore next */
-
-  var _global$2 = typeof self === 'undefined' ? global$1 : self;
-
-  var errors = {}; // Comprises all built-in errors.
-
-  ['TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'EvalError', 'URIError', 'InternalError' // non-standard
-  ].forEach(function (errName) {
-    var Cnstrctr = _global$2[errName];
-
-    if (Cnstrctr) {
-      errors[errName.toLowerCase()] = {
-        test: function test(x) {
-          return Typeson.hasConstructorOf(x, Cnstrctr);
-        },
-        replace: function replace(e) {
-          return e.message;
-        },
-        revive: function revive(message) {
-          return new Cnstrctr(message);
-        }
-      };
-    }
+    });
   });
-
-  /* globals XMLHttpRequest, File, FileReader */
-  var file = {
+  var N = {
     file: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'File';
+      test: function test(e) {
+        return "File" === toStringTag(e);
       },
-      replace: function replace(f) {
-        // Sync
-        var req = new XMLHttpRequest();
-        req.overrideMimeType('text/plain; charset=x-user-defined');
-        req.open('GET', URL.createObjectURL(f), false); // Sync
-
-        req.send(); // Seems not feasible to accurately simulate
-
-        /* istanbul ignore next */
-
-        if (req.status !== 200 && req.status !== 0) {
-          throw new Error('Bad File access: ' + req.status);
-        }
-
+      replace: function replace(e) {
+        var t = new XMLHttpRequest();
+        if (t.overrideMimeType("text/plain; charset=x-user-defined"), t.open("GET", URL.createObjectURL(e), !1), t.send(), 200 !== t.status && 0 !== t.status) throw new Error("Bad File access: " + t.status);
         return {
-          type: f.type,
-          stringContents: req.responseText,
-          name: f.name,
-          lastModified: f.lastModified
+          type: e.type,
+          stringContents: t.responseText,
+          name: e.name,
+          lastModified: e.lastModified
         };
       },
-      revive: function revive(_ref) {
-        var name = _ref.name,
-            type = _ref.type,
-            stringContents = _ref.stringContents,
-            lastModified = _ref.lastModified;
-        return new File([string2arraybuffer(stringContents)], name, {
-          type: type,
-          lastModified: lastModified
+      revive: function revive(_ref8) {
+        var e = _ref8.name,
+            t = _ref8.type,
+            r = _ref8.stringContents,
+            n = _ref8.lastModified;
+        return new File([string2arraybuffer(r)], e, {
+          type: t,
+          lastModified: n
         });
       },
-      replaceAsync: function replaceAsync(f) {
-        return new Typeson.Promise(function (resolve, reject) {
-          /*
-          if (f.isClosed) { // On MDN, but not in https://w3c.github.io/FileAPI/#dfn-Blob
-              reject(new Error('The File is closed'));
-              return;
-          }
-          */
-          var reader = new FileReader();
-          reader.addEventListener('load', function () {
-            resolve({
-              type: f.type,
-              stringContents: reader.result,
-              name: f.name,
-              lastModified: f.lastModified
+      replaceAsync: function replaceAsync(t) {
+        return new e(function (e, r) {
+          var n = new FileReader();
+          n.addEventListener("load", function () {
+            e({
+              type: t.type,
+              stringContents: n.result,
+              name: t.name,
+              lastModified: t.lastModified
             });
-          }); // Seems not feasible to accurately simulate
-
-          /* istanbul ignore next */
-
-          reader.addEventListener('error', function () {
-            reject(reader.error);
-          });
-          reader.readAsBinaryString(f);
+          }), n.addEventListener("error", function () {
+            r(n.error);
+          }), n.readAsBinaryString(t);
         });
       }
     }
-  };
-
-  var filelist = {
-    file: file.file,
+  },
+      C = {
+    file: N.file,
     filelist: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'FileList';
+      test: function test(e) {
+        return "FileList" === toStringTag(e);
       },
-      replace: function replace(fl) {
-        var arr = [];
+      replace: function replace(e) {
+        var t = [];
 
-        for (var i = 0; i < fl.length; i++) {
-          arr[i] = fl.item(i);
+        for (var _r2 = 0; _r2 < e.length; _r2++) {
+          t[_r2] = e.item(_r2);
         }
 
-        return arr;
+        return t;
       },
-      revive: function revive(o) {
-        /**
-         * `FileList` polyfill.
-         */
+      revive: function revive(e) {
         var FileList = /*#__PURE__*/function (_Symbol$toStringTag) {
-          /**
-           * Set private properties and length.
-           */
           function FileList() {
-            _classCallCheck(this, FileList);
+            _classCallCheck$1(this, FileList);
 
-            // eslint-disable-next-line prefer-rest-params
-            this._files = arguments[0];
-            this.length = this._files.length;
+            this._files = arguments[0], this.length = this._files.length;
           }
-          /**
-           * @param {Integer} index
-           * @returns {File}
-           */
-
 
-          _createClass(FileList, [{
+          _createClass$1(FileList, [{
             key: "item",
-            value: function item(index) {
-              return this._files[index];
+            value: function item(e) {
+              return this._files[e];
             }
-            /* eslint-disable class-methods-use-this */
-
-            /**
-             * @returns {"FileList"}
-             */
-
           }, {
             key: _Symbol$toStringTag,
             get: function get() {
-              /* eslint-enable class-methods-use-this */
-              return 'FileList';
+              return "FileList";
             }
           }]);
 
           return FileList;
         }(Symbol.toStringTag);
 
-        return new FileList(o);
+        return new FileList(e);
       }
     }
-  };
-
-  /* globals createImageBitmap */
-  var imagebitmap = {
+  },
+      E = {
     imagebitmap: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'ImageBitmap' || // In Node, our polyfill sets the dataset on a canvas
-        //  element as JSDom no longer allows overriding toStringTag
-        x && x.dataset && x.dataset.toStringTag === 'ImageBitmap';
+      test: function test(e) {
+        return "ImageBitmap" === toStringTag(e) || e && e.dataset && "ImageBitmap" === e.dataset.toStringTag;
       },
-      replace: function replace(bm) {
-        var canvas = document.createElement('canvas');
-        var ctx = canvas.getContext('2d');
-        ctx.drawImage(bm, 0, 0); // Although `width` and `height` are part of `ImageBitMap`,
-        //   these will be auto-created for us when reviving with the
-        //   data URL (and they are not settable even if they weren't)
-        // return {
-        //   width: bm.width, height: bm.height, dataURL: canvas.toDataURL()
-        // };
-
-        return canvas.toDataURL();
+      replace: function replace(e) {
+        var t = document.createElement("canvas");
+        return t.getContext("2d").drawImage(e, 0, 0), t.toDataURL();
       },
-      revive: function revive(o) {
-        /*
-        var req = new XMLHttpRequest();
-        req.open('GET', o, false); // Sync
-        if (req.status !== 200 && req.status !== 0) {
-          throw new Error('Bad ImageBitmap access: ' + req.status);
-        }
-        req.send();
-        return req.responseText;
-        */
-        var canvas = document.createElement('canvas');
-        var ctx = canvas.getContext('2d');
-        var img = document.createElement('img'); // The onload is needed by some browsers per http://stackoverflow.com/a/4776378/271577
-
-        img.addEventListener('load', function () {
-          ctx.drawImage(img, 0, 0);
-        });
-        img.src = o; // Works in contexts allowing an `ImageBitmap` (We might use
-        //   `OffscreenCanvas.transferToBitmap` when supported)
-
-        return canvas;
+      revive: function revive(e) {
+        var t = document.createElement("canvas"),
+            r = t.getContext("2d"),
+            n = document.createElement("img");
+        return n.addEventListener("load", function () {
+          r.drawImage(n, 0, 0);
+        }), n.src = e, t;
       },
-      reviveAsync: function reviveAsync(o) {
-        var canvas = document.createElement('canvas');
-        var ctx = canvas.getContext('2d');
-        var img = document.createElement('img'); // The onload is needed by some browsers per http://stackoverflow.com/a/4776378/271577
-
-        img.addEventListener('load', function () {
-          ctx.drawImage(img, 0, 0);
-        });
-        img.src = o; // o.dataURL;
-
-        return createImageBitmap(canvas); // Returns a promise
+      reviveAsync: function reviveAsync(e) {
+        var t = document.createElement("canvas"),
+            r = t.getContext("2d"),
+            n = document.createElement("img");
+        return n.addEventListener("load", function () {
+          r.drawImage(n, 0, 0);
+        }), n.src = e, createImageBitmap(t);
       }
     }
-  };
-
-  var imagedata = {
+  },
+      x = {
     imagedata: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'ImageData';
+      test: function test(e) {
+        return "ImageData" === toStringTag(e);
       },
-      replace: function replace(d) {
+      replace: function replace(e) {
         return {
-          // Ensure `length` gets preserved for revival
-          array: _toConsumableArray(d.data),
-          width: d.width,
-          height: d.height
+          array: _toConsumableArray(e.data),
+          width: e.width,
+          height: e.height
         };
       },
-      revive: function revive(o) {
-        return new ImageData(new Uint8ClampedArray(o.array), o.width, o.height);
+      revive: function revive(e) {
+        return new ImageData(new Uint8ClampedArray(e.array), e.width, e.height);
       }
     }
-  };
-
-  var infinity = {
+  },
+      k = {
     infinity: {
-      test: function test(x) {
-        return x === Number.POSITIVE_INFINITY;
+      test: function test(e) {
+        return e === Number.POSITIVE_INFINITY;
       },
-      replace: function replace(n) {
-        return 'Infinity';
+      replace: function replace(e) {
+        return "Infinity";
       },
-      revive: function revive(s) {
+      revive: function revive(e) {
         return Number.POSITIVE_INFINITY;
       }
     }
-  };
-
-  var IntlCollator = {
-    test: function test(x) {
-      return Typeson.hasConstructorOf(x, Intl.Collator);
-    },
-    replace: function replace(c) {
-      return c.resolvedOptions();
-    },
-    revive: function revive(options) {
-      return new Intl.Collator(options.locale, options);
-    }
-  };
-  var IntlDateTimeFormat = {
-    test: function test(x) {
-      return Typeson.hasConstructorOf(x, Intl.DateTimeFormat);
+  },
+      B = {
+    test: function test(e) {
+      return hasConstructorOf(e, Intl.Collator);
     },
-    replace: function replace(dtf) {
-      return dtf.resolvedOptions();
-    },
-    revive: function revive(options) {
-      return new Intl.DateTimeFormat(options.locale, options);
-    }
-  };
-  var IntlNumberFormat = {
-    test: function test(x) {
-      return Typeson.hasConstructorOf(x, Intl.NumberFormat);
+    replace: function replace(e) {
+      return e.resolvedOptions();
     },
-    replace: function replace(nf) {
-      return nf.resolvedOptions();
+    revive: function revive(e) {
+      return new Intl.Collator(e.locale, e);
+    }
+  },
+      U = {
+    IntlCollator: B,
+    IntlDateTimeFormat: {
+      test: function test(e) {
+        return hasConstructorOf(e, Intl.DateTimeFormat);
+      },
+      replace: function replace(e) {
+        return e.resolvedOptions();
+      },
+      revive: function revive(e) {
+        return new Intl.DateTimeFormat(e.locale, e);
+      }
     },
-    revive: function revive(options) {
-      return new Intl.NumberFormat(options.locale, options);
+    IntlNumberFormat: {
+      test: function test(e) {
+        return hasConstructorOf(e, Intl.NumberFormat);
+      },
+      replace: function replace(e) {
+        return e.resolvedOptions();
+      },
+      revive: function revive(e) {
+        return new Intl.NumberFormat(e.locale, e);
+      }
     }
-  };
-  var intlTypes = {
-    IntlCollator: IntlCollator,
-    IntlDateTimeFormat: IntlDateTimeFormat,
-    IntlNumberFormat: IntlNumberFormat
-  };
-
-  var map = {
+  },
+      K = {
     map: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'Map';
+      test: function test(e) {
+        return "Map" === toStringTag(e);
       },
-      replace: function replace(mp) {
-        return _toConsumableArray(mp.entries());
+      replace: function replace(e) {
+        return _toConsumableArray(e.entries());
       },
-      revive: function revive(entries) {
-        return new Map(entries);
+      revive: function revive(e) {
+        return new Map(e);
       }
     }
-  };
-
-  var nan = {
+  },
+      L = {
     nan: {
-      test: function test(x) {
-        return Number.isNaN(x);
+      test: function test(e) {
+        return Number.isNaN(e);
       },
-      replace: function replace(n) {
-        return 'NaN';
+      replace: function replace(e) {
+        return "NaN";
       },
-      revive: function revive(s) {
+      revive: function revive(e) {
         return Number.NaN;
       }
     }
-  };
-
-  var negativeInfinity = {
+  },
+      F = {
     negativeInfinity: {
-      test: function test(x) {
-        return x === Number.NEGATIVE_INFINITY;
+      test: function test(e) {
+        return e === Number.NEGATIVE_INFINITY;
       },
-      replace: function replace(n) {
-        return '-Infinity';
+      replace: function replace(e) {
+        return "-Infinity";
       },
-      revive: function revive(s) {
+      revive: function revive(e) {
         return Number.NEGATIVE_INFINITY;
       }
     }
-  };
-
-  var nonbuiltinIgnore = {
-    nonbuiltinIgnore: {
-      test: function test(x) {
-        return x && _typeof$1(x) === 'object' && !Array.isArray(x) && !['Object', // `Proxy` and `Reflect`, two other built-in objects, will also
-        //   have a `toStringTag` of `Object`; we don't want built-in
-        //   function objects, however
-        'Boolean', 'Number', 'String', 'Error', 'RegExp', 'Math', 'Date', 'Map', 'Set', 'JSON', 'ArrayBuffer', 'SharedArrayBuffer', 'DataView', 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array', 'Promise', 'String Iterator', 'Array Iterator', 'Map Iterator', 'Set Iterator', 'WeakMap', 'WeakSet', 'Atomics', 'Module'].includes(Typeson.toStringTag(x));
-      },
-      replace: function replace(rexp) {// Not in use
-      }
-    }
-  };
-
-  var primitiveObjects = {
-    // String Object (not primitive string which need no type spec)
+  },
+      M = {
     StringObject: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'String' && _typeof$1(x) === 'object';
+      test: function test(e) {
+        return "String" === toStringTag(e) && "object" == _typeof$2(e);
       },
-      replace: function replace(s) {
-        return String(s);
+      replace: function replace(e) {
+        return String(e);
       },
-      // convert to primitive string
-      revive: function revive(s) {
-        return new String(s);
-      } // Revive to an objectified string
-
+      revive: function revive(e) {
+        return new String(e);
+      }
     },
-    // Boolean Object (not primitive boolean which need no type spec)
     BooleanObject: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'Boolean' && _typeof$1(x) === 'object';
+      test: function test(e) {
+        return "Boolean" === toStringTag(e) && "object" == _typeof$2(e);
       },
-      replace: function replace(b) {
-        return Boolean(b);
+      replace: function replace(e) {
+        return Boolean(e);
       },
-      // convert to primitive boolean
-      revive: function revive(b) {
-        // Revive to an objectified Boolean
-        return new Boolean(b);
+      revive: function revive(e) {
+        return new Boolean(e);
       }
     },
-    // Number Object (not primitive number which need no type spec)
     NumberObject: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'Number' && _typeof$1(x) === 'object';
+      test: function test(e) {
+        return "Number" === toStringTag(e) && "object" == _typeof$2(e);
       },
-      replace: function replace(n) {
-        return Number(n);
+      replace: function replace(e) {
+        return Number(e);
       },
-      // convert to primitive number
-      revive: function revive(n) {
-        return new Number(n);
-      } // Revive to an objectified number
-
+      revive: function revive(e) {
+        return new Number(e);
+      }
     }
-  };
-
-  var regexp = {
+  },
+      $ = {
     regexp: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'RegExp';
+      test: function test(e) {
+        return "RegExp" === toStringTag(e);
       },
-      replace: function replace(rexp) {
+      replace: function replace(e) {
         return {
-          source: rexp.source,
-          flags: (rexp.global ? 'g' : '') + (rexp.ignoreCase ? 'i' : '') + (rexp.multiline ? 'm' : '') + (rexp.sticky ? 'y' : '') + (rexp.unicode ? 'u' : '')
+          source: e.source,
+          flags: (e.global ? "g" : "") + (e.ignoreCase ? "i" : "") + (e.multiline ? "m" : "") + (e.sticky ? "y" : "") + (e.unicode ? "u" : "")
         };
       },
-      revive: function revive(_ref) {
-        var source = _ref.source,
-            flags = _ref.flags;
-        return new RegExp(source, flags);
-      }
-    }
-  };
-
-  var resurrectableObjectsByUUID = {};
-  var resurrectable = {
-    resurrectable: {
-      test: function test(x) {
-        return x && !Array.isArray(x) && ['object', 'function', 'symbol'].includes(_typeof$1(x));
-      },
-      replace: function replace(rsrrctble) {
-        var uuid = generateUUID();
-        resurrectableObjectsByUUID[uuid] = rsrrctble;
-        return uuid;
-      },
-      revive: function revive(serializedResurrectable) {
-        return resurrectableObjectsByUUID[serializedResurrectable];
+      revive: function revive(_ref9) {
+        var e = _ref9.source,
+            t = _ref9.flags;
+        return new RegExp(e, t);
       }
     }
-  };
-
-  var set = {
+  },
+      Y = {
     set: {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === 'Set';
+      test: function test(e) {
+        return "Set" === toStringTag(e);
       },
-      replace: function replace(st) {
-        return _toConsumableArray(st.values());
+      replace: function replace(e) {
+        return _toConsumableArray(e.values());
       },
-      revive: function revive(values) {
-        return new Set(values);
-      }
-    }
-  };
-
-  /* istanbul ignore next */
-
-  var _global$1 = typeof self === 'undefined' ? global$1 : self; // Support all kinds of typed arrays (views of ArrayBuffers)
-
-
-  var typedArraysSocketIO = {};
-  ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'].forEach(function (typeName) {
-    var arrType = typeName;
-    var TypedArray = _global$1[typeName];
-    /* istanbul ignore if */
-
-    if (!TypedArray) {
-      return;
-    }
-
-    typedArraysSocketIO[typeName.toLowerCase()] = {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === arrType;
+      revive: function revive(e) {
+        return new Set(e);
+      }
+    }
+  },
+      q = "undefined" == typeof self ? global : self,
+      W = {};
+  ["Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array"].forEach(function (e) {
+    var t = e,
+        r = q[e];
+    r && (W[e.toLowerCase()] = {
+      test: function test(e) {
+        return toStringTag(e) === t;
       },
-      replace: function replace(a) {
-        return (a.byteOffset === 0 && a.byteLength === a.buffer.byteLength ? a // socket.io supports streaming ArrayBuffers.
-        // If we have a typed array representing a portion
-        //   of the buffer, we need to clone
-        //   the buffer before leaving it to socket.io.
-        : a.slice(0)).buffer;
+      replace: function replace(e) {
+        return (0 === e.byteOffset && e.byteLength === e.buffer.byteLength ? e : e.slice(0)).buffer;
       },
-      revive: function revive(buf) {
-        // One may configure socket.io to revive binary data as
-        //    Buffer or Blob.
-        // We should therefore not rely on that the instance we
-        //   get here is an ArrayBuffer
-        // If not, let's assume user wants to receive it as
-        //   configured with socket.io.
-        return Typeson.toStringTag(buf) === 'ArrayBuffer' ? new TypedArray(buf) : buf;
+      revive: function revive(e) {
+        return "ArrayBuffer" === toStringTag(e) ? new r(e) : e;
       }
-    };
+    });
   });
-
-  /* istanbul ignore next */
-
-  var _global = typeof self === 'undefined' ? global$1 : self;
-
-  var typedArrays = {};
-  ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'].forEach(function (typeName) {
-    var arrType = typeName;
-    var TypedArray = _global[arrType];
-    /* istanbul ignore if */
-
-    if (!TypedArray) {
-      return;
-    }
-
-    typedArrays[typeName.toLowerCase()] = {
-      test: function test(x) {
-        return Typeson.toStringTag(x) === arrType;
+  var G = "undefined" == typeof self ? global : self,
+      H = {};
+  ["Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array"].forEach(function (e) {
+    var t = e,
+        r = G[t];
+    r && (H[e.toLowerCase()] = {
+      test: function test(e) {
+        return toStringTag(e) === t;
       },
-      replace: function replace(_ref, stateObj) {
-        var buffer = _ref.buffer,
-            byteOffset = _ref.byteOffset,
-            l = _ref.length;
-
-        if (!stateObj.buffers) {
-          stateObj.buffers = [];
-        }
-
-        var index = stateObj.buffers.indexOf(buffer);
-
-        if (index > -1) {
-          return {
-            index: index,
-            byteOffset: byteOffset,
-            length: l
-          };
-        }
-
-        stateObj.buffers.push(buffer);
-        return {
-          encoded: encode$1(buffer),
-          byteOffset: byteOffset,
-          length: l
-        };
+      replace: function replace(_ref10, n) {
+        var e = _ref10.buffer,
+            t = _ref10.byteOffset,
+            r = _ref10.length;
+        n.buffers || (n.buffers = []);
+        var a = n.buffers.indexOf(e);
+        return a > -1 ? {
+          index: a,
+          byteOffset: t,
+          length: r
+        } : (n.buffers.push(e), {
+          encoded: v(e),
+          byteOffset: t,
+          length: r
+        });
       },
-      revive: function revive(b64Obj, stateObj) {
-        if (!stateObj.buffers) {
-          stateObj.buffers = [];
-        }
-
-        var byteOffset = b64Obj.byteOffset,
-            len = b64Obj.length,
-            encoded = b64Obj.encoded,
-            index = b64Obj.index;
-        var buffer;
-
-        if ('index' in b64Obj) {
-          buffer = stateObj.buffers[index];
-        } else {
-          buffer = decode$1(encoded);
-          stateObj.buffers.push(buffer);
-        }
-
-        return new TypedArray(buffer, byteOffset, len);
+      revive: function revive(e, t) {
+        t.buffers || (t.buffers = []);
+        var n = e.byteOffset,
+            a = e.length,
+            o = e.encoded,
+            i = e.index;
+        var s;
+        return "index" in e ? s = t.buffers[i] : (s = b(o), t.buffers.push(s)), new r(s, n, a);
       }
-    };
+    });
   });
-
-  // This does not preserve `undefined` in sparse arrays; see the `undefined`
-  var undef$1 = {
+  var X = {
     undef: {
-      test: function test(x, stateObj) {
-        return typeof x === 'undefined' && (stateObj.ownKeys || !('ownKeys' in stateObj));
+      test: function test(e, t) {
+        return void 0 === e && (t.ownKeys || !("ownKeys" in t));
       },
-      replace: function replace(n) {
+      replace: function replace(e) {
         return 0;
       },
-      revive: function revive(s) {
-        // Will add `undefined` (returning `undefined` would instead
-        //   avoid explicitly setting)
-        return new Typeson.Undefined();
+      revive: function revive(e) {
+        return new l();
       }
     }
-  };
-
-  var userObject = {
+  },
+      z = {
     userObject: {
-      test: function test(x, stateObj) {
-        return Typeson.isUserObject(x);
+      test: function test(e, t) {
+        return isUserObject(e);
       },
-      replace: function replace(n) {
-        return _objectSpread2({}, n);
+      replace: function replace(e) {
+        return _objectSpread2$1({}, e);
       },
-      revive: function revive(s) {
-        return s;
+      revive: function revive(e) {
+        return e;
       }
     }
-  };
-
-  var arrayNonindexKeys = [{
+  },
+      Q = [{
     arrayNonindexKeys: {
-      testPlainObjects: true,
-      test: function test(x, stateObj) {
-        if (Array.isArray(x)) {
-          if ( // By avoiding serializing arrays into objects which
-          //  have only positive-integer keys, we reduce
-          //  size and improve revival performance; arrays with
-          //  non-index keys will be larger however
-          Object.keys(x).some(function (k) {
-            //  No need to check for `isNaN` or
-            //   `isNaN(Number.parseInt())` as `NaN` will be
-            //   treated as a string.
-            //  No need to do check as
-            //   `Number.parseInt(Number())` since scientific
-            //   notation will be pre-resolved if a number
-            //   was given, and it will otherwise be a string
-            return String(Number.parseInt(k)) !== k;
-          })) {
-            stateObj.iterateIn = 'object';
-            stateObj.addLength = true;
-          }
-
-          return true;
-        }
-
-        return false;
+      testPlainObjects: !0,
+      test: function test(e, t) {
+        return !!Array.isArray(e) && (Object.keys(e).some(function (e) {
+          return String(Number.parseInt(e)) !== e;
+        }) && (t.iterateIn = "object", t.addLength = !0), !0);
       },
-      replace: function replace(a, stateObj) {
-        // Catch sparse undefined
-        stateObj.iterateUnsetNumeric = true;
-        return a;
+      replace: function replace(e, t) {
+        return t.iterateUnsetNumeric = !0, e;
       },
-      revive: function revive(o) {
-        if (Array.isArray(o)) {
-          return o;
-        }
-
-        var arr = []; // No map here as may be a sparse array (including
-        //   with `length` set)
-        // Todo: Reenable when Node `engines` >= 7
-        // Object.entries(o).forEach(([key, val]) => {
-
-        Object.keys(o).forEach(function (key) {
-          var val = o[key];
-          arr[key] = val;
-        });
-        return arr;
+      revive: function revive(e) {
+        if (Array.isArray(e)) return e;
+        var t = [];
+        return Object.keys(e).forEach(function (r) {
+          var n = e[r];
+          t[r] = n;
+        }), t;
       }
     }
   }, {
     sparseUndefined: {
-      test: function test(x, stateObj) {
-        return typeof x === 'undefined' && stateObj.ownKeys === false;
+      test: function test(e, t) {
+        return void 0 === e && !1 === t.ownKeys;
       },
-      replace: function replace(n) {
+      replace: function replace(e) {
         return 0;
       },
-      revive: function revive(s) {
-        return undefined;
-      } // Will avoid adding anything
-
-    }
-  }];
-
-  var specialNumbers = [nan, infinity, negativeInfinity];
-
-  /* This preset includes types that are built-in into the JavaScript
-      language itself, this should work universally.
-
-    Types that were added in ES6 or beyond will be checked before inclusion
-     so that this module can be consumed by both ES5 and ES6 environments.
-
-    Some types cannot be encapsulated because their inner state is private:
-      `WeakMap`, `WeakSet`.
-
-    The Function type is not included because their closures would not be
-      serialized, so a revived Function that uses closures would not behave
-      as expected.
-
-    Symbols are similarly not included.
-  */
-  var expObj$1 = [undef$1, // ES5
-  arrayNonindexKeys, primitiveObjects, specialNumbers, date, error, errors, regexp].concat( // ES2015 (ES6)
-
-  /* istanbul ignore next */
-  typeof Map === 'function' ? map : [],
-  /* istanbul ignore next */
-  typeof Set === 'function' ? set : [],
-  /* istanbul ignore next */
-  typeof ArrayBuffer === 'function' ? arraybuffer : [],
-  /* istanbul ignore next */
-  typeof Uint8Array === 'function' ? typedArrays : [],
-  /* istanbul ignore next */
-  typeof DataView === 'function' ? dataview : [],
-  /* istanbul ignore next */
-  typeof Intl !== 'undefined' ? intlTypes : [],
-  /* istanbul ignore next */
-  typeof BigInt !== 'undefined' ? [bigint, bigintObject] : []);
-
-  /*
-  When communicating via `postMessage()` (`Worker.postMessage()` or
-  `window.postMessage()`), the browser will use a similar algorithm as Typeson
-  does to encapsulate and revive all items in the structure (aka the structured
-  clone algorithm). This algorithm supports all built-in types as well as many
-  DOM types. Therefore, only types that are not included in the structured clone
-  algorithm need to be registered, which is:
-
-  * Error
-  * Specific Errors like SyntaxError, TypeError, etc.
-  * Any custom type you want to send across window- or worker boundraries
-
-  This preset will only include the Error types and you can register your
-  custom types after having registered these.
-  */
-  var postmessage = [error, errors];
-
-  var socketio = [expObj$1, // Leave ArrayBuffer as is, and let socket.io stream it instead.
-  {
-    arraybuffer: null
-  }, // Encapsulate TypedArrays in ArrayBuffers instead of base64 strings.
-  typedArraysSocketIO];
-
-  var sparseUndefined = [{
-    sparseArrays: {
-      testPlainObjects: true,
-      test: function test(x) {
-        return Array.isArray(x);
-      },
-      replace: function replace(a, stateObj) {
-        stateObj.iterateUnsetNumeric = true;
-        return a;
-      }
+      revive: function revive(e) {}
     }
-  }, {
-    sparseUndefined: {
-      test: function test(x, stateObj) {
-        return typeof x === 'undefined' && stateObj.ownKeys === false;
-      },
-      replace: function replace(n) {
-        return 0;
-      },
-      revive: function revive(s) {
-        return undefined;
-      } // Will avoid adding anything
-
-    }
-  }];
-
-  /* This preset includes types for the Structured Cloning Algorithm. */
-  var expObj = [// Todo: Might also register synchronous `ImageBitmap` and
-  //    `Blob`/`File`/`FileList`?
-  // ES5
-  userObject, // Processed last (non-builtin)
-  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 : [],
-  /* istanbul ignore next */
-  typeof Set === 'function' ? set : [],
-  /* istanbul ignore next */
-  typeof ArrayBuffer === 'function' ? arraybuffer : [],
-  /* istanbul ignore next */
-  typeof Uint8Array === 'function' ? typedArrays : [],
-  /* istanbul ignore next */
-  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] : []);
-
-  var structuredCloningThrowing = expObj.concat({
+  }],
+      Z = [L, k, F],
+      ae = [z, X, Q, M, Z, j, $, x, E, N, C, O].concat("function" == typeof Map ? K : [], "function" == typeof Set ? Y : [], "function" == typeof ArrayBuffer ? h : [], "function" == typeof Uint8Array ? H : [], "function" == typeof DataView ? A : [], "undefined" != typeof Intl ? U : [], "undefined" != typeof crypto ? w : [], "undefined" != typeof BigInt ? [m, g] : []);
+  var oe = ae.concat({
     checkDataCloneException: {
-      test: function test(val) {
-        // Should also throw with:
-        // 1. `IsDetachedBuffer` (a process not called within the
-        //      ECMAScript spec)
-        // 2. `IsCallable` (covered by `typeof === 'function'` or a
-        //       function's `toStringTag`)
-        // 3. internal slots besides [[Prototype]] or [[Extensible]] (e.g.,
-        //        [[PromiseState]] or [[WeakMapData]])
-        // 4. exotic object (e.g., `Proxy`) (unless an `%ObjectPrototype%`
-        //      intrinsic object) (which does not have default
-        //      behavior for one or more of the essential internal methods
-        //      that are limited to the following for non-function objects
-        //      (we auto-exclude functions):
-        //      [[GetPrototypeOf]],[[SetPrototypeOf]],[[IsExtensible]],
-        //      [[PreventExtensions]],[[GetOwnProperty]],
-        //      [[DefineOwnProperty]],[[HasProperty]],
-        //      [[Get]],[[Set]],[[Delete]],[[OwnPropertyKeys]]);
-        //      except for the standard, built-in exotic objects, we'd need
-        //      to know whether these methods had distinct behaviors
-        // Note: There is no apparent way for us to detect a `Proxy` and
-        //      reject (Chrome at least is not rejecting anyways)
-        var stringTag = {}.toString.call(val).slice(8, -1);
-
-        if ([// Symbol's `toStringTag` is only "Symbol" for its initial
-        //   value, so we check `typeof`
-        'symbol', // All functions including bound function exotic objects
-        'function'].includes(_typeof$1(val)) || [// A non-array exotic object
-        'Arguments', // A non-array exotic object
-        'Module', // `Error` and other errors have the [[ErrorData]] internal
-        //    slot and give "Error"
-        'Error', // Promise instances have an extra slot ([[PromiseState]])
-        //    but not throwing in Chrome `postMessage`
-        'Promise', // WeakMap instances have an extra slot ([[WeakMapData]])
-        //    but not throwing in Chrome `postMessage`
-        'WeakMap', // WeakSet instances have an extra slot ([[WeakSetData]])
-        //    but not throwing in Chrome `postMessage`
-        'WeakSet', // HTML-SPECIFIC
-        'Event', // Also in Node `worker_threads` (currently experimental)
-        'MessageChannel'].includes(stringTag) ||
-        /*
-        // isClosed is no longer documented
-        ((stringTag === 'Blob' || stringTag === 'File') &&
-            val.isClosed) ||
-        */
-        val && _typeof$1(val) === 'object' && // Duck-type DOM node objects (non-array exotic?
-        //    objects which cannot be cloned by the SCA)
-        typeof val.nodeType === 'number' && typeof val.insertBefore === 'function') {
-          throw new DOMException('The object cannot be cloned.', 'DataCloneError');
-        }
-
-        return false;
+      test: function test(e) {
+        var t = {}.toString.call(e).slice(8, -1);
+        if (["symbol", "function"].includes(_typeof$2(e)) || ["Arguments", "Module", "Error", "Promise", "WeakMap", "WeakSet", "Event", "MessageChannel"].includes(t) || e && "object" == _typeof$2(e) && "number" == typeof e.nodeType && "function" == typeof e.insertBefore) throw new DOMException("The object cannot be cloned.", "DataCloneError");
+        return !1;
       }
     }
   });
 
-  var undef = [sparseUndefined, undef$1];
-
-  var universal = [expObj$1 // TODO: Add types that are de-facto universal even though not
-  //   built-in into ecmasript standard.
-  ];
-
-  // This file is auto-generated from `build.js`
-  Typeson.types = {
-    arraybuffer: arraybuffer,
-    bigintObject: bigintObject,
-    bigint: bigint,
-    blob: blob,
-    cloneable: cloneable,
-    cryptokey: cryptokey,
-    dataview: dataview,
-    date: date,
-    error: error,
-    errors: errors,
-    file: file,
-    filelist: filelist,
-    imagebitmap: imagebitmap,
-    imagedata: imagedata,
-    infinity: infinity,
-    intlTypes: intlTypes,
-    map: map,
-    nan: nan,
-    negativeInfinity: negativeInfinity,
-    nonbuiltinIgnore: nonbuiltinIgnore,
-    primitiveObjects: primitiveObjects,
-    regexp: regexp,
-    resurrectable: resurrectable,
-    set: set,
-    typedArraysSocketio: typedArraysSocketIO,
-    typedArrays: typedArrays,
-    undef: undef$1,
-    userObject: userObject
-  };
-  Typeson.presets = {
-    arrayNonindexKeys: arrayNonindexKeys,
-    builtin: expObj$1,
-    postmessage: postmessage,
-    socketio: socketio,
-    sparseUndefined: sparseUndefined,
-    specialNumbers: specialNumbers,
-    structuredCloningThrowing: structuredCloningThrowing,
-    structuredCloning: expObj,
-    undef: undef,
-    universal: universal
-  };
-
-  var typeson = new Typeson().register(Typeson.presets.structuredCloningThrowing);
+  var typeson = new u().register(oe);
 
   function register(func) {
-    typeson = new Typeson().register(func(Typeson.presets.structuredCloningThrowing));
+    typeson = new u().register(func(oe));
   } // We are keeping the callback approach for now in case we wish to reexpose
   //   `Blob`, `File`, `FileList` asynchronously (though in such a case, we
   //   should probably refactor as a Promise)
@@ -7686,11 +5954,11 @@
       ret = typeson.stringifySync(obj);
     } catch (err) {
       // SCA in typeson-registry using `DOMException` which is not defined (e.g., in Node)
-      if (Typeson.hasConstructorOf(err, ReferenceError) || // SCA in typeson-registry threw a cloning error and we are in a
+      if (hasConstructorOf(err, ReferenceError) || // SCA in typeson-registry threw a cloning error and we are in a
       //   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)) {
+      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)
@@ -8892,7 +7160,7 @@
       }
 
       Object.entries(paramMap).forEach(function (_ref) {
-        var _ref2 = _slicedToArray(_ref, 2),
+        var _ref2 = _slicedToArray$1(_ref, 2),
             key = _ref2[0],
             stmt = _ref2[1];
 
@@ -8953,7 +7221,7 @@
     var request = me.transaction.__createRequest(me);
 
     var _me$__validateKeyAndV = me.__validateKeyAndValueAndCloneValue(value, key, false),
-        _me$__validateKeyAndV2 = _slicedToArray(_me$__validateKeyAndV, 2),
+        _me$__validateKeyAndV2 = _slicedToArray$1(_me$__validateKeyAndV, 2),
         ky = _me$__validateKeyAndV2[0],
         clonedValue = _me$__validateKeyAndV2[1];
 
@@ -8986,7 +7254,7 @@
     var request = me.transaction.__createRequest(me);
 
     var _me$__validateKeyAndV3 = me.__validateKeyAndValueAndCloneValue(value, key, false),
-        _me$__validateKeyAndV4 = _slicedToArray(_me$__validateKeyAndV3, 2),
+        _me$__validateKeyAndV4 = _slicedToArray$1(_me$__validateKeyAndV3, 2),
         ky = _me$__validateKeyAndV4[0],
         clonedValue = _me$__validateKeyAndV4[1];
 
@@ -9760,7 +8028,7 @@
 
     IDBTransaction.__assertActive(this.__versionTransaction);
 
-    createOptions = _objectSpread2({}, createOptions);
+    createOptions = _objectSpread2$1({}, createOptions);
     var _createOptions = createOptions,
         keyPath = _createOptions.keyPath;
     keyPath = keyPath === undefined ? null : convertToSequenceDOMString(keyPath);
@@ -9965,7 +8233,7 @@
   };
 
   var getOrigin = function getOrigin() {
-    return (typeof location === "undefined" ? "undefined" : _typeof$1(location)) !== 'object' || !location ? 'null' : location.origin;
+    return (typeof location === "undefined" ? "undefined" : _typeof$2(location)) !== 'object' || !location ? 'null' : location.origin;
   };
 
   var hasNullOrigin = function hasNullOrigin() {
@@ -11437,7 +9705,7 @@
 
     if (me.__store.keyPath !== null) {
       var _me$__store$__validat = me.__store.__validateKeyAndValueAndCloneValue(valueToUpdate, undefined, true),
-          _me$__store$__validat2 = _slicedToArray(_me$__store$__validat, 2),
+          _me$__store$__validat2 = _slicedToArray$1(_me$__store$__validat, 2),
           evaluatedKey = _me$__store$__validat2[0],
           clonedValue = _me$__store$__validat2[1];
 
@@ -11536,9 +9804,9 @@
   });
 
   function setConfig(prop, val) {
-    if (prop && _typeof$1(prop) === 'object') {
+    if (prop && _typeof$2(prop) === 'object') {
       Object.entries(prop).forEach(function (_ref) {
-        var _ref2 = _slicedToArray(_ref, 2),
+        var _ref2 = _slicedToArray$1(_ref, 2),
             p = _ref2[0],
             val = _ref2[1];
 
@@ -11563,7 +9831,7 @@
       setConfig(initialConfig);
     }
 
-    var IDB = idb || (typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : typeof global$1 !== 'undefined' ? global$1 : {});
+    var IDB = idb || (typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : typeof global !== 'undefined' ? global : {});
 
     function shim(name, value, propDesc) {
       if (!propDesc || !Object.defineProperty) {
@@ -11666,7 +9934,7 @@
             }
           });
           [['IDBFactory', shimIDBFactory], ['IDBDatabase', IDBDatabase], ['IDBObjectStore', IDBObjectStore], ['IDBIndex', IDBIndex], ['IDBTransaction', IDBTransaction], ['IDBCursor', IDBCursor], ['IDBCursorWithValue', IDBCursorWithValue], ['IDBKeyRange', IDBKeyRange], ['IDBRequest', IDBRequest], ['IDBOpenDBRequest', IDBOpenDBRequest], ['IDBVersionChangeEvent', IDBVersionChangeEvent]].forEach(function (_ref3) {
-            var _ref4 = _slicedToArray(_ref3, 2),
+            var _ref4 = _slicedToArray$1(_ref3, 2),
                 prop = _ref4[0],
                 obj = _ref4[1];