typeson-registry 12.0.0 → 13.0.1

package/dist/index.umd.cjs

@@ -4,7 +4,7 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.TypesonNamespace = {}));
 })(this, (function (exports) { 'use strict';
 
-  function _arrayLikeToArray$1(r, a) {
+  function _arrayLikeToArray(r, a) {
     (null == a || a > r.length) && (a = r.length);
     for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
     return n;
@@ -13,7 +13,7 @@
     if (Array.isArray(r)) return r;
   }
   function _arrayWithoutHoles(r) {
-    if (Array.isArray(r)) return _arrayLikeToArray$1(r);
+    if (Array.isArray(r)) return _arrayLikeToArray(r);
   }
   function asyncGeneratorStep(n, t, e, r, o, a, c) {
     try {
@@ -40,22 +40,22 @@
       });
     };
   }
-  function _classCallCheck$1(a, n) {
+  function _classCallCheck(a, n) {
     if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
   }
   function _defineProperties(e, r) {
     for (var t = 0; t < r.length; t++) {
       var o = r[t];
-      o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey$1(o.key), o);
+      o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
     }
   }
-  function _createClass$1(e, r, t) {
+  function _createClass(e, r, t) {
     return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
       writable: false
     }), e;
   }
-  function _defineProperty$1(e, r, t) {
-    return (r = _toPropertyKey$1(r)) in e ? Object.defineProperty(e, r, {
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
       value: t,
       enumerable: true,
       configurable: true,
@@ -76,7 +76,10 @@
         f = true,
         o = false;
       try {
-        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+        if (i = (t = t.call(r)).next, 0 === l) {
+          if (Object(t) !== t) return;
+          f = !1;
+        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
       } catch (r) {
         o = true, n = r;
       } finally {
@@ -95,7 +98,7 @@
   function _nonIterableSpread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  function ownKeys$1(e, r) {
+  function ownKeys(e, r) {
     var t = Object.keys(e);
     if (Object.getOwnPropertySymbols) {
       var o = Object.getOwnPropertySymbols(e);
@@ -105,12 +108,12 @@
     }
     return t;
   }
-  function _objectSpread2$1(e) {
+  function _objectSpread2(e) {
     for (var r = 1; r < arguments.length; r++) {
       var t = null != arguments[r] ? arguments[r] : {};
-      r % 2 ? ownKeys$1(Object(t), true).forEach(function (r) {
-        _defineProperty$1(e, r, t[r]);
-      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) {
+      r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+        _defineProperty(e, r, t[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
         Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
       });
     }
@@ -224,11 +227,11 @@
       }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
     }, _regeneratorDefine(e, r, n, t);
   }
-  function _slicedToArray$1(r, e) {
-    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray$1(r, e) || _nonIterableRest();
+  function _slicedToArray(r, e) {
+    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
   }
-  function _toConsumableArray$1(r) {
-    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray$1(r) || _nonIterableSpread();
+  function _toConsumableArray(r) {
+    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
   }
   function _toPrimitive(t, r) {
     if ("object" != typeof t || !t) return t;
@@ -240,213 +243,99 @@
     }
     return ("string" === r ? String : Number)(t);
   }
-  function _toPropertyKey$1(t) {
+  function _toPropertyKey(t) {
     var i = _toPrimitive(t, "string");
     return "symbol" == typeof i ? i : i + "";
   }
-  function _typeof$1(o) {
+  function _typeof(o) {
     "@babel/helpers - typeof";
 
-    return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
       return typeof o;
     } : function (o) {
       return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-    }, _typeof$1(o);
+    }, _typeof(o);
   }
-  function _unsupportedIterableToArray$1(r, a) {
+  function _unsupportedIterableToArray(r, a) {
     if (r) {
-      if ("string" == typeof r) return _arrayLikeToArray$1(r, a);
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
       var t = {}.toString.call(r).slice(8, -1);
-      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0;
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
     }
   }
 
-  function _arrayLikeToArray(e, t) {
-    (null == t || t > e.length) && (t = e.length);
-    for (var r = 0, n = Array(t); r < t; r++) n[r] = e[r];
-    return n;
-  }
-  function _classCallCheck(e, t) {
-    if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
-  }
-  function _createClass(e, t, r) {
-    return t && function _defineProperties(e, t) {
-      for (var r = 0; r < t.length; r++) {
-        var n = t[r];
-        n.enumerable = n.enumerable || false, n.configurable = true, "value" in n && (n.writable = true), Object.defineProperty(e, _toPropertyKey(n.key), n);
-      }
-    }(e.prototype, t), Object.defineProperty(e, "prototype", {
-      writable: false
-    }), e;
-  }
-  function _defineProperty(e, t, r) {
-    return (t = _toPropertyKey(t)) in e ? Object.defineProperty(e, t, {
-      value: r,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    }) : e[t] = r, e;
-  }
-  function ownKeys(e, t) {
-    var r = Object.keys(e);
-    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 r;
-  }
-  function _objectSpread2(e) {
-    for (var t = 1; t < arguments.length; t++) {
-      var r = null != arguments[t] ? arguments[t] : {};
-      t % 2 ? ownKeys(Object(r), true).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));
-      });
-    }
-    return e;
-  }
-  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"];
-      if (null != r) {
-        var n,
-          o,
-          i,
-          a,
-          c = [],
-          s = true,
-          u = false;
-        try {
-          if (i = (r = r.call(e)).next, 0 === t) {
-            if (Object(r) !== r) return;
-            s = !1;
-          } else for (; !(s = (n = i.call(r)).done) && (c.push(n.value), c.length !== t); s = !0);
-        } catch (e) {
-          u = true, o = e;
-        } finally {
-          try {
-            if (!s && null != r["return"] && (a = r["return"](), Object(a) !== a)) return;
-          } finally {
-            if (u) throw o;
-          }
-        }
-        return c;
-      }
-    }(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 _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.");
-    }();
-  }
-  function _toPropertyKey(e) {
-    var t = function _toPrimitive(e, t) {
-      if ("object" != _typeof$1(e) || !e) return e;
-      var r = e[Symbol.toPrimitive];
-      if (void 0 !== r) {
-        var n = r.call(e, t);
-        if ("object" != _typeof$1(n)) return n;
-        throw new TypeError("@@toPrimitive must return a primitive value.");
-      }
-      return String(e);
-    }(e, "string");
-    return "symbol" == _typeof$1(t) ? t : t + "";
-  }
-  function _typeof(e) {
-    return _typeof = "function" == typeof Symbol && "symbol" == _typeof$1(Symbol.iterator) ? function (e) {
-      return _typeof$1(e);
-    } : function (e) {
-      return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : _typeof$1(e);
-    }, _typeof(e);
-  }
-  function _unsupportedIterableToArray(e, t) {
-    if (e) {
-      if ("string" == typeof e) return _arrayLikeToArray(e, t);
-      var r = {}.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;
-    }
-  }
-  var e = _createClass(function TypesonPromise(e) {
-    _classCallCheck(this, TypesonPromise), this.p = new Promise(e);
+  var TypesonPromise = /*#__PURE__*/_createClass(function TypesonPromise(e) {
+    _classCallCheck(this, TypesonPromise);
+    this.p = new Promise(e);
   });
-  e.__typeson__type__ = "TypesonPromise", "undefined" != typeof Symbol && Object.defineProperty(e.prototype, Symbol.toStringTag, {
+  TypesonPromise.__typeson__type__ = "TypesonPromise", "undefined" != typeof Symbol && Object.defineProperty(TypesonPromise.prototype, Symbol.toStringTag, {
     get: function get() {
       return "TypesonPromise";
     }
-  }), e.prototype.then = function (t, r) {
-    var n = this;
-    return new e(function (e, o) {
-      n.p.then(function (r) {
-        e(t ? t(r) : r);
+  }), TypesonPromise.prototype.then = function (e, t) {
+    var _this = this;
+    return new TypesonPromise(function (n, r) {
+      _this.p.then(function (t) {
+        n(e ? e(t) : t);
       })["catch"](function (e) {
-        return r ? r(e) : Promise.reject(e);
-      }).then(e, o);
+        return t ? t(e) : Promise.reject(e);
+      }).then(n, r);
     });
-  }, e.prototype["catch"] = function (e) {
+  }, TypesonPromise.prototype["catch"] = function (e) {
     return this.then(function () {}, e);
-  }, e.resolve = function (t) {
-    return new e(function (e) {
-      e(t);
+  }, TypesonPromise.resolve = function (e) {
+    return new TypesonPromise(function (t) {
+      t(e);
     });
-  }, e.reject = function (t) {
-    return new e(function (e, r) {
-      r(t);
+  }, TypesonPromise.reject = function (e) {
+    return new TypesonPromise(function (t, n) {
+      n(e);
     });
-  }, e.all = function (t) {
-    return new e(function (e, r) {
-      Promise.all(t.map(function (e) {
-        return null != e && e.constructor && "__typeson__type__" in e.constructor && "TypesonPromise" === e.constructor.__typeson__type__ ? e.p : e;
-      })).then(e, r);
+  }, TypesonPromise.all = function (e) {
+    return new TypesonPromise(function (t, n) {
+      Promise.all(e.map(function (e) {
+        return e !== null && e !== void 0 && e.constructor && "__typeson__type__" in e.constructor && "TypesonPromise" === e.constructor.__typeson__type__ ? e.p : e;
+      })).then(t, n);
     });
-  }, e.race = function (t) {
-    return new e(function (e, r) {
-      Promise.race(t.map(function (e) {
-        return null != e && e.constructor && "__typeson__type__" in e.constructor && "TypesonPromise" === e.constructor.__typeson__type__ ? e.p : e;
-      })).then(e, r);
+  }, TypesonPromise.race = function (e) {
+    return new TypesonPromise(function (t, n) {
+      Promise.race(e.map(function (e) {
+        return e !== null && e !== void 0 && e.constructor && "__typeson__type__" in e.constructor && "TypesonPromise" === e.constructor.__typeson__type__ ? e.p : e;
+      })).then(t, n);
     });
-  }, e.allSettled = function (t) {
-    return new e(function (e, r) {
-      Promise.allSettled(t.map(function (e) {
-        return null != e && e.constructor && "__typeson__type__" in e.constructor && "TypesonPromise" === e.constructor.__typeson__type__ ? e.p : e;
-      })).then(e, r);
+  }, TypesonPromise.allSettled = function (e) {
+    return new TypesonPromise(function (t, n) {
+      Promise.allSettled(e.map(function (e) {
+        return e !== null && e !== void 0 && e.constructor && "__typeson__type__" in e.constructor && "TypesonPromise" === e.constructor.__typeson__type__ ? e.p : e;
+      })).then(t, n);
     });
   };
-  var t = Object.hasOwn,
-    r = Object.getPrototypeOf;
+  var e = Object.hasOwn,
+    t = Object.getPrototypeOf;
   function isThenable(e, t) {
     return isObject(e) && "function" == typeof e.then && (!t || "function" == typeof e["catch"]);
   }
   function toStringTag(e) {
     return Object.prototype.toString.call(e).slice(8, -1);
   }
-  function hasConstructorOf(e, n) {
-    if (!e || "object" !== _typeof(e)) return false;
-    var o = r(e);
-    if (!o) return null === n;
-    var i = t(o, "constructor") && o.constructor;
-    return "function" != typeof i ? null === n : n === i || null !== n && Function.prototype.toString.call(i) === Function.prototype.toString.call(n) || "function" == typeof n && "string" == typeof i.__typeson__type__ && i.__typeson__type__ === n.__typeson__type__;
+  function hasConstructorOf(n, r) {
+    if (!n || "object" != _typeof(n)) return false;
+    var s = t(n);
+    if (!s) return null === r;
+    var o = e(s, "constructor") && s.constructor;
+    return "function" != typeof o ? null === r : r === o || null !== r && Function.prototype.toString.call(o) === Function.prototype.toString.call(r) || "function" == typeof r && "string" == typeof o.__typeson__type__ && o.__typeson__type__ === r.__typeson__type__;
   }
   function isPlainObject(e) {
-    return !(!e || "Object" !== toStringTag(e)) && (!r(e) || hasConstructorOf(e, Object));
+    if (!e || "Object" !== toStringTag(e)) return false;
+    return !t(e) || hasConstructorOf(e, Object);
   }
   function isUserObject(e) {
     if (!e || "Object" !== toStringTag(e)) return false;
-    var t = r(e);
-    return !t || hasConstructorOf(e, Object) || isUserObject(t);
+    var n = t(e);
+    return !n || hasConstructorOf(e, Object) || isUserObject(n);
   }
   function isObject(e) {
-    return null !== e && "object" === _typeof(e);
+    return null !== e && "object" == _typeof(e);
   }
   function escapeKeyPathComponent(e) {
     return e.replaceAll("''", "''''").replace(/^$/, "''").replaceAll("~", "~0").replaceAll(".", "~1");
@@ -456,535 +345,604 @@
   }
   function getByKeyPath(e, t) {
     if ("" === t) return e;
-    if (null === e || "object" !== _typeof(e)) throw new TypeError("Unexpected non-object type");
-    var r = t.indexOf(".");
-    if (-1 !== r) {
-      var n = e[unescapeKeyPathComponent(t.slice(0, r))];
-      return void 0 === n ? void 0 : getByKeyPath(n, t.slice(r + 1));
+    if (null === e || "object" != _typeof(e)) throw new TypeError("Unexpected non-object type");
+    var n = t.indexOf(".");
+    if (-1 !== n) {
+      var _r = e[unescapeKeyPathComponent(t.slice(0, n))];
+      return void 0 === _r ? void 0 : getByKeyPath(_r, t.slice(n + 1));
     }
     return e[unescapeKeyPathComponent(t)];
   }
-  function setAtKeyPath(e, t, r) {
-    if ("" === t) return r;
-    if (!e || "object" !== _typeof(e)) throw new TypeError("Unexpected non-object type");
-    if ("__proto__" === t) throw new TypeError("Invalid property");
-    var n = t.indexOf(".");
-    return -1 !== n ? setAtKeyPath(e[unescapeKeyPathComponent(t.slice(0, n))], t.slice(n + 1), r) : (e[unescapeKeyPathComponent(t)] = r, e);
+  function setAtKeyPath(e, t, n) {
+    if ("" === t) return n;
+    var r = e,
+      s = t;
+    for (;;) {
+      if (!r || "object" != _typeof(r)) throw new TypeError("Unexpected non-object type");
+      if ("__proto__" === s) throw new TypeError("Invalid property");
+      var _t = s.indexOf(".");
+      if (-1 === _t) return r[unescapeKeyPathComponent(s)] = n, e;
+      r = r[unescapeKeyPathComponent(s.slice(0, _t))], s = s.slice(_t + 1);
+    }
   }
   function getJSONType(e) {
     return null === e ? "null" : Array.isArray(e) ? "array" : _typeof(e);
   }
-  function _await(e, t, r) {
-    return e && e.then || (e = Promise.resolve(e)), t ? e.then(t) : e;
-  }
+  /**
+   * @file Typeson - JSON with types.
+   * @license The MIT License (MIT)
+   * @copyright (c) 2016-2018 David Fahlander, Brett Zamir
+  */
   var n = Object.keys,
-    o = Object.hasOwn,
-    i$1 = Array.isArray,
-    a = ["type", "replaced", "iterateIn", "iterateUnsetNumeric", "addLength"];
-  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);
-      }
-    };
-  }
+    r = Object.hasOwn,
+    s = Array.isArray,
+    o = ["type", "replaced", "iterateIn", "iterateUnsetNumeric", "addLength"];
   function nestedPathsFirst(e, t) {
-    var r, n;
+    var _e$keypath$match, _t$keypath$match;
     if ("" === e.keypath) return -1;
-    var o = null !== (r = e.keypath.match(/\./g)) && void 0 !== r ? r : 0,
-      i = null !== (n = t.keypath.match(/\./g)) && void 0 !== n ? n : 0;
-    return o && (o = o.length), i && (i = i.length), o > i ? -1 : o < i ? 1 : e.keypath < t.keypath ? -1 : e.keypath > t.keypath ? 1 : 0;
-  }
-  var c = function () {
-      return _createClass(function Typeson(e) {
-        _classCallCheck(this, Typeson), this.options = e, this.plainObjectReplacers = [], this.nonplainObjectReplacers = [], this.revivers = {}, this.types = {};
-      }, [{
-        key: "stringify",
-        value: function stringify(e, t, r, n) {
-          n = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), n), {}, {
-            stringification: true
-          });
-          var o = this.encapsulate(e, null, n);
-          return i$1(o) ? JSON.stringify(o[0], t, r) : o.then(function (e) {
-            return JSON.stringify(e, t, r);
-          });
-        }
-      }, {
-        key: "stringifySync",
-        value: function stringifySync(e, t, r, n) {
-          return this.stringify(e, t, r, _objectSpread2(_objectSpread2({
-            throwOnBadSyncType: true
-          }, n), {}, {
-            sync: true
-          }));
-        }
-      }, {
-        key: "stringifyAsync",
-        value: function stringifyAsync(e, t, r, n) {
-          return this.stringify(e, t, r, _objectSpread2(_objectSpread2({
-            throwOnBadSyncType: true
-          }, n), {}, {
-            sync: false
-          }));
-        }
-      }, {
-        key: "parse",
-        value: function parse(e, t, r) {
-          return r = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), r), {}, {
-            parse: true
-          }), this.revive(JSON.parse(e, t), r);
-        }
-      }, {
-        key: "parseSync",
-        value: function parseSync(e, t, r) {
-          return this.parse(e, t, _objectSpread2(_objectSpread2({
-            throwOnBadSyncType: true
-          }, r), {}, {
+    var n = (_e$keypath$match = e.keypath.match(/\./g)) !== null && _e$keypath$match !== void 0 ? _e$keypath$match : 0,
+      r = (_t$keypath$match = t.keypath.match(/\./g)) !== null && _t$keypath$match !== void 0 ? _t$keypath$match : 0;
+    return n && (n = n.length), r && (r = r.length), n > r ? -1 : n < r ? 1 : e.keypath < t.keypath ? -1 : e.keypath > t.keypath ? 1 : 0;
+  }
+  var Typeson = /*#__PURE__*/function () {
+    function Typeson(e) {
+      _classCallCheck(this, Typeson);
+      this.options = e, this.plainObjectReplacers = [], this.nonplainObjectReplacers = [], this.revivers = {}, this.types = {};
+    }
+    return _createClass(Typeson, [{
+      key: "stringify",
+      value: function stringify(e, t, n, r) {
+        r = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), r), {}, {
+          stringification: true
+        });
+        var o = this.encapsulate(e, null, r);
+        return s(o) ? JSON.stringify(o[0], t, n) : o.then(function (e) {
+          return JSON.stringify(e, t, n);
+        });
+      }
+    }, {
+      key: "stringifySync",
+      value: function stringifySync(e, t, n, r) {
+        return this.stringify(e, t, n, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: true
+        }, r), {}, {
+          sync: true
+        }));
+      }
+    }, {
+      key: "stringifyAsync",
+      value: function stringifyAsync(e, t, n, r) {
+        return this.stringify(e, t, n, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: true
+        }, r), {}, {
+          sync: false
+        }));
+      }
+    }, {
+      key: "parse",
+      value: function parse(e, t, n) {
+        return n = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), n), {}, {
+          parse: true
+        }), this.revive(JSON.parse(e, t), n);
+      }
+    }, {
+      key: "parseSync",
+      value: function parseSync(e, t, n) {
+        return this.parse(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: true
+        }, n), {}, {
+          sync: true
+        }));
+      }
+    }, {
+      key: "parseAsync",
+      value: function parseAsync(e, t, n) {
+        return this.parse(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: true
+        }, n), {}, {
+          sync: false
+        }));
+      }
+    }, {
+      key: "specialTypeNames",
+      value: function specialTypeNames(e, t) {
+        var n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        return n.returnTypeNames = true, this.encapsulate(e, t, n);
+      }
+    }, {
+      key: "rootTypeName",
+      value: function rootTypeName(e, t) {
+        var n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        return n.iterateNone = true, this.encapsulate(e, t, n);
+      }
+    }, {
+      key: "encapsulate",
+      value: function encapsulate(e, t, i) {
+        var _this2 = this;
+        var c = _objectSpread2(_objectSpread2({
             sync: true
-          }));
-        }
-      }, {
-        key: "parseAsync",
-        value: function parseAsync(e, t, r) {
-          return this.parse(e, t, _objectSpread2(_objectSpread2({
-            throwOnBadSyncType: true
-          }, r), {}, {
-            sync: false
-          }));
-        }
-      }, {
-        key: "specialTypeNames",
-        value: function specialTypeNames(e, t) {
-          var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
-          return r.returnTypeNames = true, 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 = true, this.encapsulate(e, t, r);
-        }
-      }, {
-        key: "encapsulate",
-        value: function encapsulate(t, r, c) {
-          var s = this,
-            u = _objectSpread2(_objectSpread2({
-              sync: true
-            }, this.options), c),
-            y = u.sync,
-            l = {},
-            p = [],
-            f = [],
-            v = [],
-            h = !("cyclic" in u) || u.cyclic,
-            d = u.encapsulateObserver,
-            b = function finish(e) {
-              var t = Object.values(l);
-              if (u.iterateNone) return t.length ? t[0] : getJSONType(e);
-              if (t.length) {
-                if (u.returnTypeNames) return _toConsumableArray(new Set(t));
-                e && isPlainObject(e) && !o(e, "$types") ? e.$types = l : e = {
-                  $: e,
-                  $types: {
-                    $: l
-                  }
-                };
-              } else isObject(e) && o(e, "$types") && (e = {
+          }, this.options), i),
+          a = c.sync,
+          p = {},
+          y = [],
+          u = [],
+          l = [],
+          h = !("cyclic" in c) || c.cyclic,
+          f = c.encapsulateObserver,
+          d = c.encapsulateError,
+          finish = function finish(e) {
+            var t = Object.values(p);
+            if (c.iterateNone) return t.length ? t[0] : getJSONType(e);
+            if (t.length) {
+              if (c.returnTypeNames) return _toConsumableArray(new Set(t));
+              e && isPlainObject(e) && !r(e, "$types") ? e.$types = p : e = {
                 $: e,
-                $types: true
-              });
-              return !u.returnTypeNames && e;
-            },
-            _ = _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 = false,
-                    i = [],
-                    a = _slicedToArray(r.splice(0, 1), 1),
-                    c = _slicedToArray(a[0], 7),
-                    s = c[0],
-                    u = c[2],
-                    y = c[3],
-                    l = c[4],
-                    p = c[5],
-                    f = c[6],
-                    v = m(s, n, u, y, i, true, f),
-                    h = hasConstructorOf(v, e);
-                  return function _invoke(e, t) {
-                    var r = e();
-                    return r && r.then ? r.then(t) : t(r);
-                  }(function () {
-                    if (s && h) return _await(v.p, function (e) {
-                      l[p] = e;
-                      var r = _(t, i);
-                      return o = true, r;
+                $types: {
+                  $: p
+                }
+              };
+            } else isObject(e) && r(e, "$types") && (e = {
+              $: e,
+              $types: true
+            });
+            return !c.returnTypeNames && e;
+          },
+          _checkPromises = /*#__PURE__*/function () {
+            var _checkPromises2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(e, t) {
+              var n;
+              return _regenerator().w(function (_context2) {
+                while (1) switch (_context2.n) {
+                  case 0:
+                    _context2.n = 1;
+                    return Promise.all(t.map(function (e) {
+                      return e[1].p;
+                    }));
+                  case 1:
+                    n = _context2.v;
+                    _context2.n = 2;
+                    return Promise.all(n.map(/*#__PURE__*/function () {
+                      var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(n) {
+                        var r, _t$splice, _t$splice2, s, _s, o, i, c, a, p, y, u, l, _t2;
+                        return _regenerator().w(function (_context) {
+                          while (1) switch (_context.n) {
+                            case 0:
+                              r = [], _t$splice = t.splice(0, 1), _t$splice2 = _slicedToArray(_t$splice, 1), s = _t$splice2[0], _s = _slicedToArray(s, 7), o = _s[0], i = _s[2], c = _s[3], a = _s[4], p = _s[5], y = _s[6], u = _encapsulate2(o, n, i, c, r, true, y), l = hasConstructorOf(u, TypesonPromise);
+                              if (!(o && l)) {
+                                _context.n = 2;
+                                break;
+                              }
+                              _context.n = 1;
+                              return u.p;
+                            case 1:
+                              _t2 = _context.v;
+                              return _context.a(2, (a[p] = _t2, _checkPromises(e, r)));
+                            case 2:
+                              return _context.a(2, (o ? a[p] = u : e = l ? u.p : u, _checkPromises(e, r)));
+                          }
+                        }, _callee);
+                      }));
+                      return function (_x3) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }()));
+                  case 2:
+                    return _context2.a(2, e);
+                }
+              }, _callee2);
+            }));
+            function checkPromises(_x, _x2) {
+              return _checkPromises2.apply(this, arguments);
+            }
+            return checkPromises;
+          }(),
+          _adaptBuiltinStateObjectProperties = function _adaptBuiltinStateObjectProperties(e, t, n) {
+            Object.assign(e, t);
+            var r = o.map(function (t) {
+              var n = e[t];
+              return delete e[t], n;
+            });
+            n(), o.forEach(function (t, n) {
+              e[t] = r[n];
+            });
+          },
+          _encapsulate2 = function _encapsulate(e, t, o, i, a, l, h) {
+            var v,
+              O = {};
+            var b = f ? function (n) {
+                var _ref2;
+                var r = (_ref2 = h !== null && h !== void 0 ? h : i.type) !== null && _ref2 !== void 0 ? _ref2 : getJSONType(t);
+                f(Object.assign(n !== null && n !== void 0 ? n : O, {
+                  keypath: e,
+                  value: t,
+                  cyclic: o,
+                  stateObj: i,
+                  promisesData: a,
+                  resolvingTypesonPromise: l,
+                  awaitingTypesonPromise: hasConstructorOf(t, TypesonPromise)
+                }, {
+                  type: r
+                }));
+              } : null,
+              getEncapsulatedValue = function getEncapsulatedValue(e, t, n) {
+                try {
+                  return {
+                    value: _encapsulate2(e, t[n], Boolean(o), i, a, l)
+                  };
+                } catch (r) {
+                  var _ref3;
+                  if (!d) throw r;
+                  var s = (_ref3 = h !== null && h !== void 0 ? h : i.type) !== null && _ref3 !== void 0 ? _ref3 : getJSONType(t),
+                    _o = d({
+                      keypath: e,
+                      error: r,
+                      parent: t,
+                      key: n,
+                      stateObj: i,
+                      type: s
                     });
-                  }, function (e) {
-                    return o ? e : (s ? l[p] = v : t = h ? v.p : v, _(t, i));
-                  });
-                }))), function () {
-                  return t;
-                });
-              });
-            }),
-            O = function _adaptBuiltinStateObjectProperties(e, t, r) {
-              Object.assign(e, t);
-              var n = a.map(function (t) {
-                var r = e[t];
-                return delete e[t], r;
-              });
-              r(), a.forEach(function (t, r) {
-                e[t] = n[r];
-              });
-            },
-            m = function _encapsulate(t, r, a, c, y, v, h) {
-              var b,
-                _ = {},
-                g = _typeof(r),
-                S = d ? function (n) {
-                  var o,
-                    i = null !== (o = null != h ? h : c.type) && void 0 !== o ? o : getJSONType(r);
-                  d(Object.assign(null != n ? n : _, {
-                    keypath: t,
-                    value: r,
-                    cyclic: a,
-                    stateObj: c,
-                    promisesData: y,
-                    resolvingTypesonPromise: v,
-                    awaitingTypesonPromise: hasConstructorOf(r, e)
-                  }, {
-                    type: i
-                  }));
-                } : null;
-              if (["string", "boolean", "number", "undefined"].includes(g)) return void 0 === r || Number.isNaN(r) || r === Number.NEGATIVE_INFINITY || r === Number.POSITIVE_INFINITY || 0 === r ? (b = c.replaced ? r : j(t, r, c, y, false, v, S)) !== r && (_ = {
-                replaced: b
-              }) : b = r, S && S(), b;
-              if (null === r) return S && S(), r;
-              if (a && !c.iterateIn && !c.iterateUnsetNumeric && r && "object" === _typeof(r)) {
-                var w = p.indexOf(r);
-                if (-1 !== w) return l[t] = "#", S && S({
-                  cyclicKeypath: f[w]
-                }), "#" + f[w];
-                true === a && (p.push(r), f.push(t));
-              }
-              var T,
-                P = isPlainObject(r),
-                A = i$1(r),
-                C = (P || A) && (!s.plainObjectReplacers.length || c.replaced) || c.iterateIn ? r : j(t, r, c, y, P || A, null, S);
-              if (C !== r ? (b = C, _ = {
-                replaced: C
-              }) : "" === t && hasConstructorOf(r, e) ? (y.push([t, r, a, c, void 0, void 0, c.type]), b = r) : A && "object" !== c.iterateIn || "array" === c.iterateIn ? (T = new Array(r.length), _ = {
-                clone: T
-              }) : (["function", "symbol"].includes(_typeof(r)) || "toJSON" in r || hasConstructorOf(r, e) || hasConstructorOf(r, Promise) || hasConstructorOf(r, ArrayBuffer)) && !P && "object" !== c.iterateIn ? b = r : (T = {}, c.addLength && (T.length = r.length), _ = {
-                clone: T
-              }), S && S(), u.iterateNone) return null != T ? T : b;
-              if (!T) return b;
-              if (c.iterateIn) {
-                var k = function _loop(n) {
-                  var i = {
-                    ownKeys: o(r, n)
+                  if (!_o) throw r;
+                  if ("substitute" in _o) return {
+                    value: _o.substitute,
+                    substitute: true
                   };
-                  O(c, i, function () {
-                    var o = t + (t ? "." : "") + escapeKeyPathComponent(n),
-                      i = m(o, r[n], Boolean(a), c, y, v);
-                    hasConstructorOf(i, e) ? y.push([o, i, Boolean(a), c, T, n, c.type]) : void 0 !== i && (T[n] = i);
-                  });
+                  if (_o.ignore) return;
+                  throw r;
+                }
+              };
+            if (["string", "boolean", "number", "undefined"].includes(_typeof(t))) return void 0 === t || t === 1 / 0 || 0 === t || t === -1 / 0 || Number.isNaN(t) ? (v = i.replaced ? t : replace(e, t, i, a, false, l, b), v !== t && (O = {
+              replaced: v
+            })) : v = t, b && b(), v;
+            if (null === t) return b && b(), t;
+            if (o && t && "object" == _typeof(t) && !i.iterateIn && !i.iterateUnsetNumeric) {
+              var _n = y.indexOf(t);
+              if (-1 !== _n) return p[e] = "#", b && b({
+                cyclicKeypath: u[_n]
+              }), "#" + u[_n];
+              true === o && (y.push(t), u.push(e));
+            }
+            var m = isPlainObject(t),
+              P = s(t),
+              T = (m || P) && (!_this2.plainObjectReplacers.length || i.replaced) || i.iterateIn ? t : replace(e, t, i, a, m || P, null, b);
+            var g;
+            if (T !== t ? (v = T, O = {
+              replaced: T
+            }) : "" === e && hasConstructorOf(t, TypesonPromise) ? (a.push([e, t, o, i, void 0, void 0, i.type]), v = t) : P && "object" !== i.iterateIn || "array" === i.iterateIn ? (g = new Array(t.length), O = {
+              clone: g
+            }) : !m && ("object" != _typeof(t) || "toJSON" in t || hasConstructorOf(t, TypesonPromise) || hasConstructorOf(t, Promise) || hasConstructorOf(t, ArrayBuffer)) && "object" !== i.iterateIn ? v = t : (g = {}, i.addLength && (g.length = t.length), O = {
+              clone: g
+            }), b && b(), c.iterateNone) return g !== null && g !== void 0 ? g : v;
+            if (!g) return v;
+            if (i.iterateIn) {
+              var _loop = function _loop(_n2) {
+                var s = {
+                  ownKeys: r(t, _n2)
                 };
-                for (var N in r) k(N);
-                S && S({
-                  endIterateIn: true,
-                  end: true
-                });
-              } else n(r).forEach(function (n) {
-                var o = t + (t ? "." : "") + escapeKeyPathComponent(n);
-                O(c, {
-                  ownKeys: true
-                }, function () {
-                  var t = m(o, r[n], Boolean(a), c, y, v);
-                  hasConstructorOf(t, e) ? y.push([o, t, Boolean(a), c, T, n, c.type]) : void 0 !== t && (T[n] = t);
+                _adaptBuiltinStateObjectProperties(i, s, function () {
+                  var r = e + (e ? "." : "") + escapeKeyPathComponent(_n2),
+                    s = getEncapsulatedValue(r, t, _n2),
+                    c = s && s.value;
+                  hasConstructorOf(c, TypesonPromise) ? a.push([r, c, Boolean(o), i, g, _n2, i.type]) : s && (void 0 !== c || "substitute" in s) && (g[_n2] = c);
                 });
-              }), S && S({
-                endIterateOwn: true,
+              };
+              for (var _n2 in t) {
+                _loop(_n2);
+              }
+              b && b({
+                endIterateIn: true,
                 end: true
               });
-              if (c.iterateUnsetNumeric) {
-                for (var I = r.length, E = function _loop2(n) {
-                    if (!(n in r)) {
-                      var o = "".concat(t).concat(t ? "." : "").concat(String(n));
-                      O(c, {
-                        ownKeys: false
-                      }, function () {
-                        var t = m(o, void 0, Boolean(a), c, y, v);
-                        hasConstructorOf(t, e) ? y.push([o, t, Boolean(a), c, T, n, c.type]) : void 0 !== t && (T[n] = t);
-                      });
-                    }
-                  }, K = 0; K < I; K++) E(K);
-                S && S({
-                  endIterateUnsetNumeric: true,
-                  end: true
+            } else n(t).forEach(function (n) {
+              var r = e + (e ? "." : "") + escapeKeyPathComponent(n);
+              _adaptBuiltinStateObjectProperties(i, {
+                ownKeys: true
+              }, function () {
+                var e = getEncapsulatedValue(r, t, n),
+                  s = e && e.value;
+                hasConstructorOf(s, TypesonPromise) ? a.push([r, s, Boolean(o), i, g, n, i.type]) : e && (void 0 !== s || "substitute" in e) && (g[n] = s);
+              });
+            }), b && b({
+              endIterateOwn: true,
+              end: true
+            });
+            if (i.iterateUnsetNumeric) {
+              var _n3 = t.length;
+              var _loop2 = function _loop2(_r2) {
+                if (_r2 in t) return 1; // continue
+                var n = "".concat(e).concat(e ? "." : "").concat(String(_r2));
+                _adaptBuiltinStateObjectProperties(i, {
+                  ownKeys: false
+                }, function () {
+                  var e = _encapsulate2(n, void 0, Boolean(o), i, a, l);
+                  hasConstructorOf(e, TypesonPromise) ? a.push([n, e, Boolean(o), i, g, _r2, i.type]) : void 0 !== e && (g[_r2] = e);
                 });
+              };
+              for (var _r2 = 0; _r2 < _n3; _r2++) {
+                if (_loop2(_r2)) continue;
               }
-              return T;
-            },
-            j = function replace(e, t, r, n, o, i, a) {
-              for (var c = o ? s.plainObjectReplacers : s.nonplainObjectReplacers, u = c.length; u--;) {
-                var p = c[u];
-                if (p.test(t, r)) {
-                  var f = p.type;
-                  if (s.revivers[f]) {
-                    var v = l[e];
-                    l[e] = v ? [f].concat(v) : f;
-                  }
-                  if (Object.assign(r, {
-                    type: f,
-                    replaced: true
-                  }), (y || !p.replaceAsync) && !p.replace) return a && a({
-                    typeDetected: true
-                  }), m(e, t, h && "readonly", r, n, i, f);
-                  a && a({
-                    replacing: true
-                  });
-                  var d = void 0;
-                  if (y || !p.replaceAsync) {
-                    if (void 0 === p.replace) throw new TypeError("Missing replacer");
-                    d = p.replace(t, r);
-                  } else d = p.replaceAsync(t, r);
-                  return m(e, d, h && "readonly", r, n, i, f);
+              b && b({
+                endIterateUnsetNumeric: true,
+                end: true
+              });
+            }
+            return g;
+          },
+          replace = function replace(e, t, n, r, s, o, i) {
+            var c = s ? _this2.plainObjectReplacers : _this2.nonplainObjectReplacers;
+            var y = c.length;
+            for (; y--;) {
+              var _s2 = c[y];
+              if (_s2.test(t, n)) {
+                var _c = _s2.type;
+                if (Object.hasOwn(_this2.revivers, _c)) {
+                  var _t3 = p[e];
+                  p[e] = _t3 ? [_c].concat(_t3) : _c;
                 }
+                if (Object.assign(n, {
+                  type: _c,
+                  replaced: true
+                }), (a || !_s2.replaceAsync) && !_s2.replace) return i && i({
+                  typeDetected: true
+                }), _encapsulate2(e, t, h && "readonly", n, r, o, _c);
+                var _y = void 0;
+                if (i && i({
+                  replacing: true
+                }), a || !_s2.replaceAsync) {
+                  if (void 0 === _s2.replace) throw new TypeError("Missing replacer");
+                  _y = _s2.replace(t, n);
+                } else _y = _s2.replaceAsync(t, n);
+                return _encapsulate2(e, _y, h && "readonly", n, r, o, _c);
               }
-              return t;
-            },
-            g = m("", t, h, null != r ? r : {}, v);
-          if (v.length) return y && u.throwOnBadSyncType ? function () {
-            throw new TypeError("Sync method requested but async result obtained");
-          }() : Promise.resolve(_(g, v)).then(b);
-          if (!y && u.throwOnBadSyncType) throw new TypeError("Async method requested but sync result obtained");
-          return u.stringification && y ? [b(g)] : y ? b(g) : Promise.resolve(b(g));
-        }
-      }, {
-        key: "encapsulateSync",
-        value: function encapsulateSync(e, t, r) {
-          return this.encapsulate(e, t, _objectSpread2(_objectSpread2({
-            throwOnBadSyncType: true
-          }, r), {}, {
+            }
+            return t;
+          },
+          v = _encapsulate2("", e, h, t !== null && t !== void 0 ? t : {}, l);
+        if (l.length) return a && c.throwOnBadSyncType ? function () {
+          throw new TypeError("Sync method requested but async result obtained");
+        }() : Promise.resolve(_checkPromises(v, l)).then(finish);
+        if (!a && c.throwOnBadSyncType) throw new TypeError("Async method requested but sync result obtained");
+        return a && c.stringification ? [finish(v)] : a ? finish(v) : Promise.resolve(finish(v));
+      }
+    }, {
+      key: "encapsulateSync",
+      value: function encapsulateSync(e, t, n) {
+        return this.encapsulate(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: true
+        }, n), {}, {
+          sync: true
+        }));
+      }
+    }, {
+      key: "encapsulateAsync",
+      value: function encapsulateAsync(e, t, n) {
+        return this.encapsulate(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: true
+        }, n), {}, {
+          sync: false
+        }));
+      }
+    }, {
+      key: "revive",
+      value: function revive(e, t) {
+        var _this3 = this;
+        var o = _objectSpread2(_objectSpread2({
             sync: true
-          }));
+          }, this.options), t),
+          i = o.sync;
+        function finishRevival(e) {
+          if (i) return e;
+          if (o.throwOnBadSyncType) throw new TypeError("Async method requested but sync result obtained");
+          return Promise.resolve(e);
         }
-      }, {
-        key: "encapsulateAsync",
-        value: function encapsulateAsync(e, t, r) {
-          return this.encapsulate(e, t, _objectSpread2(_objectSpread2({
-            throwOnBadSyncType: true
-          }, r), {}, {
-            sync: false
-          }));
+        if (!e || "object" != _typeof(e) || Array.isArray(e)) return finishRevival(e);
+        var c = e.$types;
+        if (true === c) return finishRevival(e.$);
+        if (!c || "object" != _typeof(c) || Array.isArray(c)) return finishRevival(e);
+        var a = [],
+          p = Object.create(null),
+          y = {};
+        var u = true;
+        c.$ && isPlainObject(c.$) && (e = e.$, c = c.$, u = false);
+        var executeReviver = function executeReviver(e, t) {
+            var _this3$revivers$e;
+            var _ref4 = (_this3$revivers$e = _this3.revivers[e]) !== null && _this3$revivers$e !== void 0 ? _this3$revivers$e : [],
+              _ref5 = _slicedToArray(_ref4, 1),
+              n = _ref5[0];
+            if (!n) throw new Error("Unregistered type: " + e);
+            if (i && !("revive" in n)) return t;
+            if (!i && n.reviveAsync) return n.reviveAsync(t, y);
+            if (n.revive) return n.revive(t, y);
+            throw new Error("Missing reviver");
+          },
+          l = [];
+        function checkUndefined(e) {
+          return hasConstructorOf(e, Undefined) ? void 0 : e;
         }
-      }, {
-        key: "revive",
-        value: function revive(t, r) {
-          var o = this,
-            a = _objectSpread2(_objectSpread2({
-              sync: true
-            }, this.options), r),
-            c = a.sync;
-          function finishRevival(e) {
-            if (c) return e;
-            if (a.throwOnBadSyncType) throw new TypeError("Async method requested but sync result obtained");
-            return Promise.resolve(e);
+        var h = function () {
+          if (!c) throw new Error("Found bad `types`");
+          var t = [];
+          if (Object.entries(c).forEach(function (_ref6) {
+            var _ref7 = _slicedToArray(_ref6, 2),
+              e = _ref7[0],
+              n = _ref7[1];
+            "#" !== n && [].concat(n).forEach(function (n) {
+              var _this3$revivers$n;
+              var _ref8 = (_this3$revivers$n = _this3.revivers[n]) !== null && _this3$revivers$n !== void 0 ? _this3$revivers$n : [null, {}],
+                _ref9 = _slicedToArray(_ref8, 2),
+                r = _ref9[1].plain;
+              r && (t.push({
+                keypath: e,
+                type: n
+              }), delete c[e]);
+            });
+          }), t.length) return t.sort(nestedPathsFirst), t.reduce(function reducer(t, _ref0) {
+            var n = _ref0.keypath,
+              r = _ref0.type;
+            if (isThenable(t)) return t.then(function (e) {
+              return reducer(e, {
+                keypath: n,
+                type: r
+              });
+            });
+            var s = getByKeyPath(e, n);
+            if (s = executeReviver(r, s), hasConstructorOf(s, TypesonPromise)) return s.then(function (t) {
+              var r = setAtKeyPath(e, n, t);
+              r === t && (e = r);
+            });
+            var o = setAtKeyPath(e, n, s);
+            o === s && (e = o);
+          }, void 0);
+        }();
+        var f;
+        return hasConstructorOf(h, TypesonPromise) ? f = h.then(function () {
+          return e;
+        }) : (f = function _revive(e, t, o, y, h) {
+          if (u && "$types" === e) return;
+          var f = l.length,
+            d = c[e],
+            v = s(t);
+          if (v || isPlainObject(t)) {
+            var _s3 = v ? new Array(t.length) : {};
+            for (n(t).forEach(function (n) {
+              var r = _revive(e + (e ? "." : "") + escapeKeyPathComponent(n), t[n], o !== null && o !== void 0 ? o : _s3, _s3, n),
+                set = function set(e) {
+                  return hasConstructorOf(e, Undefined) ? _s3[n] = void 0 : void 0 !== e && (_s3[n] = e), e;
+                };
+              hasConstructorOf(r, TypesonPromise) ? l.push(r.then(function (e) {
+                return set(e);
+              })) : set(r);
+            }), t = _s3; a.length;) {
+              var _a$ = _slicedToArray(a[0], 4),
+                _e = _a$[0],
+                _t4 = _a$[1],
+                _n4 = _a$[2],
+                _s4 = _a$[3],
+                _o2 = r(p, _t4),
+                _i = _o2 ? p[_t4] : getByKeyPath(_e, _t4);
+              if (!_o2 && void 0 === _i) break;
+              _n4[_s4] = _i, a.shift();
+            }
           }
-          if (!t || "object" !== _typeof(t) || Array.isArray(t)) return finishRevival(t);
-          var u = t.$types;
-          if (true === u) return finishRevival(t.$);
-          if (!u || "object" !== _typeof(u) || Array.isArray(u)) return finishRevival(t);
-          var y = [],
-            l = {},
-            p = true;
-          u.$ && isPlainObject(u.$) && (t = t.$, u = u.$, p = false);
-          var f = function executeReviver(e, t) {
-              var r,
-                n = _slicedToArray(null !== (r = o.revivers[e]) && void 0 !== r ? r : [], 1)[0];
-              if (!n) throw new Error("Unregistered type: " + e);
-              if (c && !("revive" in n)) return t;
-              if (!c && n.reviveAsync) return n.reviveAsync(t, l);
-              if (n.revive) return n.revive(t, l);
-              throw new Error("Missing reviver");
-            },
-            v = [];
-          function checkUndefined(e) {
-            return hasConstructorOf(e, s) ? void 0 : e;
+          if (!d) return p[e] = t, t;
+          if ("#" === d) {
+            var _e2 = t.slice(1),
+              _n5 = r(p, _e2),
+              _s5 = _n5 ? p[_e2] : getByKeyPath(o, _e2);
+            return _n5 || void 0 !== _s5 || a.push([o, _e2, y, h]), _s5;
           }
-          var h,
-            d = function revivePlainObjects() {
-              var r = [];
-              if (!u) throw new Error("Found bad `types`");
-              if (Object.entries(u).forEach(function (e) {
-                var t = _slicedToArray(e, 2),
-                  n = t[0],
-                  i = t[1];
-                "#" !== i && [].concat(i).forEach(function (e) {
-                  var t;
-                  _slicedToArray(null !== (t = o.revivers[e]) && void 0 !== t ? t : [null, {}], 2)[1].plain && (r.push({
-                    keypath: n,
-                    type: e
-                  }), delete u[n]);
-                });
-              }), r.length) return r.sort(nestedPathsFirst), r.reduce(function reducer(r, n) {
-                var o = n.keypath,
-                  i = n.type;
-                if (isThenable(r)) return r.then(function (e) {
-                  return reducer(e, {
-                    keypath: o,
-                    type: i
-                  });
-                });
-                var a = getByKeyPath(t, o);
-                if (hasConstructorOf(a = f(i, a), e)) return a.then(function (e) {
-                  var r = setAtKeyPath(t, o, e);
-                  r === e && (t = r);
+          var applyType = function applyType(t) {
+            var n = [].concat(d).reduce(function reducer(e, t) {
+              if (hasConstructorOf(e, TypesonPromise)) return e.then(function (e) {
+                return reducer(e, t);
+              });
+              if ("string" != typeof t) throw new TypeError("Bad type JSON");
+              return executeReviver(t, e);
+            }, t);
+            return hasConstructorOf(n, TypesonPromise) ? n.then(function (t) {
+              return p[e] = t, t;
+            }) : (p[e] = n, n);
+          };
+          return !i && l.length > f ? TypesonPromise.all(l.slice(f)).then(function () {
+            return applyType(t);
+          }) : applyType(t);
+        }("", e, null), l.length && (f = TypesonPromise.resolve(f).then(function (e) {
+          return TypesonPromise.all([e].concat(l));
+        }).then(function (_ref1) {
+          var _ref10 = _slicedToArray(_ref1, 1),
+            e = _ref10[0];
+          return e;
+        }))), isThenable(f) ? i && o.throwOnBadSyncType ? function () {
+          throw new TypeError("Sync method requested but async result obtained");
+        }() : hasConstructorOf(f, TypesonPromise) ? f.p.then(checkUndefined) : f : !i && o.throwOnBadSyncType ? function () {
+          throw new TypeError("Async method requested but sync result obtained");
+        }() : i ? checkUndefined(f) : Promise.resolve(checkUndefined(f));
+      }
+    }, {
+      key: "reviveSync",
+      value: function reviveSync(e, t) {
+        return this.revive(e, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: true
+        }, t), {}, {
+          sync: true
+        }));
+      }
+    }, {
+      key: "reviveAsync",
+      value: function reviveAsync(e, t) {
+        return this.revive(e, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: true
+        }, t), {}, {
+          sync: false
+        }));
+      }
+    }, {
+      key: "register",
+      value: function register(e, t) {
+        var _this4 = this;
+        var r = t !== null && t !== void 0 ? t : {},
+          _reg = function reg(e) {
+            s(e) ? e.forEach(function (e) {
+              _reg(e);
+            }) : n(e).forEach(function (t) {
+              var _n8;
+              if ("#" === t) throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");
+              if (i$1.includes(t)) throw new TypeError("Plain JSON object types are reserved as type names");
+              var n = e[t];
+              var o = n && "function" != typeof n && !Array.isArray(n) && n.testPlainObjects ? _this4.plainObjectReplacers : _this4.nonplainObjectReplacers,
+                c = o.filter(function (e) {
+                  return e.type === t;
                 });
-                var c = setAtKeyPath(t, o, a);
-                c === a && (t = c);
-              }, void 0);
-            }();
-          return hasConstructorOf(d, e) ? h = d.then(function () {
-            return t;
-          }) : (h = function _revive(t, r, o, a, c) {
-            if (!p || "$types" !== t) {
-              var l = u[t],
-                h = i$1(r);
-              if (h || isPlainObject(r)) {
-                var d = h ? new Array(r.length) : {};
-                for (n(r).forEach(function (n) {
-                  var i = _revive(t + (t ? "." : "") + escapeKeyPathComponent(n), r[n], null != o ? o : d, d, n),
-                    a = function set(e) {
-                      return hasConstructorOf(e, s) ? d[n] = void 0 : void 0 !== e && (d[n] = e), e;
-                    };
-                  hasConstructorOf(i, e) ? v.push(i.then(function (e) {
-                    return a(e);
-                  })) : a(i);
-                }), r = d; y.length;) {
-                  var b = _slicedToArray(y[0], 4),
-                    _ = b[0],
-                    O = b[1],
-                    m = b[2],
-                    j = b[3],
-                    g = getByKeyPath(_, O);
-                  if (void 0 === g) break;
-                  m[j] = g, y.splice(0, 1);
-                }
+              if (c.length && (o.splice(o.indexOf(c[0]), 1), delete _this4.revivers[t], delete _this4.types[t]), "function" == typeof n) {
+                var _e3 = n;
+                n = {
+                  test: function test(t) {
+                    return t && t.constructor === _e3;
+                  },
+                  replace: function replace(e) {
+                    return _objectSpread2({}, e);
+                  },
+                  revive: function revive(t) {
+                    return Object.assign(Object.create(_e3.prototype), t);
+                  }
+                };
+              } else if (s(n)) {
+                var _n6 = n,
+                  _n7 = _slicedToArray(_n6, 3),
+                  _e4 = _n7[0],
+                  _t5 = _n7[1],
+                  _r3 = _n7[2];
+                n = {
+                  test: _e4,
+                  replace: _t5,
+                  revive: _r3
+                };
               }
-              if (!l) return r;
-              if ("#" === l) {
-                var S = getByKeyPath(o, r.slice(1));
-                return void 0 === S && y.push([o, r.slice(1), a, c]), S;
+              if (!((_n8 = n) !== null && _n8 !== void 0 && _n8.test)) return;
+              var a = {
+                type: t,
+                test: n.test.bind(n)
+              };
+              n.replace && (a.replace = n.replace.bind(n)), n.replaceAsync && (a.replaceAsync = n.replaceAsync.bind(n));
+              var p = "number" == typeof r.fallback ? r.fallback : r.fallback ? 0 : 1 / 0;
+              if (n.testPlainObjects ? _this4.plainObjectReplacers.splice(p, 0, a) : _this4.nonplainObjectReplacers.splice(p, 0, a), n.revive || n.reviveAsync) {
+                var _e5 = {};
+                n.revive && (_e5.revive = n.revive.bind(n)), n.reviveAsync && (_e5.reviveAsync = n.reviveAsync.bind(n)), _this4.revivers[t] = [_e5, {
+                  plain: n.testPlainObjects
+                }];
               }
-              return [].concat(l).reduce(function reducer(t, r) {
-                if (hasConstructorOf(t, e)) return t.then(function (e) {
-                  return reducer(e, r);
-                });
-                if ("string" != typeof r) throw new TypeError("Bad type JSON");
-                return f(r, t);
-              }, r);
-            }
-          }("", t, null), v.length && (h = e.resolve(h).then(function (t) {
-            return e.all([t].concat(v));
-          }).then(function (e) {
-            return _slicedToArray(e, 1)[0];
-          }))), isThenable(h) ? c && a.throwOnBadSyncType ? function () {
-            throw new TypeError("Sync method requested but async result obtained");
-          }() : hasConstructorOf(h, e) ? h.p.then(checkUndefined) : h : !c && a.throwOnBadSyncType ? function () {
-            throw new TypeError("Async method requested but sync result obtained");
-          }() : c ? checkUndefined(h) : Promise.resolve(checkUndefined(h));
-        }
-      }, {
-        key: "reviveSync",
-        value: function reviveSync(e, t) {
-          return this.revive(e, _objectSpread2(_objectSpread2({
-            throwOnBadSyncType: true
-          }, t), {}, {
-            sync: true
-          }));
-        }
-      }, {
-        key: "reviveAsync",
-        value: function reviveAsync(e, t) {
-          return this.revive(e, _objectSpread2(_objectSpread2({
-            throwOnBadSyncType: true
-          }, t), {}, {
-            sync: false
-          }));
-        }
-      }, {
-        key: "register",
-        value: function register(e, t) {
-          var r = this,
-            o = null != t ? t : {},
-            a = function reg(e) {
-              i$1(e) ? e.forEach(function (e) {
-                a(e);
-              }) : n(e).forEach(function (t) {
-                var n;
-                if ("#" === t) throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");
-                if (u.includes(t)) throw new TypeError("Plain JSON object types are reserved as type names");
-                var a = e[t],
-                  c = a && "function" != typeof a && !Array.isArray(a) && a.testPlainObjects ? r.plainObjectReplacers : r.nonplainObjectReplacers,
-                  s = c.filter(function (e) {
-                    return e.type === t;
-                  });
-                if (s.length && (c.splice(c.indexOf(s[0]), 1), delete r.revivers[t], delete r.types[t]), "function" == typeof a) {
-                  var y = a;
-                  a = {
-                    test: function test(e) {
-                      return e && e.constructor === y;
-                    },
-                    replace: function replace(e) {
-                      return _objectSpread2({}, e);
-                    },
-                    revive: function revive(e) {
-                      return Object.assign(Object.create(y.prototype), e);
-                    }
-                  };
-                } else if (i$1(a)) {
-                  var l = _slicedToArray(a, 3);
-                  a = {
-                    test: l[0],
-                    replace: l[1],
-                    revive: l[2]
-                  };
-                }
-                if (null !== (n = a) && void 0 !== n && n.test) {
-                  var p = {
-                    type: t,
-                    test: a.test.bind(a)
-                  };
-                  a.replace && (p.replace = a.replace.bind(a)), a.replaceAsync && (p.replaceAsync = a.replaceAsync.bind(a));
-                  var f = "number" == typeof o.fallback ? o.fallback : o.fallback ? 0 : Number.POSITIVE_INFINITY;
-                  if (a.testPlainObjects ? r.plainObjectReplacers.splice(f, 0, p) : r.nonplainObjectReplacers.splice(f, 0, p), a.revive || a.reviveAsync) {
-                    var v = {};
-                    a.revive && (v.revive = a.revive.bind(a)), a.reviveAsync && (v.reviveAsync = a.reviveAsync.bind(a)), r.revivers[t] = [v, {
-                      plain: a.testPlainObjects
-                    }];
-                  }
-                  r.types[t] = a;
-                }
-              });
-            };
-          return [].concat(e).forEach(function (e) {
-            a(e);
-          }), this;
-        }
-      }]);
-    }(),
-    s = _createClass(function Undefined() {
-      _classCallCheck(this, Undefined);
-    });
-  s.__typeson__type__ = "TypesonUndefined";
-  var u = ["null", "boolean", "number", "string", "array", "object"];
+              _this4.types[t] = n;
+            });
+          };
+        return [].concat(e).forEach(function (e) {
+          _reg(e);
+        }), this;
+      }
+    }]);
+  }();
+  var Undefined = /*#__PURE__*/_createClass(function Undefined() {
+    _classCallCheck(this, Undefined);
+  });
+  Undefined.__typeson__type__ = "TypesonUndefined";
+  var i$1 = ["null", "boolean", "number", "string", "array", "object"];
 
   /*
    * base64-arraybuffer
@@ -1137,7 +1095,7 @@
   var bigintObject = {
     bigintObject: {
       test: function test(x) {
-        return _typeof$1(x) === 'object' && hasConstructorOf(x, BigInt);
+        return _typeof(x) === 'object' && hasConstructorOf(x, BigInt);
       },
       replace: String,
       revive: function revive(s) {
@@ -1269,7 +1227,7 @@
         });
       },
       replaceAsync: function replaceAsync(b) {
-        return new e(function (resolve, reject) {
+        return new TypesonPromise(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'));
@@ -1304,7 +1262,7 @@
    * @returns {string}
    */
   function generateUUID() {
-    //  Adapted from original: public domain/MIT: http://stackoverflow.com/a/8809472/271577
+    //  Adapted from original: public domain/MIT: https://stackoverflow.com/a/8809472/271577
     /* c8 ignore next */
     var d = Date.now();
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replaceAll(/[xy]/g, function (c) {
@@ -1327,7 +1285,7 @@
   var cloneable = {
     cloneable: {
       test: function test(x) {
-        return x && _typeof$1(x) === 'object' && typeof x[Symbol["for"]('cloneEncapsulate')] === 'function';
+        return x && _typeof(x) === 'object' && typeof x[Symbol["for"]('cloneEncapsulate')] === 'function';
       },
       replace: function replace(clonable) {
         var encapsulated = clonable[Symbol["for"]('cloneEncapsulate')]();
@@ -1356,7 +1314,7 @@
       },
       replaceAsync: function replaceAsync(/** @type {CryptoKey} */
       key) {
-        return new e(/*#__PURE__*/function () {
+        return new TypesonPromise(/*#__PURE__*/function () {
           var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(resolve, reject) {
             var jwk, _t;
             return _regenerator().w(function (_context) {
@@ -1393,30 +1351,30 @@
       revive: function revive(obj) {
         var jwk = (
           /**
-          * @type {{
-          *   jwk: JsonWebKey,
-          *   algorithm: KeyAlgorithm,
-          *   usages: KeyUsage[]
-          * }}
-          */
+           * @type {{
+           *   jwk: JsonWebKey,
+           *   algorithm: KeyAlgorithm,
+           *   usages: KeyUsage[]
+           * }}
+           */
           obj).jwk,
           algorithm = (
           /**
-          * @type {{
-          *   jwk: JsonWebKey,
-          *   algorithm: KeyAlgorithm,
-          *   usages: KeyUsage[]
-          * }}
-          */
+           * @type {{
+           *   jwk: JsonWebKey,
+           *   algorithm: KeyAlgorithm,
+           *   usages: KeyUsage[]
+           * }}
+           */
           obj).algorithm,
           usages = (
           /**
-          * @type {{
-          *   jwk: JsonWebKey,
-          *   algorithm: KeyAlgorithm,
-          *   usages: KeyUsage[]
-          * }}
-          */
+           * @type {{
+           *   jwk: JsonWebKey,
+           *   algorithm: KeyAlgorithm,
+           *   usages: KeyUsage[]
+           * }}
+           */
           obj).usages;
         return crypto.subtle.importKey('jwk', jwk, algorithm, true, usages);
       }
@@ -1508,7 +1466,7 @@
       },
       revive: function revive(time) {
         if (time === 'NaN') {
-          return new Date(Number.NaN);
+          return new Date(NaN);
         }
         return new Date(time);
       }
@@ -1746,19 +1704,21 @@
       revive: function revive(obj) {
         var e =
         /**
-        * @type {{
-        *   name: string,
-        *   cause: Error,
-        *   stack: string,
-        *   fileName?: string,
-        *   lineNumber?: import('typeson').Integer,
-        *   columnNumber?: import('typeson').Integer
-        * }}
-        */
+         * @type {{
+         *   name: string,
+         *   cause: Error,
+         *   stack: string,
+         *   fileName?: string,
+         *   lineNumber?: import('typeson').Integer,
+         *   columnNumber?: import('typeson').Integer
+         * }}
+         */
         new Error(obj.message);
+        /* eslint-disable unicorn/no-error-property-assignment -- Ok */
         e.name = obj.name;
         e.cause = obj.cause;
         e.stack = obj.stack;
+        /* eslint-enable unicorn/no-error-property-assignment -- Ok */
         e.fileName = obj.fileName;
         e.lineNumber = obj.lineNumber;
         e.columnNumber = obj.columnNumber;
@@ -1775,6 +1735,7 @@
   var errors = {};
 
   // JS standard
+  // eslint-disable-next-line unicorn/no-top-level-side-effects -- Too cumbersome
   [TypeError, RangeError, SyntaxError, ReferenceError, EvalError, URIError].forEach(function (error) {
     return create$2(error);
   });
@@ -1791,7 +1752,6 @@
     create$2(InternalError);
   }
 
-  /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/131 */
   /**
    * Non-standard.
    * @typedef {{
@@ -1799,7 +1759,6 @@
    * (message?: string, options?: ErrorOptions): EvalError;
    * }} InternalErrorConstructor
    */
-  /* eslint-enable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/131 */
 
   /**
    * Comprises all built-in errors.
@@ -1839,23 +1798,23 @@
         var isAggregateError = typeof AggregateError !== 'undefined' && Ctor === AggregateError;
         var e =
         /**
-        * @type {{
-        *   name: string,
-        *   cause: Error,
-        *   stack: string,
-        *   fileName?: string,
-        *   lineNumber?: import('typeson').Integer,
-        *   columnNumber?: import('typeson').Integer
-        * }}
-        */
+         * @type {{
+         *   name: string,
+         *   cause: Error,
+         *   stack: string,
+         *   fileName?: string,
+         *   lineNumber?: import('typeson').Integer,
+         *   columnNumber?: import('typeson').Integer
+         * }}
+         */
         isAggregateError ? new (/** @type {AggregateErrorConstructor} */
         Ctor)(obj.errors, obj.message) : new (
         /**
-        * @type {TypeErrorConstructor|RangeErrorConstructor|
-        *   SyntaxErrorConstructor|ReferenceErrorConstructor|
-        *   EvalErrorConstructor|URIErrorConstructor|
-        *   InternalErrorConstructor}
-        */
+         * @type {TypeErrorConstructor|RangeErrorConstructor|
+         *   SyntaxErrorConstructor|ReferenceErrorConstructor|
+         *   EvalErrorConstructor|URIErrorConstructor|
+         *   InternalErrorConstructor}
+         */
         Ctor)(obj.message);
         e.name = obj.name;
         e.cause = obj.cause;
@@ -1908,7 +1867,7 @@
         });
       },
       replaceAsync: function replaceAsync(f) {
-        return new e(function (resolve, reject) {
+        return new TypesonPromise(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'));
@@ -1962,7 +1921,7 @@
            * Set private properties and length.
            */
           function FileList() {
-            _classCallCheck$1(this, FileList);
+            _classCallCheck(this, FileList);
             // eslint-disable-next-line prefer-rest-params -- API
             this._files = arguments[0];
             this.length = this._files.length;
@@ -1971,7 +1930,7 @@
            * @param {import('typeson').Integer} index
            * @returns {File}
            */
-          return _createClass$1(FileList, [{
+          return _createClass(FileList, [{
             key: "item",
             value: function item(index) {
               return this._files[index];
@@ -2030,7 +1989,7 @@
         var ctx = /** @type {CanvasRenderingContext2D} */
         canvas.getContext('2d');
         var img = document.createElement('img');
-        // The onload is needed by some browsers per http://stackoverflow.com/a/4776378/271577
+        // The onload is needed by some browsers per https://stackoverflow.com/a/4776378/271577
         img.addEventListener('load', function () {
           ctx.drawImage(img, 0, 0);
         });
@@ -2045,12 +2004,12 @@
         var ctx = /** @type {CanvasRenderingContext2D} */
         canvas.getContext('2d');
         var img = document.createElement('img');
-        // The onload is needed by some browsers per http://stackoverflow.com/a/4776378/271577
+        // The onload is needed by some browsers per https://stackoverflow.com/a/4776378/271577
         img.addEventListener('load', function () {
           ctx.drawImage(img, 0, 0);
         });
         img.src = o.dataURL;
-        return new e(/*#__PURE__*/function () {
+        return new TypesonPromise(/*#__PURE__*/function () {
           var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(resolve, reject) {
             var resp, _t;
             return _regenerator().w(function (_context) {
@@ -2093,7 +2052,7 @@
       replace: function replace(d) {
         return {
           // Ensure `length` gets preserved for revival
-          array: _toConsumableArray$1(d.data),
+          array: _toConsumableArray(d.data),
           width: d.width,
           height: d.height
         };
@@ -2110,13 +2069,13 @@
   var infinity = {
     infinity: {
       test: function test(x) {
-        return x === Number.POSITIVE_INFINITY;
+        return x === Infinity;
       },
       replace: function replace() {
         return 'Infinity';
       } /* n */,
       revive: function revive() {
-        return Number.POSITIVE_INFINITY;
+        return Infinity;
       } /* s */
     }
   };
@@ -2180,7 +2139,7 @@
         return toStringTag(x) === 'Map';
       },
       replace: function replace(mp) {
-        return _toConsumableArray$1(mp.entries());
+        return mp.entries().toArray();
       },
       revive: function revive(entries) {
         return new Map(entries);
@@ -2200,7 +2159,7 @@
         return 'NaN';
       } /* n */,
       revive: function revive() {
-        return Number.NaN;
+        return NaN;
       } /* s */
     }
   };
@@ -2211,13 +2170,13 @@
   var negativeInfinity = {
     negativeInfinity: {
       test: function test(x) {
-        return x === Number.NEGATIVE_INFINITY;
+        return x === -Infinity;
       },
       replace: function replace() {
         return '-Infinity';
       } /* n */,
       revive: function revive() {
-        return Number.NEGATIVE_INFINITY;
+        return -Infinity;
       } /* s */
     }
   };
@@ -2246,7 +2205,7 @@
   var nonbuiltinIgnore = {
     nonbuiltinIgnore: {
       test: function test(x) {
-        return x && _typeof$1(x) === 'object' && !Array.isArray(x) && !['Object',
+        return x && _typeof(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
@@ -2265,7 +2224,7 @@
     // String Object (not primitive string which need no type spec)
     StringObject: {
       test: function test(x) {
-        return toStringTag(x) === 'String' && _typeof$1(x) === 'object';
+        return toStringTag(x) === 'String' && _typeof(x) === 'object';
       },
       replace: String,
       // convert to primitive string
@@ -2276,7 +2235,7 @@
     // Boolean Object (not primitive boolean which need no type spec)
     BooleanObject: {
       test: function test(x) {
-        return toStringTag(x) === 'Boolean' && _typeof$1(x) === 'object';
+        return toStringTag(x) === 'Boolean' && _typeof(x) === 'object';
       },
       replace: function replace(o) {
         // convert to primitive boolean
@@ -2290,7 +2249,7 @@
     // Number Object (not primitive number which need no type spec)
     NumberObject: {
       test: function test(x) {
-        return toStringTag(x) === 'Number' && _typeof$1(x) === 'object';
+        return toStringTag(x) === 'Number' && _typeof(x) === 'object';
       },
       replace: Number,
       // convert to primitive number
@@ -2309,7 +2268,7 @@
         return toStringTag(x) === 'Promise';
       },
       replaceAsync: function replaceAsync(prom) {
-        return new e(/*#__PURE__*/function () {
+        return new TypesonPromise(/*#__PURE__*/function () {
           var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(resolve) {
             var _t, _t2, _t3;
             return _regenerator().w(function (_context) {
@@ -2381,7 +2340,7 @@
   var resurrectable = {
     resurrectable: {
       test: function test(x) {
-        return x && !Array.isArray(x) && ['object', 'function', 'symbol'].includes(_typeof$1(x));
+        return x && !Array.isArray(x) && ['object', 'function', 'symbol'].includes(_typeof(x));
       },
       replace: function replace(rsrrctble) {
         var uuid = generateUUID();
@@ -2403,7 +2362,7 @@
         return toStringTag(x) === 'Set';
       },
       replace: function replace(st) {
-        return _toConsumableArray$1(st.values());
+        return st.values().toArray();
       },
       revive: function revive(values) {
         return new Set(values);
@@ -2417,7 +2376,7 @@
   var symbol = {
     symbol: {
       test: function test(x) {
-        return _typeof$1(x) === 'symbol';
+        return _typeof(x) === 'symbol';
       },
       replace: function replace(sym) {
         return {
@@ -2477,7 +2436,7 @@
     // Those constructors are added in ES6 as a group.
     // If we have Int8Array, we can assume the rest also exists.
 
-    [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array].concat(_toConsumableArray$1(typeof BigInt64Array === 'function' ? [BigInt64Array, BigUint64Array]
+    [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array].concat(_toConsumableArray(typeof BigInt64Array === 'function' ? [BigInt64Array, BigUint64Array]
     /* c8 ignore next */ : [])).forEach(function (TypedArray) {
       return create$1(TypedArray);
     });
@@ -2570,7 +2529,7 @@
   if (typeof Int8Array === 'function') {
     // Those constructors are added in ES6 as a group.
     // If we have Int8Array, we can assume the rest also exists.
-    [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array].concat(_toConsumableArray$1(typeof BigInt64Array === 'function' ? [BigInt64Array, BigUint64Array]
+    [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array].concat(_toConsumableArray(typeof BigInt64Array === 'function' ? [BigInt64Array, BigUint64Array]
     /* c8 ignore next */ : [])).forEach(function (TypedArray) {
       return create(TypedArray);
     });
@@ -2593,7 +2552,7 @@
       revive: function revive() {
         // Will add `undefined` (returning `undefined` would instead
         //   avoid explicitly setting)
-        return new s();
+        return new Undefined();
       } /* s */
     }
   };
@@ -2607,7 +2566,7 @@
         return isUserObject(x);
       },
       replace: function replace(n) {
-        return _objectSpread2$1({}, n);
+        return _objectSpread2({}, n);
       },
       revive: function revive(s) {
         return s;
@@ -2636,7 +2595,7 @@
             //   `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;
+            return String(Number(k)) !== k;
           })) {
             stateObj.iterateIn = 'object';
             stateObj.addLength = true;
@@ -2662,7 +2621,7 @@
         // No map here as may be a sparse array (including
         //   with `length` set)
         Object.entries(o).forEach(function (_ref) {
-          var _ref2 = _slicedToArray$1(_ref, 2),
+          var _ref2 = _slicedToArray(_ref, 2),
             key = _ref2[0],
             val = _ref2[1];
           arr[key] = val;
@@ -2846,7 +2805,7 @@
         //   value, so we check `typeof`
         'symbol',
         // All functions including bound function exotic objects
-        'function'].includes(_typeof$1(val)) || [
+        'function'].includes(_typeof(val)) || [
         // A non-array exotic object
         'Arguments',
         // A non-array exotic object
@@ -2869,7 +2828,7 @@
         ((stringTag === 'Blob' || stringTag === 'File') &&
             val.isClosed) ||
         */
-        val && _typeof$1(val) === 'object' &&
+        val && _typeof(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')) {
@@ -2893,10 +2852,10 @@
   //   built-in into ecmasript standard.
   ];
 
-  exports.JSON_TYPES = u;
-  exports.Typeson = c;
-  exports.TypesonPromise = e;
-  exports.Undefined = s;
+  exports.JSON_TYPES = i$1;
+  exports.Typeson = Typeson;
+  exports.TypesonPromise = TypesonPromise;
+  exports.Undefined = Undefined;
   exports.arrayNonindexKeys = arrayNonindexKeys;
   exports.arraybuffer = arraybuffer;
   exports.bigint = bigint;