typeson-registry 1.0.0-alpha.7 → 2.0.0

package/dist/index.umd.js

@@ -0,0 +1,2274 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.TypesonNamespace = {}));
+})(this, (function (exports) { 'use strict';
+
+  function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      enumerableOnly && (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
+    }
+
+    return keys;
+  }
+
+  function _objectSpread2$1(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) {
+        _defineProperty$1(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+
+    return target;
+  }
+
+  function _typeof$1(obj) {
+    "@babel/helpers - typeof";
+
+    return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof$1(obj);
+  }
+
+  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+      var info = gen[key](arg);
+      var value = info.value;
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    if (info.done) {
+      resolve(value);
+    } else {
+      Promise.resolve(value).then(_next, _throw);
+    }
+  }
+
+  function _asyncToGenerator(fn) {
+    return function () {
+      var self = this,
+          args = arguments;
+      return new Promise(function (resolve, reject) {
+        var gen = fn.apply(self, args);
+
+        function _next(value) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+        }
+
+        function _throw(err) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+        }
+
+        _next(undefined);
+      });
+    };
+  }
+
+  function _classCallCheck$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  function _defineProperties$1(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$1(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
+    return Constructor;
+  }
+
+  function _defineProperty$1(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+
+    return obj;
+  }
+
+  function _toConsumableArray$1(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
+  }
+
+  function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
+  }
+
+  function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+  }
+
+  function _unsupportedIterableToArray$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen);
+  }
+
+  function _arrayLikeToArray$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+
+  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(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), !0).forEach(function (t) {
+        _defineProperty(e, t, r[t]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : ownKeys(Object(r)).forEach(function (t) {
+        Object.defineProperty(e, t, Object.getOwnPropertyDescriptor(r, t));
+      });
+    }
+
+    return e;
+  }
+
+  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);
+    })(e);
+  }
+
+  function _classCallCheck(e, t) {
+    if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+  }
+
+  function _defineProperties(e, t) {
+    for (var r = 0; r < t.length; r++) {
+      var n = t[r];
+      n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, n.key, n);
+    }
+  }
+
+  function _createClass(e, t, r) {
+    return t && _defineProperties(e.prototype, t), r && _defineProperties(e, r), Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
+
+  function _defineProperty(e, t, r) {
+    return t in e ? Object.defineProperty(e, t, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[t] = r, e;
+  }
+
+  function _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) return;
+      var n,
+          a,
+          o = [],
+          i = !0,
+          c = !1;
+
+      try {
+        for (r = r.call(e); !(i = (n = r.next()).done) && (o.push(n.value), !t || o.length !== t); i = !0) {
+          ;
+        }
+      } catch (e) {
+        c = !0, a = e;
+      } finally {
+        try {
+          i || null == r["return"] || r["return"]();
+        } finally {
+          if (c) throw a;
+        }
+      }
+
+      return o;
+    }(e, t) || _unsupportedIterableToArray(e, t) || function _nonIterableRest() {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }();
+  }
+
+  function _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 _unsupportedIterableToArray(e, t) {
+    if (e) {
+      if ("string" == typeof e) return _arrayLikeToArray(e, t);
+      var r = Object.prototype.toString.call(e).slice(8, -1);
+      return "Object" === r && e.constructor && (r = e.constructor.name), "Map" === r || "Set" === r ? Array.from(e) : "Arguments" === r || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? _arrayLikeToArray(e, t) : void 0;
+    }
+  }
+
+  function _arrayLikeToArray(e, t) {
+    (null == t || t > e.length) && (t = e.length);
+
+    for (var r = 0, n = new Array(t); r < t; r++) {
+      n[r] = e[r];
+    }
+
+    return n;
+  }
+
+  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) {
+    var n = this;
+    return new e(function (e, a) {
+      n.p.then(function (r) {
+        e(t ? t(r) : r);
+      })["catch"](function (e) {
+        return r ? r(e) : Promise.reject(e);
+      }).then(e, a);
+    });
+  }, e.prototype["catch"] = function (e) {
+    return this.then(null, e);
+  }, e.resolve = function (t) {
+    return new e(function (e) {
+      e(t);
+    });
+  }, e.reject = function (t) {
+    return new e(function (e, r) {
+      r(t);
+    });
+  }, ["all", "race", "allSettled"].forEach(function (t) {
+    e[t] = function (r) {
+      return new e(function (e, n) {
+        Promise[t](r.map(function (e) {
+          return e && e.constructor && "TypesonPromise" === e.constructor.__typeson__type__ ? e.p : e;
+        })).then(e, n);
+      });
+    };
+  });
+  var t = {}.toString,
+      r = {}.hasOwnProperty,
+      n = Object.getPrototypeOf,
+      a = r.toString;
+
+  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);
+  }
+
+  function hasConstructorOf(e, t) {
+    if (!e || "object" !== _typeof(e)) return !1;
+    var o = n(e);
+    if (!o) return null === t;
+    var i = r.call(o, "constructor") && o.constructor;
+    return "function" != typeof i ? null === t : t === i || null !== t && a.call(i) === a.call(t) || "function" == typeof t && "string" == typeof i.__typeson__type__ && i.__typeson__type__ === t.__typeson__type__;
+  }
+
+  function isPlainObject(e) {
+    return !(!e || "Object" !== toStringTag(e)) && (!n(e) || hasConstructorOf(e, Object));
+  }
+
+  function isUserObject(e) {
+    if (!e || "Object" !== toStringTag(e)) return !1;
+    var t = n(e);
+    return !t || hasConstructorOf(e, Object) || isUserObject(t);
+  }
+
+  function isObject(e) {
+    return e && "object" === _typeof(e);
+  }
+
+  function escapeKeyPathComponent(e) {
+    return e.replace(/~/g, "~0").replace(/\./g, "~1");
+  }
+
+  function unescapeKeyPathComponent(e) {
+    return e.replace(/~1/g, ".").replace(/~0/g, "~");
+  }
+
+  function getByKeyPath(e, t) {
+    if ("" === t) return e;
+    var r = t.indexOf(".");
+
+    if (r > -1) {
+      var n = e[unescapeKeyPathComponent(t.slice(0, r))];
+      return void 0 === n ? void 0 : getByKeyPath(n, t.slice(r + 1));
+    }
+
+    return e[unescapeKeyPathComponent(t)];
+  }
+
+  function setAtKeyPath(e, t, r) {
+    if ("" === t) return r;
+    var n = t.indexOf(".");
+    return n > -1 ? setAtKeyPath(e[unescapeKeyPathComponent(t.slice(0, n))], t.slice(n + 1), r) : (e[unescapeKeyPathComponent(t)] = r, e);
+  }
+
+  function getJSONType(e) {
+    return null === e ? "null" : Array.isArray(e) ? "array" : _typeof(e);
+  }
+
+  function _await(e, t, r) {
+    return r ? t ? t(e) : e : (e && e.then || (e = Promise.resolve(e)), t ? e.then(t) : e);
+  }
+
+  var o = Object.keys,
+      i$1 = Array.isArray,
+      c = {}.hasOwnProperty,
+      s = ["type", "replaced", "iterateIn", "iterateUnsetNumeric"];
+
+  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);
+      }
+    };
+  }
+
+  function nestedPathsFirst(e, t) {
+    if ("" === e.keypath) return -1;
+    var r = e.keypath.match(/\./g) || 0,
+        n = t.keypath.match(/\./g) || 0;
+    return r && (r = r.length), n && (n = n.length), r > n ? -1 : r < n ? 1 : e.keypath < t.keypath ? -1 : e.keypath > t.keypath;
+  }
+
+  var u = function () {
+    function Typeson(e) {
+      _classCallCheck(this, Typeson), this.options = e, this.plainObjectReplacers = [], this.nonplainObjectReplacers = [], this.revivers = {}, this.types = {};
+    }
+
+    return _createClass(Typeson, [{
+      key: "stringify",
+      value: function stringify(e, t, r, n) {
+        n = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), n), {}, {
+          stringification: !0
+        });
+        var a = this.encapsulate(e, null, n);
+        return i$1(a) ? JSON.stringify(a[0], t, r) : a.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: !0
+        }, n), {}, {
+          sync: !0
+        }));
+      }
+    }, {
+      key: "stringifyAsync",
+      value: function stringifyAsync(e, t, r, n) {
+        return this.stringify(e, t, r, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, n), {}, {
+          sync: !1
+        }));
+      }
+    }, {
+      key: "parse",
+      value: function parse(e, t, r) {
+        return r = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), r), {}, {
+          parse: !0
+        }), this.revive(JSON.parse(e, t), r);
+      }
+    }, {
+      key: "parseSync",
+      value: function parseSync(e, t, r) {
+        return this.parse(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, r), {}, {
+          sync: !0
+        }));
+      }
+    }, {
+      key: "parseAsync",
+      value: function parseAsync(e, t, r) {
+        return this.parse(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, r), {}, {
+          sync: !1
+        }));
+      }
+    }, {
+      key: "specialTypeNames",
+      value: function specialTypeNames(e, t) {
+        var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+        return r.returnTypeNames = !0, this.encapsulate(e, t, r);
+      }
+    }, {
+      key: "rootTypeName",
+      value: function rootTypeName(e, t) {
+        var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+        return r.iterateNone = !0, this.encapsulate(e, t, r);
+      }
+    }, {
+      key: "encapsulate",
+      value: function encapsulate(t, r, n) {
+        var a = _async(function (t, r) {
+          return _await(Promise.all(r.map(function (e) {
+            return e[1].p;
+          })), function (n) {
+            return _await(Promise.all(n.map(_async(function (n) {
+              var o = !1,
+                  i = [],
+                  c = _slicedToArray(r.splice(0, 1), 1),
+                  s = _slicedToArray(c[0], 7),
+                  u = s[0],
+                  p = s[2],
+                  y = s[3],
+                  l = s[4],
+                  f = s[5],
+                  h = s[6],
+                  v = _encapsulate(u, n, p, y, i, !0, h),
+                  d = hasConstructorOf(v, e);
+
+              return function _invoke(e, t) {
+                var r = e();
+                return r && r.then ? r.then(t) : t(r);
+              }(function () {
+                if (u && d) return _await(v.p, function (e) {
+                  l[f] = e;
+                  var r = a(t, i);
+                  return o = !0, r;
+                });
+              }, function (e) {
+                return o ? e : (u ? l[f] = v : t = d ? v.p : v, a(t, i));
+              });
+            }))), function () {
+              return t;
+            });
+          });
+        }),
+            u = (n = _objectSpread2(_objectSpread2({
+          sync: !0
+        }, this.options), n)).sync,
+            p = this,
+            y = {},
+            l = [],
+            f = [],
+            h = [],
+            v = !("cyclic" in n) || n.cyclic,
+            d = n.encapsulateObserver,
+            b = _encapsulate("", t, v, r || {}, h);
+
+        function finish(e) {
+          var t = Object.values(y);
+          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 = y : e = {
+              $: e,
+              $types: {
+                $: y
+              }
+            };
+          } 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, a, s, u, h, v) {
+          var b,
+              _ = {},
+              O = _typeof(r),
+              j = d ? function (n) {
+            var o = v || s.type || getJSONType(r);
+            d(Object.assign(n || _, {
+              keypath: t,
+              value: r,
+              cyclic: a,
+              stateObj: s,
+              promisesData: u,
+              resolvingTypesonPromise: h,
+              awaitingTypesonPromise: hasConstructorOf(r, e)
+            }, {
+              type: o
+            }));
+          } : null;
+
+          if (["string", "boolean", "number", "undefined"].includes(O)) return void 0 === r || Number.isNaN(r) || r === Number.NEGATIVE_INFINITY || r === Number.POSITIVE_INFINITY ? (b = s.replaced ? r : replace(t, r, s, u, !1, h, j)) !== r && (_ = {
+            replaced: b
+          }) : b = r, j && j(), b;
+          if (null === r) return j && j(), r;
+
+          if (a && !s.iterateIn && !s.iterateUnsetNumeric && r && "object" === _typeof(r)) {
+            var m = l.indexOf(r);
+            if (!(m < 0)) return y[t] = "#", j && j({
+              cyclicKeypath: f[m]
+            }), "#" + f[m];
+            !0 === a && (l.push(r), f.push(t));
+          }
+
+          var S,
+              g = isPlainObject(r),
+              P = i$1(r),
+              T = (g || P) && (!p.plainObjectReplacers.length || s.replaced) || s.iterateIn ? r : replace(t, r, s, u, g || P, null, j);
+          if (T !== r ? (b = T, _ = {
+            replaced: T
+          }) : "" === t && hasConstructorOf(r, e) ? (u.push([t, r, a, s, void 0, void 0, s.type]), b = r) : P && "object" !== s.iterateIn || "array" === s.iterateIn ? (S = new Array(r.length), _ = {
+            clone: S
+          }) : (["function", "symbol"].includes(_typeof(r)) || "toJSON" in r || hasConstructorOf(r, e) || hasConstructorOf(r, Promise) || hasConstructorOf(r, ArrayBuffer)) && !g && "object" !== s.iterateIn ? b = r : (S = {}, s.addLength && (S.length = r.length), _ = {
+            clone: S
+          }), j && j(), n.iterateNone) return S || b;
+          if (!S) return b;
+
+          if (s.iterateIn) {
+            var w = function _loop(n) {
+              var o = {
+                ownKeys: c.call(r, n)
+              };
+
+              _adaptBuiltinStateObjectProperties(s, o, function () {
+                var o = t + (t ? "." : "") + escapeKeyPathComponent(n),
+                    i = _encapsulate(o, r[n], Boolean(a), s, u, h);
+
+                hasConstructorOf(i, e) ? u.push([o, i, Boolean(a), s, S, n, s.type]) : void 0 !== i && (S[n] = i);
+              });
+            };
+
+            for (var A in r) {
+              w(A);
+            }
+
+            j && j({
+              endIterateIn: !0,
+              end: !0
+            });
+          } else o(r).forEach(function (n) {
+            var o = t + (t ? "." : "") + escapeKeyPathComponent(n);
+
+            _adaptBuiltinStateObjectProperties(s, {
+              ownKeys: !0
+            }, function () {
+              var t = _encapsulate(o, r[n], Boolean(a), s, u, h);
+
+              hasConstructorOf(t, e) ? u.push([o, t, Boolean(a), s, S, n, s.type]) : void 0 !== t && (S[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 o = t + (t ? "." : "") + n;
+
+                _adaptBuiltinStateObjectProperties(s, {
+                  ownKeys: !1
+                }, function () {
+                  var t = _encapsulate(o, void 0, Boolean(a), s, u, h);
+
+                  hasConstructorOf(t, e) ? u.push([o, t, Boolean(a), s, S, n, s.type]) : void 0 !== t && (S[n] = t);
+                });
+              }
+            }, N = 0; N < C; N++) {
+              k(N);
+            }
+
+            j && j({
+              endIterateUnsetNumeric: !0,
+              end: !0
+            });
+          }
+
+          return S;
+        }
+
+        function replace(e, t, r, n, a, o, i) {
+          for (var c = a ? p.plainObjectReplacers : p.nonplainObjectReplacers, s = c.length; s--;) {
+            var l = c[s];
+
+            if (l.test(t, r)) {
+              var f = l.type;
+
+              if (p.revivers[f]) {
+                var h = y[e];
+                y[e] = h ? [f].concat(h) : f;
+              }
+
+              return Object.assign(r, {
+                type: f,
+                replaced: !0
+              }), !u && l.replaceAsync || l.replace ? (i && i({
+                replacing: !0
+              }), _encapsulate(e, l[u || !l.replaceAsync ? "replace" : "replaceAsync"](t, r), v && "readonly", r, n, o, f)) : (i && i({
+                typeDetected: !0
+              }), _encapsulate(e, t, v && "readonly", r, n, o, f));
+            }
+          }
+
+          return t;
+        }
+
+        return h.length ? u && n.throwOnBadSyncType ? function () {
+          throw new TypeError("Sync method requested but async result obtained");
+        }() : Promise.resolve(a(b, h)).then(finish) : !u && n.throwOnBadSyncType ? function () {
+          throw new TypeError("Async method requested but sync result obtained");
+        }() : n.stringification && u ? [finish(b)] : u ? finish(b) : Promise.resolve(finish(b));
+      }
+    }, {
+      key: "encapsulateSync",
+      value: function encapsulateSync(e, t, r) {
+        return this.encapsulate(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, r), {}, {
+          sync: !0
+        }));
+      }
+    }, {
+      key: "encapsulateAsync",
+      value: function encapsulateAsync(e, t, r) {
+        return this.encapsulate(e, t, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, r), {}, {
+          sync: !1
+        }));
+      }
+    }, {
+      key: "revive",
+      value: function revive(t, r) {
+        var n = t && t.$types;
+        if (!n) return t;
+        if (!0 === n) return t.$;
+
+        var a = (r = _objectSpread2(_objectSpread2({
+          sync: !0
+        }, this.options), r)).sync,
+            c = [],
+            s = {},
+            u = !0;
+
+        n.$ && isPlainObject(n.$) && (t = t.$, n = n.$, u = !1);
+        var y = this;
+
+        function executeReviver(e, t) {
+          var r = _slicedToArray(y.revivers[e] || [], 1)[0];
+
+          if (!r) throw new Error("Unregistered type: " + e);
+          return a && !("revive" in r) ? t : r[a && r.revive ? "revive" : !a && r.reviveAsync ? "reviveAsync" : "revive"](t, s);
+        }
+
+        var l = [];
+
+        function checkUndefined(e) {
+          return hasConstructorOf(e, p) ? void 0 : e;
+        }
+
+        var f,
+            h = function revivePlainObjects() {
+          var r = [];
+          if (Object.entries(n).forEach(function (e) {
+            var t = _slicedToArray(e, 2),
+                a = t[0],
+                o = t[1];
+
+            "#" !== o && [].concat(o).forEach(function (e) {
+              _slicedToArray(y.revivers[e] || [null, {}], 2)[1].plain && (r.push({
+                keypath: a,
+                type: e
+              }), delete n[a]);
+            });
+          }), r.length) return r.sort(nestedPathsFirst).reduce(function reducer(r, n) {
+            var a = n.keypath,
+                o = n.type;
+            if (isThenable(r)) return r.then(function (e) {
+              return reducer(e, {
+                keypath: a,
+                type: o
+              });
+            });
+            var i = getByKeyPath(t, a);
+            if (hasConstructorOf(i = executeReviver(o, i), e)) return i.then(function (e) {
+              var r = setAtKeyPath(t, a, e);
+              r === e && (t = r);
+            });
+            var c = setAtKeyPath(t, a, i);
+            c === i && (t = c);
+          }, void 0);
+        }();
+
+        return hasConstructorOf(h, e) ? f = h.then(function () {
+          return t;
+        }) : (f = function _revive(t, r, a, s, y) {
+          if (!u || "$types" !== t) {
+            var f = n[t],
+                h = i$1(r);
+
+            if (h || isPlainObject(r)) {
+              var v = h ? new Array(r.length) : {};
+
+              for (o(r).forEach(function (n) {
+                var o = _revive(t + (t ? "." : "") + escapeKeyPathComponent(n), r[n], a || v, v, n),
+                    i = function set(e) {
+                  return hasConstructorOf(e, p) ? v[n] = void 0 : void 0 !== e && (v[n] = e), e;
+                };
+
+                hasConstructorOf(o, e) ? l.push(o.then(function (e) {
+                  return i(e);
+                })) : i(o);
+              }), r = v; c.length;) {
+                var d = _slicedToArray(c[0], 4),
+                    b = d[0],
+                    _ = d[1],
+                    O = d[2],
+                    j = d[3],
+                    m = getByKeyPath(b, _);
+
+                if (void 0 === m) break;
+                O[j] = m, c.splice(0, 1);
+              }
+            }
+
+            if (!f) return r;
+
+            if ("#" === f) {
+              var S = getByKeyPath(a, r.slice(1));
+              return void 0 === S && c.push([a, r.slice(1), s, y]), S;
+            }
+
+            return [].concat(f).reduce(function reducer(t, r) {
+              return hasConstructorOf(t, e) ? t.then(function (e) {
+                return reducer(e, r);
+              }) : executeReviver(r, t);
+            }, r);
+          }
+        }("", t, null), l.length && (f = e.resolve(f).then(function (t) {
+          return e.all([t].concat(l));
+        }).then(function (e) {
+          return _slicedToArray(e, 1)[0];
+        }))), isThenable(f) ? a && r.throwOnBadSyncType ? function () {
+          throw new TypeError("Sync method requested but async result obtained");
+        }() : hasConstructorOf(f, e) ? f.p.then(checkUndefined) : f : !a && r.throwOnBadSyncType ? function () {
+          throw new TypeError("Async method requested but sync result obtained");
+        }() : a ? checkUndefined(f) : Promise.resolve(checkUndefined(f));
+      }
+    }, {
+      key: "reviveSync",
+      value: function reviveSync(e, t) {
+        return this.revive(e, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, t), {}, {
+          sync: !0
+        }));
+      }
+    }, {
+      key: "reviveAsync",
+      value: function reviveAsync(e, t) {
+        return this.revive(e, _objectSpread2(_objectSpread2({
+          throwOnBadSyncType: !0
+        }, t), {}, {
+          sync: !1
+        }));
+      }
+    }, {
+      key: "register",
+      value: function register(e, t) {
+        var r = this;
+        t = t || {};
+
+        var n = function R(e) {
+          i$1(e) ? e.forEach(function (e) {
+            return R(e);
+          }) : e && o(e).forEach(function (n) {
+            if ("#" === n) throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");
+            if (y.includes(n)) throw new TypeError("Plain JSON object types are reserved as type names");
+            var a = e[n],
+                o = a && a.testPlainObjects ? r.plainObjectReplacers : r.nonplainObjectReplacers,
+                c = o.filter(function (e) {
+              return e.type === n;
+            });
+
+            if (c.length && (o.splice(o.indexOf(c[0]), 1), delete r.revivers[n], delete r.types[n]), "function" == typeof a) {
+              var s = a;
+              a = {
+                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);
+                }
+              };
+            } else if (i$1(a)) {
+              var u = _slicedToArray(a, 3);
+
+              a = {
+                test: u[0],
+                replace: u[1],
+                revive: u[2]
+              };
+            }
+
+            if (a && a.test) {
+              var p = {
+                type: n,
+                test: a.test.bind(a)
+              };
+              a.replace && (p.replace = a.replace.bind(a)), a.replaceAsync && (p.replaceAsync = a.replaceAsync.bind(a));
+              var l = "number" == typeof t.fallback ? t.fallback : t.fallback ? 0 : Number.POSITIVE_INFINITY;
+
+              if (a.testPlainObjects ? r.plainObjectReplacers.splice(l, 0, p) : r.nonplainObjectReplacers.splice(l, 0, p), a.revive || a.reviveAsync) {
+                var f = {};
+                a.revive && (f.revive = a.revive.bind(a)), a.reviveAsync && (f.reviveAsync = a.reviveAsync.bind(a)), r.revivers[n] = [f, {
+                  plain: a.testPlainObjects
+                }];
+              }
+
+              r.types[n] = a;
+            }
+          });
+        };
+
+        return [].concat(e).forEach(function (e) {
+          return n(e);
+        }), this;
+      }
+    }]), Typeson;
+  }(),
+      p = _createClass(function Undefined() {
+    _classCallCheck(this, Undefined);
+  });
+
+  p.__typeson__type__ = "TypesonUndefined";
+  var y = ["null", "boolean", "number", "string", "array", "object"];
+
+  /*
+   * base64-arraybuffer
+   * https://github.com/niklasvh/base64-arraybuffer
+   *
+   * Copyright (c) 2017 Brett Zamir, 2012 Niklas von Hertzen
+   * Licensed under the MIT license.
+   */
+  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; // Use a lookup table to find the index.
+
+  var lookup = new Uint8Array(256);
+
+  for (var i = 0; i < chars.length; i++) {
+    lookup[chars.codePointAt(i)] = i;
+  }
+  /**
+   * @param {ArrayBuffer} arraybuffer
+   * @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
+    }
+
+    var bytes = new Uint8Array(arraybuffer, byteOffset || 0, // Default needed for Safari
+    lngth);
+    var len = bytes.length;
+    var base64 = '';
+
+    for (var _i = 0; _i < len; _i += 3) {
+      base64 += chars[bytes[_i] >> 2];
+      base64 += chars[(bytes[_i] & 3) << 4 | bytes[_i + 1] >> 4];
+      base64 += chars[(bytes[_i + 1] & 15) << 2 | bytes[_i + 2] >> 6];
+      base64 += chars[bytes[_i + 2] & 63];
+    }
+
+    if (len % 3 === 2) {
+      base64 = base64.slice(0, -1) + '=';
+    } else if (len % 3 === 1) {
+      base64 = base64.slice(0, -2) + '==';
+    }
+
+    return base64;
+  };
+  /**
+   * @param {string} base64
+   * @returns {ArrayBuffer}
+   */
+
+
+  var decode = function decode(base64) {
+    var len = base64.length;
+    var bufferLength = base64.length * 0.75;
+    var p = 0;
+    var encoded1, encoded2, encoded3, encoded4;
+
+    if (base64[base64.length - 1] === '=') {
+      bufferLength--;
+
+      if (base64[base64.length - 2] === '=') {
+        bufferLength--;
+      }
+    }
+
+    var arraybuffer = new ArrayBuffer(bufferLength),
+        bytes = new Uint8Array(arraybuffer);
+
+    for (var _i2 = 0; _i2 < len; _i2 += 4) {
+      encoded1 = lookup[base64.codePointAt(_i2)];
+      encoded2 = lookup[base64.codePointAt(_i2 + 1)];
+      encoded3 = lookup[base64.codePointAt(_i2 + 2)];
+      encoded4 = lookup[base64.codePointAt(_i2 + 3)];
+      bytes[p++] = encoded1 << 2 | encoded2 >> 4;
+      bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
+      bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
+    }
+
+    return arraybuffer;
+  };
+
+  var arraybuffer = {
+    arraybuffer: {
+      test: function test(x) {
+        return toStringTag(x) === 'ArrayBuffer';
+      },
+      replace: function replace(b, stateObj) {
+        if (!stateObj.buffers) {
+          stateObj.buffers = [];
+        }
+
+        var index = stateObj.buffers.indexOf(b);
+
+        if (index > -1) {
+          return {
+            index: index
+          };
+        }
+
+        stateObj.buffers.push(b);
+        return encode(b);
+      },
+      revive: function revive(b64, stateObj) {
+        if (!stateObj.buffers) {
+          stateObj.buffers = [];
+        }
+
+        if (_typeof$1(b64) === 'object') {
+          return stateObj.buffers[b64.index];
+        }
+
+        var buffer = decode(b64);
+        stateObj.buffers.push(buffer);
+        return buffer;
+      }
+    }
+  };
+   // See also typed-arrays!
+
+  var bigintObject = {
+    bigintObject: {
+      test: function test(x) {
+        return _typeof$1(x) === 'object' && hasConstructorOf(x, BigInt);
+      },
+      replace: function replace(n) {
+        return String(n);
+      },
+      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));
+      }
+    }
+  };
+
+  /* globals BigInt */
+  var bigint = {
+    bigint: {
+      test: function test(x) {
+        return typeof x === 'bigint';
+      },
+      replace: function replace(n) {
+        return String(n);
+      },
+      revive: function revive(s) {
+        return BigInt(s);
+      }
+    }
+  };
+
+  /**
+   * Not currently in use internally, but provided for parity.
+   * @param {ArrayBuffer} buf
+   * @returns {Uint8Array}
+   */
+  /**
+   *
+   * @param {string} str
+   * @returns {ArrayBuffer}
+   */
+
+
+  function string2arraybuffer(str) {
+    /*
+    // UTF-8 approaches
+    const utf8 = unescape(encodeURIComponent(str));
+    const arr = new Uint8Array(utf8.length);
+    for (let i = 0; i < utf8.length; i++) {
+        arr[i] = utf8.charCodeAt(i);
+    }
+    return arr.buffer;
+     const utf8 = [];
+    for (let i = 0; i < str.length; i++) {
+        let charcode = str.charCodeAt(i);
+        if (charcode < 0x80) utf8.push(charcode);
+        else if (charcode < 0x800) {
+            utf8.push(0xc0 | (charcode >> 6),
+                0x80 | (charcode & 0x3f));
+        } else if (charcode < 0xd800 || charcode >= 0xe000) {
+            utf8.push(0xe0 | (charcode >> 12),
+                0x80 | ((charcode >> 6) & 0x3f),
+                0x80 | (charcode & 0x3f));
+        // surrogate pair
+        } else {
+            i++;
+            // UTF-16 encodes 0x10000-0x10FFFF by
+            // subtracting 0x10000 and splitting the
+            // 20 bits of 0x0-0xFFFFF into two halves
+            charcode = 0x10000 + (((charcode & 0x3ff) << 10) |
+                (str.charCodeAt(i) & 0x3ff));
+            utf8.push(0xf0 | (charcode >> 18),
+                0x80 | ((charcode >> 12) & 0x3f),
+                0x80 | ((charcode >> 6) & 0x3f),
+                0x80 | (charcode & 0x3f));
+        }
+    }
+    return utf8;
+    */
+
+    /*
+    // Working UTF-16 options (equivalents)
+    const buf = new ArrayBuffer(str.length * 2); // 2 bytes for each char
+    const bufView = new Uint16Array(buf);
+    for (let i = 0, strLen = str.length; i < strLen; i++) {
+        bufView[i] = str.charCodeAt(i);
+    }
+    return buf;
+    */
+    var array = new Uint8Array(str.length);
+
+    for (var i = 0; i < str.length; i++) {
+      // eslint-disable-next-line max-len -- Long
+      // eslint-disable-next-line unicorn/prefer-code-point -- Iterating char. codes
+      array[i] = str.charCodeAt(i); // & 0xff;
+    }
+
+    return array.buffer;
+  }
+
+  /* globals XMLHttpRequest, Blob, FileReader */
+  var blob = {
+    blob: {
+      test: function test(x) {
+        return toStringTag(x) === 'Blob';
+      },
+      replace: function replace(b) {
+        // Sync
+        var req = new XMLHttpRequest();
+        req.overrideMimeType('text/plain; charset=x-user-defined');
+        req.open('GET', URL.createObjectURL(b), false); // Sync
+
+        req.send(); // Seems not feasible to accurately simulate
+
+        /* c8 ignore next 3 */
+
+        if (req.status !== 200 && req.status !== 0) {
+          throw new Error('Bad Blob access: ' + req.status);
+        }
+
+        return {
+          type: b.type,
+          stringContents: req.responseText
+        };
+      },
+      revive: function revive(_ref) {
+        var type = _ref.type,
+            stringContents = _ref.stringContents;
+        return new Blob([string2arraybuffer(stringContents)], {
+          type: type
+        });
+      },
+      replaceAsync: function replaceAsync(b) {
+        return new e(function (resolve, reject) {
+          /*
+          if (b.isClosed) { // On MDN, but not in https://w3c.github.io/FileAPI/#dfn-Blob
+              reject(new Error('The Blob is closed'));
+              return;
+          }
+          */
+          var reader = new FileReader();
+          reader.addEventListener('load', function () {
+            resolve({
+              type: b.type,
+              stringContents: reader.result
+            });
+          }); // Seems not feasible to accurately simulate
+
+          /* c8 ignore next 3 */
+
+          reader.addEventListener('error', function () {
+            reject(reader.error);
+          });
+          reader.readAsBinaryString(b);
+        });
+      }
+    }
+  };
+
+  /* globals performance */
+  // The `performance` global is optional
+
+  /**
+   * @todo We could use `import generateUUID from 'uuid/v4';` (but it needs
+   *   crypto library, etc.; `rollup-plugin-node-builtins` doesn't recommend
+   *   using its own version and though there is <https://www.npmjs.com/package/crypto-browserify>,
+   *   it may be troublesome to bundle and not strongly needed)
+   * @returns {string}
+   */
+  function generateUUID() {
+    //  Adapted from original: public domain/MIT: http://stackoverflow.com/a/8809472/271577
+
+    /* c8 ignore next */
+    var d = Date.now() + ( // use high-precision timer if available
+
+    /* c8 ignore next 4 */
+    typeof performance !== 'undefined' && typeof performance.now === 'function' ? performance.now() : 0);
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+      /* eslint-disable no-bitwise */
+      var r = Math.trunc((d + Math.random() * 16) % 16);
+      d = Math.floor(d / 16);
+      return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+      /* eslint-enable no-bitwise */
+    });
+  }
+
+  var cloneableObjectsByUUID = {};
+  var cloneable = {
+    cloneable: {
+      test: function test(x) {
+        return x && _typeof$1(x) === 'object' && typeof x[Symbol["for"]('cloneEncapsulate')] === 'function';
+      },
+      replace: function replace(clonable) {
+        var encapsulated = clonable[Symbol["for"]('cloneEncapsulate')]();
+        var uuid = generateUUID();
+        cloneableObjectsByUUID[uuid] = clonable;
+        return {
+          uuid: uuid,
+          encapsulated: encapsulated
+        };
+      },
+      revive: function revive(_ref) {
+        var uuid = _ref.uuid,
+            encapsulated = _ref.encapsulated;
+        return cloneableObjectsByUUID[uuid][Symbol["for"]('cloneRevive')](encapsulated);
+      }
+    }
+  };
+
+  var cryptokey = {
+    cryptokey: {
+      test: function test(x) {
+        return toStringTag(x) === 'CryptoKey' && x.extractable;
+      },
+      replaceAsync: function replaceAsync(key) {
+        return new e( /*#__PURE__*/function () {
+          var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(resolve, reject) {
+            var jwk;
+            return regeneratorRuntime.wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    _context.prev = 0;
+                    _context.next = 3;
+                    return crypto.subtle.exportKey('jwk', key);
+
+                  case 3:
+                    jwk = _context.sent;
+                    _context.next = 10;
+                    break;
+
+                  case 6:
+                    _context.prev = 6;
+                    _context.t0 = _context["catch"](0);
+                    reject(_context.t0);
+                    return _context.abrupt("return");
+
+                  case 10:
+                    resolve({
+                      jwk: jwk,
+                      algorithm: key.algorithm,
+                      usages: key.usages
+                    });
+
+                  case 11:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee, null, [[0, 6]]);
+          }));
+
+          return function (_x, _x2) {
+            return _ref.apply(this, arguments);
+          };
+        }());
+      },
+      revive: function revive(_ref2) {
+        var jwk = _ref2.jwk,
+            algorithm = _ref2.algorithm,
+            usages = _ref2.usages;
+        return crypto.subtle.importKey('jwk', jwk, algorithm, true, usages);
+      }
+    }
+  };
+
+  var dataview = {
+    dataview: {
+      test: function test(x) {
+        return toStringTag(x) === 'DataView';
+      },
+      replace: function replace(_ref, stateObj) {
+        var buffer = _ref.buffer,
+            byteOffset = _ref.byteOffset,
+            byteLength = _ref.byteLength;
+
+        if (!stateObj.buffers) {
+          stateObj.buffers = [];
+        }
+
+        var index = stateObj.buffers.indexOf(buffer);
+
+        if (index > -1) {
+          return {
+            index: index,
+            byteOffset: byteOffset,
+            byteLength: byteLength
+          };
+        }
+
+        stateObj.buffers.push(buffer);
+        return {
+          encoded: encode(buffer),
+          byteOffset: byteOffset,
+          byteLength: byteLength
+        };
+      },
+      revive: function revive(b64Obj, stateObj) {
+        if (!stateObj.buffers) {
+          stateObj.buffers = [];
+        }
+
+        var byteOffset = b64Obj.byteOffset,
+            byteLength = b64Obj.byteLength,
+            encoded = b64Obj.encoded,
+            index = b64Obj.index;
+        var buffer;
+
+        if ('index' in b64Obj) {
+          buffer = stateObj.buffers[index];
+        } else {
+          buffer = decode(encoded);
+          stateObj.buffers.push(buffer);
+        }
+
+        return new DataView(buffer, byteOffset, byteLength);
+      }
+    }
+  };
+
+  var date = {
+    date: {
+      test: function test(x) {
+        return toStringTag(x) === 'Date';
+      },
+      replace: function replace(dt) {
+        var time = dt.getTime();
+
+        if (Number.isNaN(time)) {
+          return 'NaN';
+        }
+
+        return time;
+      },
+      revive: function revive(time) {
+        if (time === 'NaN') {
+          return new Date(Number.NaN);
+        }
+
+        return new Date(time);
+      }
+    }
+  };
+
+  var error = {
+    error: {
+      test: function test(x) {
+        return toStringTag(x) === 'Error';
+      },
+      replace: function replace(_ref) {
+        var name = _ref.name,
+            message = _ref.message;
+        return {
+          name: name,
+          message: message
+        };
+      },
+      revive: function revive(_ref2) {
+        var name = _ref2.name,
+            message = _ref2.message;
+        var e = new Error(message);
+        e.name = name;
+        return e;
+      }
+    }
+  }; // See also errors.js that may be registered after having registered this type.
+
+  /* eslint-env browser, node */
+  /* c8 ignore next */
+
+  var _global$2 = typeof self === 'undefined' ? global : self;
+
+  var errors = {}; // Comprises all built-in errors.
+
+  ['TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'EvalError', 'URIError', 'InternalError' // non-standard
+  ].forEach(function (errName) {
+    var Cnstrctr = _global$2[errName];
+
+    if (Cnstrctr) {
+      errors[errName.toLowerCase()] = {
+        test: function test(x) {
+          return hasConstructorOf(x, Cnstrctr);
+        },
+        replace: function replace(e) {
+          return e.message;
+        },
+        revive: function revive(message) {
+          return new Cnstrctr(message);
+        }
+      };
+    }
+  });
+
+  /* globals XMLHttpRequest, File, FileReader */
+  var file = {
+    file: {
+      test: function test(x) {
+        return toStringTag(x) === 'File';
+      },
+      replace: function replace(f) {
+        // Sync
+        var req = new XMLHttpRequest();
+        req.overrideMimeType('text/plain; charset=x-user-defined');
+        req.open('GET', URL.createObjectURL(f), false); // Sync
+
+        req.send(); // Seems not feasible to accurately simulate
+
+        /* c8 ignore next 3 */
+
+        if (req.status !== 200 && req.status !== 0) {
+          throw new Error('Bad File access: ' + req.status);
+        }
+
+        return {
+          type: f.type,
+          stringContents: req.responseText,
+          name: f.name,
+          lastModified: f.lastModified
+        };
+      },
+      revive: function revive(_ref) {
+        var name = _ref.name,
+            type = _ref.type,
+            stringContents = _ref.stringContents,
+            lastModified = _ref.lastModified;
+        return new File([string2arraybuffer(stringContents)], name, {
+          type: type,
+          lastModified: lastModified
+        });
+      },
+      replaceAsync: function replaceAsync(f) {
+        return new e(function (resolve, reject) {
+          /*
+          if (f.isClosed) { // On MDN, but not in https://w3c.github.io/FileAPI/#dfn-Blob
+              reject(new Error('The File is closed'));
+              return;
+          }
+          */
+          var reader = new FileReader();
+          reader.addEventListener('load', function () {
+            resolve({
+              type: f.type,
+              stringContents: reader.result,
+              name: f.name,
+              lastModified: f.lastModified
+            });
+          }); // Seems not feasible to accurately simulate
+
+          /* c8 ignore next 3 */
+
+          reader.addEventListener('error', function () {
+            reject(reader.error);
+          });
+          reader.readAsBinaryString(f);
+        });
+      }
+    }
+  };
+
+  var filelist = {
+    file: file.file,
+    filelist: {
+      test: function test(x) {
+        return toStringTag(x) === 'FileList';
+      },
+      replace: function replace(fl) {
+        var arr = [];
+
+        for (var i = 0; i < fl.length; i++) {
+          arr[i] = fl.item(i);
+        }
+
+        return arr;
+      },
+      revive: function revive(o) {
+        /**
+         * `FileList` polyfill.
+         */
+        var FileList = /*#__PURE__*/function (_Symbol$toStringTag) {
+          /**
+           * Set private properties and length.
+           */
+          function FileList() {
+            _classCallCheck$1(this, FileList);
+
+            // eslint-disable-next-line prefer-rest-params
+            this._files = arguments[0];
+            this.length = this._files.length;
+          }
+          /**
+           * @param {Integer} index
+           * @returns {File}
+           */
+
+
+          _createClass$1(FileList, [{
+            key: "item",
+            value: function item(index) {
+              return this._files[index];
+            }
+            /* eslint-disable class-methods-use-this */
+
+            /**
+             * @returns {"FileList"}
+             */
+
+          }, {
+            key: _Symbol$toStringTag,
+            get: function get() {
+              /* eslint-enable class-methods-use-this */
+              return 'FileList';
+            }
+          }]);
+
+          return FileList;
+        }(Symbol.toStringTag);
+
+        return new FileList(o);
+      }
+    }
+  };
+
+  /* globals createImageBitmap */
+  var imagebitmap = {
+    imagebitmap: {
+      test: function test(x) {
+        return toStringTag(x) === 'ImageBitmap' || // In Node, our polyfill sets the dataset on a canvas
+        //  element as JSDom no longer allows overriding toStringTag
+        x && x.dataset && x.dataset.toStringTag === 'ImageBitmap';
+      },
+      replace: function replace(bm) {
+        var canvas = document.createElement('canvas');
+        var ctx = canvas.getContext('2d');
+        ctx.drawImage(bm, 0, 0); // Although `width` and `height` are part of `ImageBitMap`,
+        //   these will be auto-created for us when reviving with the
+        //   data URL (and they are not settable even if they weren't)
+        // return {
+        //   width: bm.width, height: bm.height, dataURL: canvas.toDataURL()
+        // };
+
+        return canvas.toDataURL();
+      },
+      revive: function revive(o) {
+        /*
+        var req = new XMLHttpRequest();
+        req.open('GET', o, false); // Sync
+        if (req.status !== 200 && req.status !== 0) {
+          throw new Error('Bad ImageBitmap access: ' + req.status);
+        }
+        req.send();
+        return req.responseText;
+        */
+        var canvas = document.createElement('canvas');
+        var ctx = canvas.getContext('2d');
+        var img = document.createElement('img'); // The onload is needed by some browsers per http://stackoverflow.com/a/4776378/271577
+
+        img.addEventListener('load', function () {
+          ctx.drawImage(img, 0, 0);
+        });
+        img.src = o; // Works in contexts allowing an `ImageBitmap` (We might use
+        //   `OffscreenCanvas.transferToBitmap` when supported)
+
+        return canvas;
+      },
+      reviveAsync: function reviveAsync(o) {
+        var canvas = document.createElement('canvas');
+        var ctx = canvas.getContext('2d');
+        var img = document.createElement('img'); // The onload is needed by some browsers per http://stackoverflow.com/a/4776378/271577
+
+        img.addEventListener('load', function () {
+          ctx.drawImage(img, 0, 0);
+        });
+        img.src = o; // o.dataURL;
+
+        return createImageBitmap(canvas); // Returns a promise
+      }
+    }
+  };
+
+  var imagedata = {
+    imagedata: {
+      test: function test(x) {
+        return toStringTag(x) === 'ImageData';
+      },
+      replace: function replace(d) {
+        return {
+          // Ensure `length` gets preserved for revival
+          array: _toConsumableArray$1(d.data),
+          width: d.width,
+          height: d.height
+        };
+      },
+      revive: function revive(o) {
+        return new ImageData(new Uint8ClampedArray(o.array), o.width, o.height);
+      }
+    }
+  };
+
+  var infinity = {
+    infinity: {
+      test: function test(x) {
+        return x === Number.POSITIVE_INFINITY;
+      },
+      replace: function replace(n) {
+        return 'Infinity';
+      },
+      revive: function revive(s) {
+        return Number.POSITIVE_INFINITY;
+      }
+    }
+  };
+
+  var IntlCollator = {
+    test: function test(x) {
+      return hasConstructorOf(x, Intl.Collator);
+    },
+    replace: function replace(c) {
+      return c.resolvedOptions();
+    },
+    revive: function revive(options) {
+      return new Intl.Collator(options.locale, options);
+    }
+  };
+  var IntlDateTimeFormat = {
+    test: function test(x) {
+      return hasConstructorOf(x, Intl.DateTimeFormat);
+    },
+    replace: function replace(dtf) {
+      return dtf.resolvedOptions();
+    },
+    revive: function revive(options) {
+      return new Intl.DateTimeFormat(options.locale, options);
+    }
+  };
+  var IntlNumberFormat = {
+    test: function test(x) {
+      return hasConstructorOf(x, Intl.NumberFormat);
+    },
+    replace: function replace(nf) {
+      return nf.resolvedOptions();
+    },
+    revive: function revive(options) {
+      return new Intl.NumberFormat(options.locale, options);
+    }
+  };
+  var intlTypes = {
+    IntlCollator: IntlCollator,
+    IntlDateTimeFormat: IntlDateTimeFormat,
+    IntlNumberFormat: IntlNumberFormat
+  };
+
+  var map = {
+    map: {
+      test: function test(x) {
+        return toStringTag(x) === 'Map';
+      },
+      replace: function replace(mp) {
+        return _toConsumableArray$1(mp.entries());
+      },
+      revive: function revive(entries) {
+        return new Map(entries);
+      }
+    }
+  };
+
+  var nan = {
+    nan: {
+      test: function test(x) {
+        return Number.isNaN(x);
+      },
+      replace: function replace(n) {
+        return 'NaN';
+      },
+      revive: function revive(s) {
+        return Number.NaN;
+      }
+    }
+  };
+
+  var negativeInfinity = {
+    negativeInfinity: {
+      test: function test(x) {
+        return x === Number.NEGATIVE_INFINITY;
+      },
+      replace: function replace(n) {
+        return '-Infinity';
+      },
+      revive: function revive(s) {
+        return Number.NEGATIVE_INFINITY;
+      }
+    }
+  };
+
+  var nonbuiltinIgnore = {
+    nonbuiltinIgnore: {
+      test: function test(x) {
+        return x && _typeof$1(x) === 'object' && !Array.isArray(x) && !['Object', // `Proxy` and `Reflect`, two other built-in objects, will also
+        //   have a `toStringTag` of `Object`; we don't want built-in
+        //   function objects, however
+        'Boolean', 'Number', 'String', 'Error', 'RegExp', 'Math', 'Date', 'Map', 'Set', 'JSON', 'ArrayBuffer', 'SharedArrayBuffer', 'DataView', 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array', 'Promise', 'String Iterator', 'Array Iterator', 'Map Iterator', 'Set Iterator', 'WeakMap', 'WeakSet', 'Atomics', 'Module'].includes(toStringTag(x));
+      },
+      replace: function replace(rexp) {// Not in use
+      }
+    }
+  };
+
+  var primitiveObjects = {
+    // String Object (not primitive string which need no type spec)
+    StringObject: {
+      test: function test(x) {
+        return toStringTag(x) === 'String' && _typeof$1(x) === 'object';
+      },
+      replace: function replace(s) {
+        return String(s);
+      },
+      // convert to primitive string
+      revive: function revive(s) {
+        return new String(s);
+      } // Revive to an objectified string
+
+    },
+    // Boolean Object (not primitive boolean which need no type spec)
+    BooleanObject: {
+      test: function test(x) {
+        return toStringTag(x) === 'Boolean' && _typeof$1(x) === 'object';
+      },
+      replace: function replace(b) {
+        return Boolean(b);
+      },
+      // convert to primitive boolean
+      revive: function revive(b) {
+        // Revive to an objectified Boolean
+        return new Boolean(b);
+      }
+    },
+    // Number Object (not primitive number which need no type spec)
+    NumberObject: {
+      test: function test(x) {
+        return toStringTag(x) === 'Number' && _typeof$1(x) === 'object';
+      },
+      replace: function replace(n) {
+        return Number(n);
+      },
+      // convert to primitive number
+      revive: function revive(n) {
+        return new Number(n);
+      } // Revive to an objectified number
+
+    }
+  };
+
+  var regexp = {
+    regexp: {
+      test: function test(x) {
+        return toStringTag(x) === 'RegExp';
+      },
+      replace: function replace(rexp) {
+        return {
+          source: rexp.source,
+          flags: (rexp.global ? 'g' : '') + (rexp.ignoreCase ? 'i' : '') + (rexp.multiline ? 'm' : '') + (rexp.sticky ? 'y' : '') + (rexp.unicode ? 'u' : '')
+        };
+      },
+      revive: function revive(_ref) {
+        var source = _ref.source,
+            flags = _ref.flags;
+        return new RegExp(source, flags);
+      }
+    }
+  };
+
+  var resurrectableObjectsByUUID = {};
+  var resurrectable = {
+    resurrectable: {
+      test: function test(x) {
+        return x && !Array.isArray(x) && ['object', 'function', 'symbol'].includes(_typeof$1(x));
+      },
+      replace: function replace(rsrrctble) {
+        var uuid = generateUUID();
+        resurrectableObjectsByUUID[uuid] = rsrrctble;
+        return uuid;
+      },
+      revive: function revive(serializedResurrectable) {
+        return resurrectableObjectsByUUID[serializedResurrectable];
+      }
+    }
+  };
+
+  var set = {
+    set: {
+      test: function test(x) {
+        return toStringTag(x) === 'Set';
+      },
+      replace: function replace(st) {
+        return _toConsumableArray$1(st.values());
+      },
+      revive: function revive(values) {
+        return new Set(values);
+      }
+    }
+  };
+
+  /* eslint-env browser, node */
+  /* c8 ignore next */
+
+  var _global$1 = typeof self === 'undefined' ? global : self; // Support all kinds of typed arrays (views of ArrayBuffers)
+
+
+  var typedArraysSocketIO = {};
+  ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'].forEach(function (typeName) {
+    var arrType = typeName;
+    var TypedArray = _global$1[typeName];
+    /* c8 ignore next 3 */
+
+    if (!TypedArray) {
+      return;
+    }
+
+    typedArraysSocketIO[typeName.toLowerCase()] = {
+      test: function test(x) {
+        return toStringTag(x) === arrType;
+      },
+      replace: function replace(a) {
+        return (a.byteOffset === 0 && a.byteLength === a.buffer.byteLength ? a // socket.io supports streaming ArrayBuffers.
+        // If we have a typed array representing a portion
+        //   of the buffer, we need to clone
+        //   the buffer before leaving it to socket.io.
+        : a.slice(0)).buffer;
+      },
+      revive: function revive(buf) {
+        // One may configure socket.io to revive binary data as
+        //    Buffer or Blob.
+        // We should therefore not rely on that the instance we
+        //   get here is an ArrayBuffer
+        // If not, let's assume user wants to receive it as
+        //   configured with socket.io.
+        return toStringTag(buf) === 'ArrayBuffer' ? new TypedArray(buf) : buf;
+      }
+    };
+  });
+
+  /* eslint-env browser, node */
+  /* c8 ignore next */
+
+  var _global = typeof self === 'undefined' ? global : self;
+
+  var typedArrays = {};
+  ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'].forEach(function (typeName) {
+    var arrType = typeName;
+    var TypedArray = _global[arrType];
+    /* c8 ignore next 3 */
+
+    if (!TypedArray) {
+      return;
+    }
+
+    typedArrays[typeName.toLowerCase()] = {
+      test: function test(x) {
+        return toStringTag(x) === arrType;
+      },
+      replace: function replace(_ref, stateObj) {
+        var buffer = _ref.buffer,
+            byteOffset = _ref.byteOffset,
+            l = _ref.length;
+
+        if (!stateObj.buffers) {
+          stateObj.buffers = [];
+        }
+
+        var index = stateObj.buffers.indexOf(buffer);
+
+        if (index > -1) {
+          return {
+            index: index,
+            byteOffset: byteOffset,
+            length: l
+          };
+        }
+
+        stateObj.buffers.push(buffer);
+        return {
+          encoded: encode(buffer),
+          byteOffset: byteOffset,
+          length: l
+        };
+      },
+      revive: function revive(b64Obj, stateObj) {
+        if (!stateObj.buffers) {
+          stateObj.buffers = [];
+        }
+
+        var byteOffset = b64Obj.byteOffset,
+            len = b64Obj.length,
+            encoded = b64Obj.encoded,
+            index = b64Obj.index;
+        var buffer;
+
+        if ('index' in b64Obj) {
+          buffer = stateObj.buffers[index];
+        } else {
+          buffer = decode(encoded);
+          stateObj.buffers.push(buffer);
+        }
+
+        return new TypedArray(buffer, byteOffset, len);
+      }
+    };
+  });
+
+  // This does not preserve `undefined` in sparse arrays; see the `undef`
+  var undef$1 = {
+    undef: {
+      test: function test(x, stateObj) {
+        return typeof x === 'undefined' && (stateObj.ownKeys || !('ownKeys' in stateObj));
+      },
+      replace: function replace(n) {
+        return 0;
+      },
+      revive: function revive(s) {
+        // Will add `undefined` (returning `undefined` would instead
+        //   avoid explicitly setting)
+        return new p();
+      }
+    }
+  };
+
+  var userObject = {
+    userObject: {
+      test: function test(x, stateObj) {
+        return isUserObject(x);
+      },
+      replace: function replace(n) {
+        return _objectSpread2$1({}, n);
+      },
+      revive: function revive(s) {
+        return s;
+      }
+    }
+  };
+
+  var arrayNonindexKeys = [{
+    arrayNonindexKeys: {
+      testPlainObjects: true,
+      test: function test(x, stateObj) {
+        if (Array.isArray(x)) {
+          if ( // By avoiding serializing arrays into objects which
+          //  have only positive-integer keys, we reduce
+          //  size and improve revival performance; arrays with
+          //  non-index keys will be larger however
+          Object.keys(x).some(function (k) {
+            //  No need to check for `isNaN` or
+            //   `isNaN(Number.parseInt())` as `NaN` will be
+            //   treated as a string.
+            //  No need to do check as
+            //   `Number.parseInt(Number())` since scientific
+            //   notation will be pre-resolved if a number
+            //   was given, and it will otherwise be a string
+            return String(Number.parseInt(k)) !== k;
+          })) {
+            stateObj.iterateIn = 'object';
+            stateObj.addLength = true;
+          }
+
+          return true;
+        }
+
+        return false;
+      },
+      replace: function replace(a, stateObj) {
+        // Catch sparse undefined
+        stateObj.iterateUnsetNumeric = true;
+        return a;
+      },
+      revive: function revive(o) {
+        if (Array.isArray(o)) {
+          return o;
+        }
+
+        var arr = []; // No map here as may be a sparse array (including
+        //   with `length` set)
+        // Todo: Reenable when Node `engines` >= 7
+        // Object.entries(o).forEach(([key, val]) => {
+
+        Object.keys(o).forEach(function (key) {
+          var val = o[key];
+          arr[key] = val;
+        });
+        return arr;
+      }
+    }
+  }, {
+    sparseUndefined: {
+      test: function test(x, stateObj) {
+        return typeof x === 'undefined' && stateObj.ownKeys === false;
+      },
+      replace: function replace(n) {
+        return 0;
+      },
+      revive: function revive(s) {
+        return undefined;
+      } // Will avoid adding anything
+
+    }
+  }];
+
+  var specialNumbers = [nan, infinity, negativeInfinity];
+
+  /* This preset includes types that are built-in into the JavaScript
+      language itself, this should work universally.
+
+    Types that were added in ES6 or beyond will be checked before inclusion
+     so that this module can be consumed by both ES5 and ES6 environments.
+
+    Some types cannot be encapsulated because their inner state is private:
+      `WeakMap`, `WeakSet`.
+
+    The Function type is not included because their closures would not be
+      serialized, so a revived Function that uses closures would not behave
+      as expected.
+
+    Symbols are similarly not included.
+  */
+  var expObj$1 = [undef$1, // ES5
+  arrayNonindexKeys, primitiveObjects, specialNumbers, date, error, errors, regexp].concat( // ES2015 (ES6)
+
+  /* c8 ignore next */
+  typeof Map === 'function' ? map : [],
+  /* c8 ignore next */
+  typeof Set === 'function' ? set : [],
+  /* c8 ignore next */
+  typeof ArrayBuffer === 'function' ? arraybuffer : [],
+  /* c8 ignore next */
+  typeof Uint8Array === 'function' ? typedArrays : [],
+  /* c8 ignore next */
+  typeof DataView === 'function' ? dataview : [],
+  /* c8 ignore next */
+  typeof Intl !== 'undefined' ? intlTypes : [],
+  /* c8 ignore next */
+  typeof BigInt !== 'undefined' ? [bigint, bigintObject] : []);
+
+  /*
+  When communicating via `postMessage()` (`Worker.postMessage()` or
+  `window.postMessage()`), the browser will use a similar algorithm as Typeson
+  does to encapsulate and revive all items in the structure (aka the structured
+  clone algorithm). This algorithm supports all built-in types as well as many
+  DOM types. Therefore, only types that are not included in the structured clone
+  algorithm need to be registered, which is:
+
+  * Error
+  * Specific Errors like SyntaxError, TypeError, etc.
+  * Any custom type you want to send across window- or worker boundraries
+
+  This preset will only include the Error types and you can register your
+  custom types after having registered these.
+  */
+  var postmessage = [error, errors];
+
+  var socketio = [expObj$1, // Leave ArrayBuffer as is, and let socket.io stream it instead.
+  {
+    arraybuffer: null
+  }, // Encapsulate TypedArrays in ArrayBuffers instead of base64 strings.
+  typedArraysSocketIO];
+
+  var sparseUndefined = [{
+    sparseArrays: {
+      testPlainObjects: true,
+      test: function test(x) {
+        return Array.isArray(x);
+      },
+      replace: function replace(a, stateObj) {
+        stateObj.iterateUnsetNumeric = true;
+        return a;
+      }
+    }
+  }, {
+    sparseUndefined: {
+      test: function test(x, stateObj) {
+        return typeof x === 'undefined' && stateObj.ownKeys === false;
+      },
+      replace: function replace(n) {
+        return 0;
+      },
+      revive: function revive(s) {
+        return undefined;
+      } // Will avoid adding anything
+
+    }
+  }];
+
+  /* This preset includes types for the Structured Cloning Algorithm. */
+  var expObj = [// Todo: Might also register synchronous `ImageBitmap` and
+  //    `Blob`/`File`/`FileList`?
+  // ES5
+  userObject, // Processed last (non-builtin)
+  undef$1, arrayNonindexKeys, primitiveObjects, specialNumbers, date, regexp, // Non-built-ins
+  imagedata, imagebitmap, // Async return
+  file, filelist, blob].concat( // ES2015 (ES6)
+
+  /* c8 ignore next */
+  typeof Map === 'function' ? map : [],
+  /* c8 ignore next */
+  typeof Set === 'function' ? set : [],
+  /* c8 ignore next */
+  typeof ArrayBuffer === 'function' ? arraybuffer : [],
+  /* c8 ignore next */
+  typeof Uint8Array === 'function' ? typedArrays : [],
+  /* c8 ignore next */
+  typeof DataView === 'function' ? dataview : [],
+  /* c8 ignore next */
+  typeof Intl !== 'undefined' ? intlTypes : [],
+  /* c8 ignore next */
+  typeof crypto !== 'undefined' ? cryptokey : [],
+  /* c8 ignore next */
+  typeof BigInt !== 'undefined' ? [bigint, bigintObject] : []);
+
+  var structuredCloningThrowing = expObj.concat({
+    checkDataCloneException: {
+      test: function test(val) {
+        // Should also throw with:
+        // 1. `IsDetachedBuffer` (a process not called within the
+        //      ECMAScript spec)
+        // 2. `IsCallable` (covered by `typeof === 'function'` or a
+        //       function's `toStringTag`)
+        // 3. internal slots besides [[Prototype]] or [[Extensible]] (e.g.,
+        //        [[PromiseState]] or [[WeakMapData]])
+        // 4. exotic object (e.g., `Proxy`) (unless an `%ObjectPrototype%`
+        //      intrinsic object) (which does not have default
+        //      behavior for one or more of the essential internal methods
+        //      that are limited to the following for non-function objects
+        //      (we auto-exclude functions):
+        //      [[GetPrototypeOf]],[[SetPrototypeOf]],[[IsExtensible]],
+        //      [[PreventExtensions]],[[GetOwnProperty]],
+        //      [[DefineOwnProperty]],[[HasProperty]],
+        //      [[Get]],[[Set]],[[Delete]],[[OwnPropertyKeys]]);
+        //      except for the standard, built-in exotic objects, we'd need
+        //      to know whether these methods had distinct behaviors
+        // Note: There is no apparent way for us to detect a `Proxy` and
+        //      reject (Chrome at least is not rejecting anyways)
+        var stringTag = {}.toString.call(val).slice(8, -1);
+
+        if ([// Symbol's `toStringTag` is only "Symbol" for its initial
+        //   value, so we check `typeof`
+        'symbol', // All functions including bound function exotic objects
+        'function'].includes(_typeof$1(val)) || [// A non-array exotic object
+        'Arguments', // A non-array exotic object
+        'Module', // `Error` and other errors have the [[ErrorData]] internal
+        //    slot and give "Error"
+        'Error', // Promise instances have an extra slot ([[PromiseState]])
+        //    but not throwing in Chrome `postMessage`
+        'Promise', // WeakMap instances have an extra slot ([[WeakMapData]])
+        //    but not throwing in Chrome `postMessage`
+        'WeakMap', // WeakSet instances have an extra slot ([[WeakSetData]])
+        //    but not throwing in Chrome `postMessage`
+        'WeakSet', // HTML-SPECIFIC
+        'Event', // Also in Node `worker_threads` (currently experimental)
+        'MessageChannel'].includes(stringTag) ||
+        /*
+        // isClosed is no longer documented
+        ((stringTag === 'Blob' || stringTag === 'File') &&
+            val.isClosed) ||
+        */
+        val && _typeof$1(val) === 'object' && // Duck-type DOM node objects (non-array exotic?
+        //    objects which cannot be cloned by the SCA)
+        typeof val.nodeType === 'number' && typeof val.insertBefore === 'function') {
+          throw new DOMException('The object cannot be cloned.', 'DataCloneError');
+        }
+
+        return false;
+      }
+    }
+  });
+
+  var undef = [sparseUndefined, undef$1];
+
+  var universal = [expObj$1 // TODO: Add types that are de-facto universal even though not
+  //   built-in into ecmasript standard.
+  ];
+
+  exports.JSON_TYPES = y;
+  exports.Typeson = u;
+  exports.TypesonPromise = e;
+  exports.Undefined = p;
+  exports.arrayNonindexKeys = arrayNonindexKeys;
+  exports.arraybuffer = arraybuffer;
+  exports.bigint = bigint;
+  exports.bigintObject = bigintObject;
+  exports.blob = blob;
+  exports.builtin = expObj$1;
+  exports.cloneable = cloneable;
+  exports.cryptokey = cryptokey;
+  exports.dataview = dataview;
+  exports.date = date;
+  exports.error = error;
+  exports.errors = errors;
+  exports.escapeKeyPathComponent = escapeKeyPathComponent;
+  exports.file = file;
+  exports.filelist = filelist;
+  exports.getByKeyPath = getByKeyPath;
+  exports.getJSONType = getJSONType;
+  exports.hasConstructorOf = hasConstructorOf;
+  exports.imagebitmap = imagebitmap;
+  exports.imagedata = imagedata;
+  exports.infinity = infinity;
+  exports.intlTypes = intlTypes;
+  exports.isObject = isObject;
+  exports.isPlainObject = isPlainObject;
+  exports.isThenable = isThenable;
+  exports.isUserObject = isUserObject;
+  exports.map = map;
+  exports.nan = nan;
+  exports.negativeInfinity = negativeInfinity;
+  exports.nonbuiltinIgnore = nonbuiltinIgnore;
+  exports.postmessage = postmessage;
+  exports.primitiveObjects = primitiveObjects;
+  exports.regexp = regexp;
+  exports.resurrectable = resurrectable;
+  exports.set = set;
+  exports.setAtKeyPath = setAtKeyPath;
+  exports.socketio = socketio;
+  exports.sparseUndefined = sparseUndefined;
+  exports.specialNumbers = specialNumbers;
+  exports.structuredCloning = expObj;
+  exports.structuredCloningThrowing = structuredCloningThrowing;
+  exports.toStringTag = toStringTag;
+  exports.typedArrays = typedArrays;
+  exports.typedArraysSocketio = typedArraysSocketIO;
+  exports.undef = undef$1;
+  exports.undefPreset = undef;
+  exports.unescapeKeyPathComponent = unescapeKeyPathComponent;
+  exports.universal = universal;
+  exports.userObject = userObject;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.js.map