typeson-registry 5.0.0 → 7.0.0

package/dist/index.umd.js

@@ -4,6 +4,33 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.TypesonNamespace = {}));
 })(this, (function (exports) { 'use strict';
 
+  function _iterableToArrayLimit(arr, i) {
+    var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+    if (null != _i) {
+      var _s,
+        _e,
+        _x,
+        _r,
+        _arr = [],
+        _n = !0,
+        _d = !1;
+      try {
+        if (_x = (_i = _i.call(arr)).next, 0 === i) {
+          if (Object(_i) !== _i) return;
+          _n = !1;
+        } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+      } catch (err) {
+        _d = !0, _e = err;
+      } finally {
+        try {
+          if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+        } finally {
+          if (_d) throw _e;
+        }
+      }
+      return _arr;
+    }
+  }
   function ownKeys$1(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
@@ -401,12 +428,18 @@
     }
     return obj;
   }
+  function _slicedToArray$1(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
+  }
   function _toConsumableArray$1(arr) {
     return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
   }
   function _arrayWithoutHoles(arr) {
     if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
   }
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
   function _iterableToArray(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
   }
@@ -426,6 +459,9 @@
   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 _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 _toPrimitive(input, hint) {
     if (typeof input !== "object" || input === null) return input;
     var prim = input[Symbol.toPrimitive];
@@ -499,21 +535,21 @@
       if (null != r) {
         var n,
           o,
-          a,
           i,
+          a,
           c = [],
           s = !0,
           u = !1;
         try {
-          if (a = (r = r.call(e)).next, 0 === t) {
+          if (i = (r = r.call(e)).next, 0 === t) {
             if (Object(r) !== r) return;
             s = !1;
-          } else for (; !(s = (n = a.call(r)).done) && (c.push(n.value), c.length !== t); s = !0);
+          } else for (; !(s = (n = i.call(r)).done) && (c.push(n.value), c.length !== t); s = !0);
         } catch (e) {
           u = !0, o = e;
         } finally {
           try {
-            if (!s && null != r["return"] && (i = r["return"](), Object(i) !== i)) return;
+            if (!s && null != r["return"] && (a = r["return"](), Object(a) !== a)) return;
           } finally {
             if (u) throw o;
           }
@@ -561,7 +597,11 @@
   var e = _createClass(function TypesonPromise(e) {
     _classCallCheck(this, TypesonPromise), this.p = new Promise(e);
   });
-  e.__typeson__type__ = "TypesonPromise", "undefined" != typeof Symbol && (e.prototype[Symbol.toStringTag] = "TypesonPromise"), e.prototype.then = function (t, r) {
+  e.__typeson__type__ = "TypesonPromise", "undefined" != typeof Symbol && Object.defineProperty(e.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) {
@@ -571,7 +611,7 @@
       }).then(e, o);
     });
   }, e.prototype["catch"] = function (e) {
-    return this.then(null, e);
+    return this.then(function () {}, e);
   }, e.resolve = function (t) {
     return new e(function (e) {
       e(t);
@@ -580,42 +620,50 @@
     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,
-    o = r.toString;
+  }, 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);
+    });
+  }, 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);
+    });
+  }, 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);
+    });
+  };
+  var t = Object.hasOwn,
+    r = Object.getPrototypeOf;
   function isThenable(e, t) {
     return isObject(e) && "function" == typeof e.then && (!t || "function" == typeof e["catch"]);
   }
   function toStringTag(e) {
-    return t.call(e).slice(8, -1);
+    return Object.prototype.toString.call(e).slice(8, -1);
   }
-  function hasConstructorOf(e, t) {
+  function hasConstructorOf(e, n) {
     if (!e || "object" !== _typeof(e)) return !1;
-    var a = n(e);
-    if (!a) return null === t;
-    var i = r.call(a, "constructor") && a.constructor;
-    return "function" != typeof i ? null === t : t === i || null !== t && o.call(i) === o.call(t) || "function" == typeof t && "string" == typeof i.__typeson__type__ && i.__typeson__type__ === t.__typeson__type__;
+    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 isPlainObject(e) {
-    return !(!e || "Object" !== toStringTag(e)) && (!n(e) || hasConstructorOf(e, Object));
+    return !(!e || "Object" !== toStringTag(e)) && (!r(e) || hasConstructorOf(e, Object));
   }
   function isUserObject(e) {
     if (!e || "Object" !== toStringTag(e)) return !1;
-    var t = n(e);
+    var t = r(e);
     return !t || hasConstructorOf(e, Object) || isUserObject(t);
   }
   function isObject(e) {
-    return e && "object" === _typeof(e);
+    return null !== e && "object" === _typeof(e);
   }
   function escapeKeyPathComponent(e) {
     return e.replace(/''/g, "''''").replace(/^$/, "''").replace(/~/g, "~0").replace(/\./g, "~1");
@@ -625,6 +673,7 @@
   }
   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 (r > -1) {
       var n = e[unescapeKeyPathComponent(t.slice(0, r))];
@@ -634,6 +683,7 @@
   }
   function setAtKeyPath(e, t, r) {
     if ("" === t) return r;
+    if (!e || "object" !== _typeof(e)) throw new TypeError("Unexpected non-object type");
     var n = t.indexOf(".");
     return n > -1 ? setAtKeyPath(e[unescapeKeyPathComponent(t.slice(0, n))], t.slice(n + 1), r) : (e[unescapeKeyPathComponent(t)] = r, e);
   }
@@ -643,10 +693,10 @@
   function _await(e, t, r) {
     return r ? t ? t(e) : e : (e && e.then || (e = Promise.resolve(e)), t ? e.then(t) : e);
   }
-  var a = Object.keys,
+  var n = Object.keys,
+    o = Object.hasOwn,
     i$1 = Array.isArray,
-    c = {}.hasOwnProperty,
-    s = ["type", "replaced", "iterateIn", "iterateUnsetNumeric"];
+    a = ["type", "replaced", "iterateIn", "iterateUnsetNumeric", "addLength"];
   function _async(e) {
     return function () {
       for (var t = [], r = 0; r < arguments.length; r++) t[r] = arguments[r];
@@ -658,12 +708,13 @@
     };
   }
   function nestedPathsFirst(e, t) {
+    var r, n;
     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 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 u = function () {
+  var c = function () {
       function Typeson(e) {
         _classCallCheck(this, Typeson), this.options = e, this.plainObjectReplacers = [], this.nonplainObjectReplacers = [], this.revivers = {}, this.types = {};
       }
@@ -735,193 +786,203 @@
         }
       }, {
         key: "encapsulate",
-        value: function encapsulate(t, r, n) {
-          var o = _async(function (t, r) {
+        value: function encapsulate(t, r, c) {
+          var s = this,
+            u = _objectSpread2(_objectSpread2({
+              sync: !0
+            }, this.options), c),
+            y = u.sync,
+            p = {},
+            l = [],
+            f = [],
+            v = [],
+            h = !("cyclic" in u) || u.cyclic,
+            d = u.encapsulateObserver,
+            b = function finish(e) {
+              var t = Object.values(p);
+              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 = p : e = {
+                  $: e,
+                  $types: {
+                    $: p
+                  }
+                };
+              } else isObject(e) && o(e, "$types") && (e = {
+                $: e,
+                $types: !0
+              });
+              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 a = !1,
+                  var o = !1,
                     i = [],
-                    c = _slicedToArray(r.splice(0, 1), 1),
-                    s = _slicedToArray(c[0], 7),
-                    u = s[0],
-                    p = s[2],
-                    l = s[3],
-                    y = s[4],
-                    f = s[5],
-                    h = s[6],
-                    v = _encapsulate(u, n, p, l, i, !0, h),
-                    b = hasConstructorOf(v, e);
+                    a = _slicedToArray(r.splice(0, 1), 1),
+                    c = _slicedToArray(a[0], 7),
+                    s = c[0],
+                    u = c[2],
+                    y = c[3],
+                    p = c[4],
+                    l = c[5],
+                    f = c[6],
+                    v = m(s, n, u, y, i, !0, f),
+                    h = 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[f] = e;
-                      var r = o(t, i);
-                      return a = !0, r;
+                    if (s && h) return _await(v.p, function (e) {
+                      p[l] = e;
+                      var r = _(t, i);
+                      return o = !0, r;
                     });
                   }, function (e) {
-                    return a ? e : (u ? y[f] = v : t = b ? v.p : v, o(t, i));
+                    return o ? e : (s ? p[l] = v : t = h ? v.p : v, _(t, i));
                   });
                 }))), function () {
                   return t;
                 });
               });
             }),
-            u = (n = _objectSpread2(_objectSpread2({
-              sync: !0
-            }, this.options), n)).sync,
-            p = this,
-            l = {},
-            y = [],
-            f = [],
-            h = [],
-            v = !("cyclic" in n) || n.cyclic,
-            b = n.encapsulateObserver,
-            d = _encapsulate("", t, v, r || {}, h);
-          function finish(e) {
-            var t = Object.values(l);
-            if (n.iterateNone) return t.length ? t[0] : getJSONType(e);
-            if (t.length) {
-              if (n.returnTypeNames) return _toConsumableArray(new Set(t));
-              e && isPlainObject(e) && !c.call(e, "$types") ? e.$types = l : e = {
-                $: e,
-                $types: {
-                  $: l
-                }
-              };
-            } else isObject(e) && c.call(e, "$types") && (e = {
-              $: e,
-              $types: !0
-            });
-            return !n.returnTypeNames && e;
-          }
-          function _adaptBuiltinStateObjectProperties(e, t, r) {
-            Object.assign(e, t);
-            var n = s.map(function (t) {
-              var r = e[t];
-              return delete e[t], r;
-            });
-            r(), s.forEach(function (t, r) {
-              e[t] = n[r];
-            });
-          }
-          function _encapsulate(t, r, o, s, u, h, v) {
-            var d,
-              _ = {},
-              O = _typeof(r),
-              j = b ? function (n) {
-                var a = v || s.type || getJSONType(r);
-                b(Object.assign(n || _, {
-                  keypath: t,
-                  value: r,
-                  cyclic: o,
-                  stateObj: s,
-                  promisesData: u,
-                  resolvingTypesonPromise: h,
-                  awaitingTypesonPromise: hasConstructorOf(r, e)
-                }, {
-                  type: a
-                }));
-              } : null;
-            if (["string", "boolean", "number", "undefined"].includes(O)) return void 0 === r || Number.isNaN(r) || r === Number.NEGATIVE_INFINITY || r === Number.POSITIVE_INFINITY ? (d = s.replaced ? r : replace(t, r, s, u, !1, h, j)) !== r && (_ = {
-              replaced: d
-            }) : d = r, j && j(), d;
-            if (null === r) return j && j(), r;
-            if (o && !s.iterateIn && !s.iterateUnsetNumeric && r && "object" === _typeof(r)) {
-              var m = y.indexOf(r);
-              if (!(m < 0)) return l[t] = "#", j && j({
-                cyclicKeypath: f[m]
-              }), "#" + f[m];
-              !0 === o && (y.push(r), f.push(t));
-            }
-            var g,
-              S = isPlainObject(r),
-              P = i$1(r),
-              T = (S || P) && (!p.plainObjectReplacers.length || s.replaced) || s.iterateIn ? r : replace(t, r, s, u, S || P, null, j);
-            if (T !== r ? (d = T, _ = {
-              replaced: T
-            }) : "" === t && hasConstructorOf(r, e) ? (u.push([t, r, o, s, void 0, void 0, s.type]), d = r) : P && "object" !== s.iterateIn || "array" === s.iterateIn ? (g = new Array(r.length), _ = {
-              clone: g
-            }) : (["function", "symbol"].includes(_typeof(r)) || "toJSON" in r || hasConstructorOf(r, e) || hasConstructorOf(r, Promise) || hasConstructorOf(r, ArrayBuffer)) && !S && "object" !== s.iterateIn ? d = r : (g = {}, s.addLength && (g.length = r.length), _ = {
-              clone: g
-            }), j && j(), n.iterateNone) return g || d;
-            if (!g) return d;
-            if (s.iterateIn) {
-              var w = function _loop(n) {
-                var a = {
-                  ownKeys: c.call(r, n)
+            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,
+                _ = {},
+                m = _typeof(r),
+                g = 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(m)) 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, !1, v, g)) !== r && (_ = {
+                replaced: b
+              }) : b = r, g && g(), b;
+              if (null === r) return g && g(), r;
+              if (a && !c.iterateIn && !c.iterateUnsetNumeric && r && "object" === _typeof(r)) {
+                var S = l.indexOf(r);
+                if (!(S < 0)) return p[t] = "#", g && g({
+                  cyclicKeypath: f[S]
+                }), "#" + f[S];
+                !0 === a && (l.push(r), f.push(t));
+              }
+              var P,
+                T,
+                w = isPlainObject(r),
+                A = i$1(r),
+                C = (w || A) && (!s.plainObjectReplacers.length || c.replaced) || c.iterateIn ? r : j(t, r, c, y, w || A, null, g);
+              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 ? (P = new Array(r.length), _ = {
+                clone: P
+              }) : (["function", "symbol"].includes(_typeof(r)) || "toJSON" in r || hasConstructorOf(r, e) || hasConstructorOf(r, Promise) || hasConstructorOf(r, ArrayBuffer)) && !w && "object" !== c.iterateIn ? b = r : (P = {}, c.addLength && (P.length = r.length), _ = {
+                clone: P
+              }), g && g(), u.iterateNone) return null !== (T = P) && void 0 !== T ? T : b;
+              if (!P) return b;
+              if (c.iterateIn) {
+                var k = function _loop(n) {
+                  var i = {
+                    ownKeys: o(r, n)
+                  };
+                  O(c, i, function () {
+                    var o = t + (t ? "." : "") + escapeKeyPathComponent(n),
+                      i = _encapsulate(o, r[n], Boolean(a), c, y, v);
+                    hasConstructorOf(i, e) ? y.push([o, i, Boolean(a), c, P, n, c.type]) : void 0 !== i && (P[n] = i);
+                  });
                 };
-                _adaptBuiltinStateObjectProperties(s, a, function () {
-                  var a = t + (t ? "." : "") + escapeKeyPathComponent(n),
-                    i = _encapsulate(a, r[n], Boolean(o), s, u, h);
-                  hasConstructorOf(i, e) ? u.push([a, i, Boolean(o), s, g, n, s.type]) : void 0 !== i && (g[n] = i);
+                for (var N in r) k(N);
+                g && g({
+                  endIterateIn: !0,
+                  end: !0
                 });
-              };
-              for (var A in r) w(A);
-              j && j({
-                endIterateIn: !0,
+              } else n(r).forEach(function (n) {
+                var o = t + (t ? "." : "") + escapeKeyPathComponent(n);
+                O(c, {
+                  ownKeys: !0
+                }, function () {
+                  var t = _encapsulate(o, r[n], Boolean(a), c, y, v);
+                  hasConstructorOf(t, e) ? y.push([o, t, Boolean(a), c, P, n, c.type]) : void 0 !== t && (P[n] = t);
+                });
+              }), g && g({
+                endIterateOwn: !0,
                 end: !0
               });
-            } else a(r).forEach(function (n) {
-              var a = t + (t ? "." : "") + escapeKeyPathComponent(n);
-              _adaptBuiltinStateObjectProperties(s, {
-                ownKeys: !0
-              }, function () {
-                var t = _encapsulate(a, r[n], Boolean(o), s, u, h);
-                hasConstructorOf(t, e) ? u.push([a, t, Boolean(o), s, g, n, s.type]) : void 0 !== t && (g[n] = t);
-              });
-            }), j && j({
-              endIterateOwn: !0,
-              end: !0
-            });
-            if (s.iterateUnsetNumeric) {
-              for (var C = r.length, k = function _loop2(n) {
-                  if (!(n in r)) {
-                    var a = t + (t ? "." : "") + n;
-                    _adaptBuiltinStateObjectProperties(s, {
-                      ownKeys: !1
-                    }, function () {
-                      var t = _encapsulate(a, void 0, Boolean(o), s, u, h);
-                      hasConstructorOf(t, e) ? u.push([a, t, Boolean(o), s, g, n, s.type]) : void 0 !== t && (g[n] = t);
-                    });
+              if (c.iterateUnsetNumeric) {
+                for (var I = r.length, E = function _loop2(n) {
+                    if (!(n in r)) {
+                      var o = "".concat(t).concat(t ? "." : "").concat(n);
+                      O(c, {
+                        ownKeys: !1
+                      }, function () {
+                        var t = _encapsulate(o, void 0, Boolean(a), c, y, v);
+                        hasConstructorOf(t, e) ? y.push([o, t, Boolean(a), c, P, n, c.type]) : void 0 !== t && (P[n] = t);
+                      });
+                    }
+                  }, K = 0; K < I; K++) E(K);
+                g && g({
+                  endIterateUnsetNumeric: !0,
+                  end: !0
+                });
+              }
+              return P;
+            },
+            j = function replace(e, t, r, n, o, i, a) {
+              for (var c = o ? s.plainObjectReplacers : s.nonplainObjectReplacers, u = c.length; u--;) {
+                var l = c[u];
+                if (l.test(t, r)) {
+                  var f = l.type;
+                  if (s.revivers[f]) {
+                    var v = p[e];
+                    p[e] = v ? [f].concat(v) : f;
                   }
-                }, N = 0; N < C; N++) k(N);
-              j && j({
-                endIterateUnsetNumeric: !0,
-                end: !0
-              });
-            }
-            return g;
-          }
-          function replace(e, t, r, n, o, a, i) {
-            for (var c = o ? p.plainObjectReplacers : p.nonplainObjectReplacers, s = c.length; s--;) {
-              var y = c[s];
-              if (y.test(t, r)) {
-                var f = y.type;
-                if (p.revivers[f]) {
-                  var h = l[e];
-                  l[e] = h ? [f].concat(h) : f;
+                  if (Object.assign(r, {
+                    type: f,
+                    replaced: !0
+                  }), (y || !l.replaceAsync) && !l.replace) return a && a({
+                    typeDetected: !0
+                  }), m(e, t, h && "readonly", r, n, i, f);
+                  a && a({
+                    replacing: !0
+                  });
+                  var d = void 0;
+                  if (y || !l.replaceAsync) {
+                    if (void 0 === l.replace) throw new TypeError("Missing replacer");
+                    d = l.replace(t, r);
+                  } else d = l.replaceAsync(t, r);
+                  return m(e, d, h && "readonly", r, n, i, f);
                 }
-                return Object.assign(r, {
-                  type: f,
-                  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, a, f)) : (i && i({
-                  typeDetected: !0
-                }), _encapsulate(e, t, v && "readonly", r, n, a, f));
               }
-            }
-            return t;
-          }
-          return h.length ? u && n.throwOnBadSyncType ? function () {
+              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(o(d, h)).then(finish) : !u && n.throwOnBadSyncType ? function () {
-            throw new TypeError("Async method requested but sync result obtained");
-          }() : n.stringification && u ? [finish(d)] : u ? finish(d) : Promise.resolve(finish(d));
+          }() : 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",
@@ -944,104 +1005,119 @@
       }, {
         key: "revive",
         value: function revive(t, r) {
-          var n = t && t.$types;
-          if (!n) return t;
-          if (!0 === n) return t.$;
-          var o = (r = _objectSpread2(_objectSpread2({
+          var o = this,
+            a = _objectSpread2(_objectSpread2({
               sync: !0
-            }, this.options), r)).sync,
-            c = [],
-            s = {},
-            u = !0;
-          n.$ && isPlainObject(n.$) && (t = t.$, n = n.$, u = !1);
-          var l = this;
-          function executeReviver(e, t) {
-            var r = _slicedToArray(l.revivers[e] || [], 1)[0];
-            if (!r) throw new Error("Unregistered type: " + e);
-            return o && !("revive" in r) ? t : r[o && r.revive ? "revive" : !o && r.reviveAsync ? "reviveAsync" : "revive"](t, s);
+            }, 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 y = [];
+          if (!t || "object" !== _typeof(t) || Array.isArray(t)) return finishRevival(t);
+          var u = t.$types;
+          if (!0 === u) return finishRevival(t.$);
+          if (!u || "object" !== _typeof(u) || Array.isArray(u)) return finishRevival(t);
+          var y = [],
+            p = {},
+            l = !0;
+          u.$ && isPlainObject(u.$) && (t = t.$, u = u.$, l = !1);
+          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, p);
+              if (n.revive) return n.revive(t, p);
+              throw new Error("Missing reviver");
+            },
+            v = [];
           function checkUndefined(e) {
-            return hasConstructorOf(e, p) ? void 0 : e;
+            return hasConstructorOf(e, s) ? void 0 : e;
           }
-          var f,
-            h = function revivePlainObjects() {
+          var h,
+            d = function revivePlainObjects() {
               var r = [];
-              if (Object.entries(n).forEach(function (e) {
+              if (!u) throw new Error("Found bad `types`");
+              if (Object.entries(u).forEach(function (e) {
                 var t = _slicedToArray(e, 2),
-                  o = t[0],
-                  a = t[1];
-                "#" !== a && [].concat(a).forEach(function (e) {
-                  _slicedToArray(l.revivers[e] || [null, {}], 2)[1].plain && (r.push({
-                    keypath: o,
+                  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 n[o]);
+                  }), delete u[n]);
                 });
               }), r.length) return r.sort(nestedPathsFirst).reduce(function reducer(r, n) {
                 var o = n.keypath,
-                  a = n.type;
+                  i = n.type;
                 if (isThenable(r)) return r.then(function (e) {
                   return reducer(e, {
                     keypath: o,
-                    type: a
+                    type: i
                   });
                 });
-                var i = getByKeyPath(t, o);
-                if (hasConstructorOf(i = executeReviver(a, i), e)) return i.then(function (e) {
+                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 c = setAtKeyPath(t, o, i);
-                c === i && (t = c);
+                var c = setAtKeyPath(t, o, a);
+                c === a && (t = c);
               }, void 0);
             }();
-          return hasConstructorOf(h, e) ? f = h.then(function () {
+          return hasConstructorOf(d, e) ? h = d.then(function () {
             return t;
-          }) : (f = function _revive(t, r, o, s, l) {
-            if (!u || "$types" !== t) {
-              var f = n[t],
+          }) : (h = function _revive(t, r, o, a, c) {
+            if (!l || "$types" !== t) {
+              var p = u[t],
                 h = i$1(r);
               if (h || isPlainObject(r)) {
-                var v = h ? new Array(r.length) : {};
-                for (a(r).forEach(function (n) {
-                  var a = _revive(t + (t ? "." : "") + escapeKeyPathComponent(n), r[n], o || v, v, n),
-                    i = function set(e) {
-                      return hasConstructorOf(e, p) ? v[n] = void 0 : void 0 !== e && (v[n] = e), e;
+                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(a, e) ? y.push(a.then(function (e) {
-                    return i(e);
-                  })) : i(a);
-                }), r = v; c.length;) {
-                  var b = _slicedToArray(c[0], 4),
-                    d = b[0],
-                    _ = b[1],
-                    O = b[2],
+                  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],
-                    m = getByKeyPath(d, _);
-                  if (void 0 === m) break;
-                  O[j] = m, c.splice(0, 1);
+                    g = getByKeyPath(_, O);
+                  if (void 0 === g) break;
+                  m[j] = g, y.splice(0, 1);
                 }
               }
-              if (!f) return r;
-              if ("#" === f) {
-                var g = getByKeyPath(o, r.slice(1));
-                return void 0 === g && c.push([o, r.slice(1), s, l]), g;
+              if (!p) return r;
+              if ("#" === p) {
+                var S = getByKeyPath(o, r.slice(1));
+                return void 0 === S && y.push([o, r.slice(1), a, c]), S;
               }
-              return [].concat(f).reduce(function reducer(t, r) {
-                return hasConstructorOf(t, e) ? t.then(function (e) {
+              return [].concat(p).reduce(function reducer(t, r) {
+                if (hasConstructorOf(t, e)) return t.then(function (e) {
                   return reducer(e, r);
-                }) : executeReviver(r, t);
+                });
+                if ("string" != typeof r) throw new TypeError("Bad type JSON");
+                return f(r, t);
               }, r);
             }
-          }("", t, null), y.length && (f = e.resolve(f).then(function (t) {
-            return e.all([t].concat(y));
+          }("", 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(f) ? o && r.throwOnBadSyncType ? function () {
+          }))), isThenable(h) ? c && a.throwOnBadSyncType ? function () {
             throw new TypeError("Sync method requested but async result obtained");
-          }() : hasConstructorOf(f, e) ? f.p.then(checkUndefined) : f : !o && r.throwOnBadSyncType ? function () {
+          }() : hasConstructorOf(h, e) ? h.p.then(checkUndefined) : h : !c && a.throwOnBadSyncType ? function () {
             throw new TypeError("Async method requested but sync result obtained");
-          }() : o ? checkUndefined(f) : Promise.resolve(checkUndefined(f));
+          }() : c ? checkUndefined(h) : Promise.resolve(checkUndefined(h));
         }
       }, {
         key: "reviveSync",
@@ -1064,89 +1140,96 @@
       }, {
         key: "register",
         value: function register(e, t) {
-          var r = this;
-          t = t || {};
-          var n = function R(e) {
-            i$1(e) ? e.forEach(function (e) {
-              return R(e);
-            }) : e && a(e).forEach(function (n) {
-              if ("#" === n) throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");
-              if (l.includes(n)) throw new TypeError("Plain JSON object types are reserved as type names");
-              var o = e[n],
-                a = o && o.testPlainObjects ? r.plainObjectReplacers : r.nonplainObjectReplacers,
-                c = a.filter(function (e) {
-                  return e.type === n;
-                });
-              if (c.length && (a.splice(a.indexOf(c[0]), 1), delete r.revivers[n], delete r.types[n]), "function" == typeof o) {
-                var s = o;
-                o = {
-                  test: function test(e) {
-                    return e && e.constructor === s;
-                  },
-                  replace: function replace(e) {
-                    return _objectSpread2({}, e);
-                  },
-                  revive: function revive(e) {
-                    return Object.assign(Object.create(s.prototype), e);
+          var r = this,
+            o = null != t ? t : {},
+            a = function R(e) {
+              i$1(e) ? e.forEach(function (e) {
+                return R(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 p = _slicedToArray(a, 3);
+                  a = {
+                    test: p[0],
+                    replace: p[1],
+                    revive: p[2]
+                  };
+                }
+                if (null !== (n = a) && void 0 !== n && n.test) {
+                  var l = {
+                    type: t,
+                    test: a.test.bind(a)
+                  };
+                  a.replace && (l.replace = a.replace.bind(a)), a.replaceAsync && (l.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, l) : r.nonplainObjectReplacers.splice(f, 0, l), 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
+                    }];
                   }
-                };
-              } else if (i$1(o)) {
-                var u = _slicedToArray(o, 3);
-                o = {
-                  test: u[0],
-                  replace: u[1],
-                  revive: u[2]
-                };
-              }
-              if (o && o.test) {
-                var p = {
-                  type: n,
-                  test: o.test.bind(o)
-                };
-                o.replace && (p.replace = o.replace.bind(o)), o.replaceAsync && (p.replaceAsync = o.replaceAsync.bind(o));
-                var y = "number" == typeof t.fallback ? t.fallback : t.fallback ? 0 : Number.POSITIVE_INFINITY;
-                if (o.testPlainObjects ? r.plainObjectReplacers.splice(y, 0, p) : r.nonplainObjectReplacers.splice(y, 0, p), o.revive || o.reviveAsync) {
-                  var f = {};
-                  o.revive && (f.revive = o.revive.bind(o)), o.reviveAsync && (f.reviveAsync = o.reviveAsync.bind(o)), r.revivers[n] = [f, {
-                    plain: o.testPlainObjects
-                  }];
+                  r.types[t] = a;
                 }
-                r.types[n] = o;
-              }
-            });
-          };
+              });
+            };
           return [].concat(e).forEach(function (e) {
-            return n(e);
+            return a(e);
           }), this;
         }
       }]), Typeson;
     }(),
-    p = _createClass(function Undefined() {
+    s = _createClass(function Undefined() {
       _classCallCheck(this, Undefined);
     });
-  p.__typeson__type__ = "TypesonUndefined";
-  var l = ["null", "boolean", "number", "string", "array", "object"];
+  s.__typeson__type__ = "TypesonUndefined";
+  var u = ["null", "boolean", "number", "string", "array", "object"];
 
   /*
    * base64-arraybuffer
    * https://github.com/niklasvh/base64-arraybuffer
    *
-   * Copyright (c) 2017 Brett Zamir, 2012 Niklas von Hertzen
+   * Copyright (c) 2017-2023 Brett Zamir, 2012 Niklas von Hertzen
    * Licensed under the MIT license.
    */
-  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; // Use a lookup table to find the index.
 
+  /**
+   * @typedef {number} Integer
+   */
+
+  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.codePointAt(i)] = i;
+    lookup[/** @type {number} */chars.codePointAt(i)] = i;
   }
+
   /**
    * @param {ArrayBuffer} arraybuffer
-   * @param {Integer} byteOffset
-   * @param {Integer} lngth
+   * @param {Integer} [byteOffset]
+   * @param {Integer} [lngth]
    * @returns {string}
    */
-
   var encode = function encode(arraybuffer, byteOffset, lngth) {
     if (lngth === null || lngth === undefined) {
       lngth = arraybuffer.byteLength; // Needed for Safari
@@ -1170,13 +1253,16 @@
     }
     return base64;
   };
+
   /**
    * @param {string} base64
    * @returns {ArrayBuffer}
    */
-
   var decode = function decode(base64) {
     var len = base64.length;
+    if (len % 4) {
+      throw new Error('Bad base64 length: not divisible by four');
+    }
     var bufferLength = base64.length * 0.75;
     var p = 0;
     var encoded1, encoded2, encoded3, encoded4;
@@ -1189,10 +1275,12 @@
     var arraybuffer = new ArrayBuffer(bufferLength),
       bytes = new Uint8Array(arraybuffer);
     for (var _i2 = 0; _i2 < len; _i2 += 4) {
-      encoded1 = lookup[base64.codePointAt(_i2)];
-      encoded2 = lookup[base64.codePointAt(_i2 + 1)];
-      encoded3 = lookup[base64.codePointAt(_i2 + 2)];
-      encoded4 = lookup[base64.codePointAt(_i2 + 3)];
+      // We know the result will not be undefined, as we have a text
+      //   length divisible by four
+      encoded1 = lookup[/** @type {number} */base64.codePointAt(_i2)];
+      encoded2 = lookup[/** @type {number} */base64.codePointAt(_i2 + 1)];
+      encoded3 = lookup[/** @type {number} */base64.codePointAt(_i2 + 2)];
+      encoded4 = lookup[/** @type {number} */base64.codePointAt(_i2 + 3)];
       bytes[p++] = encoded1 << 2 | encoded2 >> 4;
       bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
       bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
@@ -1200,12 +1288,20 @@
     return arraybuffer;
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var arraybuffer = {
     arraybuffer: {
       test: function test(x) {
         return toStringTag(x) === 'ArrayBuffer';
       },
-      replace: function replace(b, stateObj) {
+      replace: function replace(b,
+      /**
+       * @type {import('typeson').StateObject &
+       *   {buffers?: ArrayBuffer[]}}
+       */
+      stateObj) {
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
@@ -1218,14 +1314,23 @@
         stateObj.buffers.push(b);
         return encode(b);
       },
-      revive: function revive(b64, stateObj) {
+      revive: function revive(b64,
+      /**
+       * @type {import('typeson').StateObject &
+       *   {buffers?: ArrayBuffer[]}}
+       */
+      stateObj) {
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
         if (_typeof$1(b64) === 'object') {
-          return stateObj.buffers[b64.index];
+          return stateObj.buffers[
+          /**
+           * @type {{index: import('typeson').Integer}}
+           */
+          b64.index];
         }
-        var buffer = decode(b64);
+        var buffer = decode( /** @type {string} */b64);
         stateObj.buffers.push(buffer);
         return buffer;
       }
@@ -1234,6 +1339,9 @@
 
   // See also typed-arrays!
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var bigintObject = {
     bigintObject: {
       test: function test(x) {
@@ -1243,27 +1351,33 @@
       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));
+        return new Object(BigInt( /** @type {string} */s));
       }
     }
   };
 
   /* globals BigInt */
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var bigint = {
     bigint: {
       test: function test(x) {
         return typeof x === 'bigint';
       },
       replace: String,
-      revive: BigInt
+      // eslint-disable-next-line unicorn/prefer-native-coercion-functions
+      revive: function revive(s) {
+        return BigInt( /** @type {string} */s);
+      }
     }
   };
 
   /**
    * Not currently in use internally, but provided for parity.
    * @param {ArrayBuffer} buf
-   * @returns {Uint8Array}
+   * @returns {string}
    */
 
   /**
@@ -1328,6 +1442,10 @@
   }
 
   /* globals XMLHttpRequest, Blob, FileReader */
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var blob = {
     blob: {
       test: function test(x) {
@@ -1350,9 +1468,9 @@
           stringContents: req.responseText
         };
       },
-      revive: function revive(_ref) {
-        var type = _ref.type,
-          stringContents = _ref.stringContents;
+      revive: function revive(obj) {
+        var type = /** @type {{type: string, stringContents: string}} */obj.type,
+          stringContents = /** @type {{type: string, stringContents: string}} */obj.stringContents;
         return new Blob([string2arraybuffer(stringContents)], {
           type: type
         });
@@ -1410,7 +1528,14 @@
     });
   }
 
+  /**
+   * @type {{[key: (symbol|string)]: any}}
+   */
   var cloneableObjectsByUUID = {};
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var cloneable = {
     cloneable: {
       test: function test(x) {
@@ -1425,20 +1550,24 @@
           encapsulated: encapsulated
         };
       },
-      revive: function revive(_ref) {
-        var uuid = _ref.uuid,
-          encapsulated = _ref.encapsulated;
+      revive: function revive(obj) {
+        var uuid = /** @type {{uuid: string, encapsulated: any}} */obj.uuid,
+          encapsulated = /** @type {{uuid: string, encapsulated: any}} */obj.encapsulated;
         return cloneableObjectsByUUID[uuid][Symbol["for"]('cloneRevive')](encapsulated);
       }
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var cryptokey = {
     cryptokey: {
       test: function test(x) {
         return toStringTag(x) === 'CryptoKey' && x.extractable;
       },
-      replaceAsync: function replaceAsync(key) {
+      replaceAsync: function replaceAsync( /** @type {CryptoKey} */
+      key) {
         return new e( /*#__PURE__*/function () {
           var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(resolve, reject) {
             var jwk;
@@ -1474,21 +1603,54 @@
           };
         }());
       },
-      revive: function revive(_ref2) {
-        var jwk = _ref2.jwk,
-          algorithm = _ref2.algorithm,
-          usages = _ref2.usages;
+      revive: function revive(obj) {
+        var jwk =
+          /**
+          * @type {{
+          *   jwk: JsonWebKey,
+          *   algorithm: KeyAlgorithm,
+          *   usages: KeyUsage[]
+          * }}
+          */
+          obj.jwk,
+          algorithm =
+          /**
+          * @type {{
+          *   jwk: JsonWebKey,
+          *   algorithm: KeyAlgorithm,
+          *   usages: KeyUsage[]
+          * }}
+          */
+          obj.algorithm,
+          usages =
+          /**
+          * @type {{
+          *   jwk: JsonWebKey,
+          *   algorithm: KeyAlgorithm,
+          *   usages: KeyUsage[]
+          * }}
+          */
+          obj.usages;
         return crypto.subtle.importKey('jwk', jwk, algorithm, true, usages);
       }
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var dataview = {
     dataview: {
       test: function test(x) {
         return toStringTag(x) === 'DataView';
       },
-      replace: function replace(_ref, stateObj) {
+      replace: function replace(_ref,
+      /**
+       * @type {import('typeson').StateObject & {
+       *  buffers?: ArrayBuffer[]
+       * }}
+       */
+      stateObj) {
         var buffer = _ref.buffer,
           byteOffset = _ref.byteOffset,
           byteLength = _ref.byteLength;
@@ -1510,7 +1672,13 @@
           byteLength: byteLength
         };
       },
-      revive: function revive(b64Obj, stateObj) {
+      revive: function revive(b64Obj,
+      /**
+       * @type {import('typeson').StateObject & {
+       *  buffers?: ArrayBuffer[]
+       * }}
+       */
+      stateObj) {
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
@@ -1530,6 +1698,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var date = {
     date: {
       test: function test(x) {
@@ -1551,6 +1722,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var error = {
     error: {
       test: function test(x) {
@@ -1575,16 +1749,34 @@
         };
       },
       revive: function revive(obj) {
-        var e = new Error(obj.message);
-        ['name', 'cause', 'stack', 'fileName', 'lineNumber', 'columnNumber'].forEach(function (prop) {
-          e[prop] = obj[prop];
-        });
+        var e =
+        /**
+        * @type {{
+        *   name: string,
+        *   cause: Error,
+        *   stack: string,
+        *   fileName?: string,
+        *   lineNumber?: import('typeson').Integer,
+        *   columnNumber?: import('typeson').Integer
+        * }}
+        */
+        new Error(obj.message);
+        e.name = obj.name;
+        e.cause = obj.cause;
+        e.stack = obj.stack;
+        e.fileName = obj.fileName;
+        e.lineNumber = obj.lineNumber;
+        e.columnNumber = obj.columnNumber;
         return e;
       }
     }
   };
 
   /* globals InternalError */
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var errors = {};
 
   // JS standard
@@ -1601,11 +1793,22 @@
   // @ts-ignore Non-standard
   typeof InternalError === 'function' && create$2(InternalError);
 
+  /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/131 */
+  /**
+   * Non-standard.
+   * @typedef {{
+   *     new (message?: string, options?: ErrorOptions): EvalError;
+   * (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.
-   * @param {
-   *   TypeError|RangeError|SyntaxError|ReferenceError|EvalError|URIError|
-   *   AggregateError|InternalError
+   * @param {TypeErrorConstructor|RangeErrorConstructor|
+   *   SyntaxErrorConstructor|ReferenceErrorConstructor|
+   *   EvalErrorConstructor|URIErrorConstructor|
+   *   AggregateErrorConstructor|InternalErrorConstructor
    * } Ctor
    * @returns {void}
    */
@@ -1636,13 +1839,36 @@
       },
       revive: function revive(obj) {
         var isAggregateError = typeof AggregateError !== 'undefined' && Ctor === AggregateError;
-        var e = isAggregateError ? new Ctor(obj.errors, obj.message) : new Ctor(obj.message);
-        ['name', 'cause', 'stack', 'fileName', 'lineNumber', 'columnNumber'].forEach(function (prop) {
-          e[prop] = obj[prop];
-        });
+        var e =
+        /**
+        * @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}
+        */
+        Ctor(obj.message);
+        e.name = obj.name;
+        e.cause = obj.cause;
+        e.stack = obj.stack;
+        e.fileName = obj.fileName;
+        e.lineNumber = obj.lineNumber;
+        e.columnNumber = obj.columnNumber;
+
         /* c8 ignore next 6 */
         if (isAggregateError) {
-          e.errors = obj.errors;
+          /** @type {AggregateError} */e.errors = obj.errors;
         }
         return e;
       }
@@ -1650,6 +1876,10 @@
   }
 
   /* globals XMLHttpRequest, File, FileReader */
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var file = {
     file: {
       test: function test(x) {
@@ -1712,6 +1942,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var filelist = {
     file: file.file,
     filelist: {
@@ -1740,7 +1973,7 @@
             this.length = this._files.length;
           }
           /**
-           * @param {Integer} index
+           * @param {import('typeson').Integer} index
            * @returns {File}
            */
           _createClass$1(FileList, [{
@@ -1766,7 +1999,9 @@
     }
   };
 
-  /* globals createImageBitmap */
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var imagebitmap = {
     imagebitmap: {
       test: function test(x) {
@@ -1777,7 +2012,8 @@
       },
       replace: function replace(bm) {
         var canvas = document.createElement('canvas');
-        var ctx = canvas.getContext('2d');
+        var ctx = /** @type {CanvasRenderingContext2D} */
+        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
@@ -1798,7 +2034,8 @@
         return req.responseText;
         */
         var canvas = document.createElement('canvas');
-        var ctx = canvas.getContext('2d');
+        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
         img.addEventListener('load', function () {
@@ -1811,18 +2048,51 @@
       },
       reviveAsync: function reviveAsync(o) {
         var canvas = document.createElement('canvas');
-        var ctx = canvas.getContext('2d');
+        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
         img.addEventListener('load', function () {
           ctx.drawImage(img, 0, 0);
         });
         img.src = o; // o.dataURL;
-        return createImageBitmap(canvas); // Returns a promise
+
+        return new e( /*#__PURE__*/function () {
+          var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(resolve, reject) {
+            var resp;
+            return _regeneratorRuntime().wrap(function _callee$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.prev = 0;
+                  _context.next = 3;
+                  return createImageBitmap(canvas);
+                case 3:
+                  resp = _context.sent;
+                  resolve(resp);
+                  /* c8 ignore next 3 */
+                  _context.next = 10;
+                  break;
+                case 7:
+                  _context.prev = 7;
+                  _context.t0 = _context["catch"](0);
+                  reject(_context.t0);
+                case 10:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee, null, [[0, 7]]);
+          }));
+          return function (_x, _x2) {
+            return _ref.apply(this, arguments);
+          };
+        }());
       }
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var imagedata = {
     imagedata: {
       test: function test(x) {
@@ -1842,6 +2112,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var infinity = {
     infinity: {
       test: function test(x) {
@@ -1856,6 +2129,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').Spec}
+   */
   var IntlCollator = {
     test: function test(x) {
       return hasConstructorOf(x, Intl.Collator);
@@ -1867,6 +2143,10 @@
       return new Intl.Collator(options.locale, options);
     }
   };
+
+  /**
+   * @type {import('typeson').Spec}
+   */
   var IntlDateTimeFormat = {
     test: function test(x) {
       return hasConstructorOf(x, Intl.DateTimeFormat);
@@ -1878,6 +2158,10 @@
       return new Intl.DateTimeFormat(options.locale, options);
     }
   };
+
+  /**
+   * @type {import('typeson').Spec}
+   */
   var IntlNumberFormat = {
     test: function test(x) {
       return hasConstructorOf(x, Intl.NumberFormat);
@@ -1895,6 +2179,9 @@
     IntlNumberFormat: IntlNumberFormat
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var map = {
     map: {
       test: function test(x) {
@@ -1909,6 +2196,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var nan = {
     nan: {
       test: function test(x) {
@@ -1923,6 +2213,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var negativeInfinity = {
     negativeInfinity: {
       test: function test(x) {
@@ -1937,6 +2230,27 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
+  var negativeZero = {
+    negativeZero: {
+      test: function test(x) {
+        return Object.is(x, -0);
+      },
+      replace: function replace(n) {
+        // Just adding 0 here for minimized space; will still revive as -0
+        return 0;
+      },
+      revive: function revive(s) {
+        return -0;
+      }
+    }
+  };
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var nonbuiltinIgnore = {
     nonbuiltinIgnore: {
       test: function test(x) {
@@ -1952,6 +2266,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var primitiveObjects = {
     // String Object (not primitive string which need no type spec)
     StringObject: {
@@ -1989,6 +2306,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var regexp = {
     regexp: {
       test: function test(x) {
@@ -2008,7 +2328,14 @@
     }
   };
 
+  /**
+   * @type {{[key: string]: any}}
+   */
   var resurrectableObjectsByUUID = {};
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var resurrectable = {
     resurrectable: {
       test: function test(x) {
@@ -2025,6 +2352,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var set = {
     set: {
       test: function test(x) {
@@ -2042,12 +2372,18 @@
   /* eslint-env browser, node */
 
   // Support all kinds of typed arrays (views of ArrayBuffers)
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var typedArraysSocketIO = {};
 
   /**
-   * @param {
-   *   Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|
-   *   Uint32Array|Float32Array|Float64Array
+   * @param {Int8ArrayConstructor|Uint8ArrayConstructor|
+   *   Uint8ClampedArrayConstructor|Int16ArrayConstructor|
+   *   Uint16ArrayConstructor|Int32ArrayConstructor|
+   *   Uint32ArrayConstructor|Float32ArrayConstructor|
+   *   Float64ArrayConstructor
    * } TypedArray
    * @returns {void}
    */
@@ -2086,22 +2422,42 @@
   }
 
   /* eslint-env browser, node */
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var typedArrays = {};
 
   /**
-   * @param {
-   *   Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|
-   *   Uint32Array|Float32Array|Float64Array
-   * } TypedArray
+   * @typedef {Int8ArrayConstructor|Uint8ArrayConstructor|
+   *   Uint8ClampedArrayConstructor|
+   *   Int16ArrayConstructor|Uint16ArrayConstructor|
+   *   Int32ArrayConstructor|Uint32ArrayConstructor|
+   *   Float32ArrayConstructor|
+   *   Float64ArrayConstructor} TypedArrayConstructor
+   */
+
+  /**
+   * @param {TypedArrayConstructor} TypedArray
    * @returns {void}
    */
   function create(TypedArray) {
-    var typeName = TypedArray.name;
+    var typeName =
+    /**
+     * @type {TypedArrayConstructor & {name: string}}
+     */
+    TypedArray.name;
     typedArrays[typeName.toLowerCase()] = {
       test: function test(x) {
         return toStringTag(x) === typeName;
       },
-      replace: function replace(_ref, stateObj) {
+      replace: function replace(_ref,
+      /**
+       * @type {import('typeson').StateObject & {
+       *   buffers?: ArrayBuffer[]
+       * }}
+       */
+      stateObj) {
         var buffer = _ref.buffer,
           byteOffset = _ref.byteOffset,
           l = _ref.length;
@@ -2123,7 +2479,13 @@
           length: l
         };
       },
-      revive: function revive(b64Obj, stateObj) {
+      revive: function revive(b64Obj,
+      /**
+       * @type {import('typeson').StateObject & {
+       *   buffers?: ArrayBuffer[]
+       * }}
+       */
+      stateObj) {
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
@@ -2151,6 +2513,10 @@
   }
 
   // This does not preserve `undefined` in sparse arrays; see the `undef`
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var undef$1 = {
     undef: {
       test: function test(x, stateObj) {
@@ -2159,14 +2525,17 @@
       replace: function replace(n) {
         return 0;
       },
-      revive: function revive(s) {
+      revive: function revive(s$1) {
         // Will add `undefined` (returning `undefined` would instead
         //   avoid explicitly setting)
-        return new p();
+        return new s();
       }
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
   var userObject = {
     userObject: {
       test: function test(x, stateObj) {
@@ -2181,6 +2550,9 @@
     }
   };
 
+  /**
+   * @type {import('typeson').Preset}
+   */
   var arrayNonindexKeys = [{
     arrayNonindexKeys: {
       testPlainObjects: true,
@@ -2217,13 +2589,17 @@
         if (Array.isArray(o)) {
           return o;
         }
+
+        /**
+         * @type {{[key: string]: any}}
+         */
         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];
+        Object.entries(o).forEach(function (_ref) {
+          var _ref2 = _slicedToArray$1(_ref, 2),
+            key = _ref2[0],
+            val = _ref2[1];
           arr[key] = val;
         });
         return arr;
@@ -2243,7 +2619,10 @@
     }
   }];
 
-  var specialNumbers = [nan, infinity, negativeInfinity];
+  /**
+   * @type {import('typeson').Preset}
+   */
+  var specialNumbers = [nan, infinity, negativeInfinity, negativeZero];
 
   /* This preset includes types that are built-in into the JavaScript
       language itself, this should work universally.
@@ -2260,6 +2639,10 @@
 
     Symbols are similarly not included.
   */
+
+  /**
+   * @type {import('typeson').Preset}
+   */
   var expObj$1 = [undef$1,
   // ES5
   arrayNonindexKeys, primitiveObjects, specialNumbers, date, error, errors, regexp].concat(
@@ -2288,8 +2671,15 @@
   This preset will only include the Error types and you can register your
   custom types after having registered these.
   */
+
+  /**
+   * @type {import('typeson').Preset}
+   */
   var postmessage = [error, errors];
 
+  /**
+   * @type {import('typeson').Preset}
+   */
   var socketio = [expObj$1,
   // Leave ArrayBuffer as is, and let socket.io stream it instead.
   {
@@ -2298,6 +2688,9 @@
   // Encapsulate TypedArrays in ArrayBuffers instead of base64 strings.
   typedArraysSocketIO];
 
+  /**
+   * @type {import('typeson').Preset}
+   */
   var sparseUndefined = [{
     sparseArrays: {
       testPlainObjects: true,
@@ -2324,6 +2717,10 @@
   }];
 
   /* This preset includes types for the Structured Cloning Algorithm. */
+
+  /**
+   * @type {import('typeson').Preset}
+   */
   var expObj = [
   // Todo: Might also register synchronous `ImageBitmap` and
   //    `Blob`/`File`/`FileList`?
@@ -2347,6 +2744,9 @@
   typeof crypto !== 'undefined' ? cryptokey : [], /* c8 ignore next */
   typeof BigInt !== 'undefined' ? [bigint, bigintObject] : []);
 
+  /**
+   * @type {import('typeson').Preset}
+   */
   var structuredCloningThrowing = expObj.concat({
     checkDataCloneException: {
       test: function test(val) {
@@ -2413,17 +2813,23 @@
     }
   });
 
+  /**
+   * @type {import('typeson').Preset}
+   */
   var undef = [sparseUndefined, undef$1];
 
+  /**
+   * @type {import('typeson').Preset}
+   */
   var universal = [expObj$1
   // TODO: Add types that are de-facto universal even though not
   //   built-in into ecmasript standard.
   ];
 
-  exports.JSON_TYPES = l;
-  exports.Typeson = u;
+  exports.JSON_TYPES = u;
+  exports.Typeson = c;
   exports.TypesonPromise = e;
-  exports.Undefined = p;
+  exports.Undefined = s;
   exports.arrayNonindexKeys = arrayNonindexKeys;
   exports.arraybuffer = arraybuffer;
   exports.bigint = bigint;
@@ -2453,6 +2859,7 @@
   exports.map = map;
   exports.nan = nan;
   exports.negativeInfinity = negativeInfinity;
+  exports.negativeZero = negativeZero;
   exports.nonbuiltinIgnore = nonbuiltinIgnore;
   exports.postmessage = postmessage;
   exports.primitiveObjects = primitiveObjects;