typeson-registry 2.0.0 → 4.0.0

package/dist/index.umd.js

@@ -6,17 +6,14 @@
 
   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] : {};
@@ -26,10 +23,309 @@
         Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
       });
     }
-
     return target;
   }
-
+  function _regeneratorRuntime() {
+    _regeneratorRuntime = function () {
+      return exports;
+    };
+    var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      defineProperty = Object.defineProperty || function (obj, key, desc) {
+        obj[key] = desc.value;
+      },
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+    function define(obj, key, value) {
+      return Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      }), obj[key];
+    }
+    try {
+      define({}, "");
+    } catch (err) {
+      define = function (obj, key, value) {
+        return obj[key] = value;
+      };
+    }
+    function wrap(innerFn, outerFn, self, tryLocsList) {
+      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+      return defineProperty(generator, "_invoke", {
+        value: makeInvokeMethod(innerFn, self, context)
+      }), generator;
+    }
+    function tryCatch(fn, obj, arg) {
+      try {
+        return {
+          type: "normal",
+          arg: fn.call(obj, arg)
+        };
+      } catch (err) {
+        return {
+          type: "throw",
+          arg: err
+        };
+      }
+    }
+    exports.wrap = wrap;
+    var ContinueSentinel = {};
+    function Generator() {}
+    function GeneratorFunction() {}
+    function GeneratorFunctionPrototype() {}
+    var IteratorPrototype = {};
+    define(IteratorPrototype, iteratorSymbol, function () {
+      return this;
+    });
+    var getProto = Object.getPrototypeOf,
+      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+    NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+    function defineIteratorMethods(prototype) {
+      ["next", "throw", "return"].forEach(function (method) {
+        define(prototype, method, function (arg) {
+          return this._invoke(method, arg);
+        });
+      });
+    }
+    function AsyncIterator(generator, PromiseImpl) {
+      function invoke(method, arg, resolve, reject) {
+        var record = tryCatch(generator[method], generator, arg);
+        if ("throw" !== record.type) {
+          var result = record.arg,
+            value = result.value;
+          return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+            invoke("next", value, resolve, reject);
+          }, function (err) {
+            invoke("throw", err, resolve, reject);
+          }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+            result.value = unwrapped, resolve(result);
+          }, function (error) {
+            return invoke("throw", error, resolve, reject);
+          });
+        }
+        reject(record.arg);
+      }
+      var previousPromise;
+      defineProperty(this, "_invoke", {
+        value: function (method, arg) {
+          function callInvokeWithMethodAndArg() {
+            return new PromiseImpl(function (resolve, reject) {
+              invoke(method, arg, resolve, reject);
+            });
+          }
+          return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+        }
+      });
+    }
+    function makeInvokeMethod(innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }
+    function maybeInvokeDelegate(delegate, context) {
+      var methodName = context.method,
+        method = delegate.iterator[methodName];
+      if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
+      var record = tryCatch(method, delegate.iterator, context.arg);
+      if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+      var info = record.arg;
+      return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+    }
+    function pushTryEntry(locs) {
+      var entry = {
+        tryLoc: locs[0]
+      };
+      1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+    }
+    function resetTryEntry(entry) {
+      var record = entry.completion || {};
+      record.type = "normal", delete record.arg, entry.completion = record;
+    }
+    function Context(tryLocsList) {
+      this.tryEntries = [{
+        tryLoc: "root"
+      }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+    }
+    function values(iterable) {
+      if (iterable) {
+        var iteratorMethod = iterable[iteratorSymbol];
+        if (iteratorMethod) return iteratorMethod.call(iterable);
+        if ("function" == typeof iterable.next) return iterable;
+        if (!isNaN(iterable.length)) {
+          var i = -1,
+            next = function next() {
+              for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+              return next.value = undefined, next.done = !0, next;
+            };
+          return next.next = next;
+        }
+      }
+      return {
+        next: doneResult
+      };
+    }
+    function doneResult() {
+      return {
+        value: undefined,
+        done: !0
+      };
+    }
+    return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
+      value: GeneratorFunctionPrototype,
+      configurable: !0
+    }), defineProperty(GeneratorFunctionPrototype, "constructor", {
+      value: GeneratorFunction,
+      configurable: !0
+    }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+      var ctor = "function" == typeof genFun && genFun.constructor;
+      return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+    }, exports.mark = function (genFun) {
+      return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+    }, exports.awrap = function (arg) {
+      return {
+        __await: arg
+      };
+    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+      return this;
+    }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+      void 0 === PromiseImpl && (PromiseImpl = Promise);
+      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+      return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+        return result.done ? result.value : iter.next();
+      });
+    }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+      return this;
+    }), define(Gp, "toString", function () {
+      return "[object Generator]";
+    }), exports.keys = function (val) {
+      var object = Object(val),
+        keys = [];
+      for (var key in object) keys.push(key);
+      return keys.reverse(), function next() {
+        for (; keys.length;) {
+          var key = keys.pop();
+          if (key in object) return next.value = key, next.done = !1, next;
+        }
+        return next.done = !0, next;
+      };
+    }, exports.values = values, Context.prototype = {
+      constructor: Context,
+      reset: function (skipTempReset) {
+        if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+      },
+      stop: function () {
+        this.done = !0;
+        var rootRecord = this.tryEntries[0].completion;
+        if ("throw" === rootRecord.type) throw rootRecord.arg;
+        return this.rval;
+      },
+      dispatchException: function (exception) {
+        if (this.done) throw exception;
+        var context = this;
+        function handle(loc, caught) {
+          return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+        }
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i],
+            record = entry.completion;
+          if ("root" === entry.tryLoc) return handle("end");
+          if (entry.tryLoc <= this.prev) {
+            var hasCatch = hasOwn.call(entry, "catchLoc"),
+              hasFinally = hasOwn.call(entry, "finallyLoc");
+            if (hasCatch && hasFinally) {
+              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+            } else if (hasCatch) {
+              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            } else {
+              if (!hasFinally) throw new Error("try statement without catch or finally");
+              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+            }
+          }
+        }
+      },
+      abrupt: function (type, arg) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+            var finallyEntry = entry;
+            break;
+          }
+        }
+        finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+        var record = finallyEntry ? finallyEntry.completion : {};
+        return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+      },
+      complete: function (record, afterLoc) {
+        if ("throw" === record.type) throw record.arg;
+        return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+      },
+      finish: function (finallyLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+        }
+      },
+      catch: function (tryLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.tryLoc === tryLoc) {
+            var record = entry.completion;
+            if ("throw" === record.type) {
+              var thrown = record.arg;
+              resetTryEntry(entry);
+            }
+            return thrown;
+          }
+        }
+        throw new Error("illegal catch attempt");
+      },
+      delegateYield: function (iterable, resultName, nextLoc) {
+        return this.delegate = {
+          iterator: values(iterable),
+          resultName: resultName,
+          nextLoc: nextLoc
+        }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+      }
+    }, exports;
+  }
   function _typeof$1(obj) {
     "@babel/helpers - typeof";
 
@@ -39,7 +335,6 @@
       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);
@@ -48,50 +343,42 @@
       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;
+        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);
+      Object.defineProperty(target, _toPropertyKey$1(descriptor.key), descriptor);
     }
   }
-
   function _createClass$1(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
     if (staticProps) _defineProperties$1(Constructor, staticProps);
@@ -100,8 +387,8 @@
     });
     return Constructor;
   }
-
   function _defineProperty$1(obj, key, value) {
+    key = _toPropertyKey$1(key);
     if (key in obj) {
       Object.defineProperty(obj, key, {
         value: value,
@@ -112,22 +399,17 @@
     } 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);
@@ -136,32 +418,39 @@
     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 _toPrimitive(input, hint) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+      var res = prim.call(input, hint || "default");
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  function _toPropertyKey$1(arg) {
+    var key = _toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
 
   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] : {};
@@ -171,76 +460,70 @@
         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 = "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);
+    }, _typeof(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);
+      n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, _toPropertyKey(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, {
+    return (t = _toPropertyKey(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,
+      if (null != r) {
+        var n,
+          o,
           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 {
+          i,
+          c = [],
+          s = !0,
+          u = !1;
         try {
-          i || null == r["return"] || r["return"]();
+          if (a = (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);
+        } catch (e) {
+          u = !0, o = e;
         } finally {
-          if (c) throw a;
+          try {
+            if (!s && null != r["return"] && (i = r["return"](), Object(i) !== i)) return;
+          } finally {
+            if (u) throw o;
+          }
         }
+        return c;
       }
-
-      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);
@@ -250,7 +533,6 @@
       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);
@@ -258,29 +540,35 @@
       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];
-    }
-
+    for (var r = 0, n = new Array(t); r < t; r++) n[r] = e[r];
     return n;
   }
-
+  function _toPropertyKey(e) {
+    var t = function _toPrimitive(e, t) {
+      if ("object" != _typeof$1(e) || null === e) return e;
+      var r = e[Symbol.toPrimitive];
+      if (void 0 !== r) {
+        var n = r.call(e, t || "default");
+        if ("object" != _typeof$1(n)) return n;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === t ? String : Number)(e);
+    }(e, "string");
+    return "symbol" == _typeof$1(t) ? t : String(t);
+  }
   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) {
+    return new e(function (e, o) {
       n.p.then(function (r) {
         e(t ? t(r) : r);
       })["catch"](function (e) {
         return r ? r(e) : Promise.reject(e);
-      }).then(e, a);
+      }).then(e, o);
     });
   }, e.prototype["catch"] = function (e) {
     return this.then(null, e);
@@ -302,85 +590,66 @@
     };
   });
   var t = {}.toString,
-      r = {}.hasOwnProperty,
-      n = Object.getPrototypeOf,
-      a = r.toString;
-
+    r = {}.hasOwnProperty,
+    n = Object.getPrototypeOf,
+    o = 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__;
+    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__;
   }
-
   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");
+    return e.replace(/''/g, "''''").replace(/^$/, "''").replace(/~/g, "~0").replace(/\./g, "~1");
   }
-
   function unescapeKeyPathComponent(e) {
-    return e.replace(/~1/g, ".").replace(/~0/g, "~");
+    return e.replace(/~1/g, ".").replace(/~0/g, "~").replace(/^''$/, "").replace(/''''/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"];
-
+  var a = 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];
-      }
-
+      for (var t = [], r = 0; r < arguments.length; r++) t[r] = arguments[r];
       try {
         return Promise.resolve(e.apply(this, t));
       } catch (e) {
@@ -388,533 +657,475 @@
       }
     };
   }
-
   function nestedPathsFirst(e, t) {
     if ("" === e.keypath) return -1;
     var r = e.keypath.match(/\./g) || 0,
-        n = t.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);
+      function Typeson(e) {
+        _classCallCheck(this, Typeson), this.options = e, this.plainObjectReplacers = [], this.nonplainObjectReplacers = [], this.revivers = {}, this.types = {};
       }
-    }, {
-      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;
+      return _createClass(Typeson, [{
+        key: "stringify",
+        value: function stringify(e, t, r, n) {
+          n = _objectSpread2(_objectSpread2(_objectSpread2({}, this.options), n), {}, {
+            stringification: !0
+          });
+          var o = this.encapsulate(e, null, n);
+          return i$1(o) ? JSON.stringify(o[0], t, r) : o.then(function (e) {
+            return JSON.stringify(e, t, r);
+          });
+        }
+      }, {
+        key: "stringifySync",
+        value: function stringifySync(e, t, r, n) {
+          return this.stringify(e, t, r, _objectSpread2(_objectSpread2({
+            throwOnBadSyncType: !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 o = _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,
+                    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);
+                  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;
+                    });
+                  }, function (e) {
+                    return a ? e : (u ? y[f] = v : t = b ? v.p : v, o(t, i));
+                  });
+                }))), function () {
+                  return t;
                 });
-              }, 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,
+              sync: !0
+            }, this.options), n)).sync,
             p = this,
-            y = {},
-            l = [],
+            l = {},
+            y = [],
             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 = {
+            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: {
-                $: 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,
+              $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 = 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),
+              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 = (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)
+              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)
+                };
+                _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);
+                });
               };
-
-              _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
               });
-            };
-
-            for (var A in r) {
-              w(A);
-            }
-
-            j && j({
-              endIterateIn: !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
             });
-          } 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);
+            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);
+                    });
+                  }
+                }, N = 0; N < C; N++) k(N);
+              j && j({
+                endIterateUnsetNumeric: !0,
+                end: !0
+              });
             }
-
-            j && j({
-              endIterateUnsetNumeric: !0,
-              end: !0
-            });
+            return g;
           }
-
-          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;
+          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;
+                }
+                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 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 t;
+          return h.length ? u && n.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));
         }
-
-        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,
+      }, {
+        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 o = (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,
+          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);
+          }
+          var y = [];
+          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],
+              var r = [];
+              if (Object.entries(n).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,
+                    type: e
+                  }), delete n[o]);
+                });
+              }), r.length) return r.sort(nestedPathsFirst).reduce(function reducer(r, n) {
+                var o = n.keypath,
+                  a = n.type;
+                if (isThenable(r)) return r.then(function (e) {
+                  return reducer(e, {
+                    keypath: o,
+                    type: a
+                  });
+                });
+                var i = getByKeyPath(t, o);
+                if (hasConstructorOf(i = executeReviver(a, i), e)) return i.then(function (e) {
+                  var r = setAtKeyPath(t, o, e);
+                  r === e && (t = r);
+                });
+                var c = setAtKeyPath(t, o, i);
+                c === i && (t = c);
+              }, void 0);
+            }();
+          return hasConstructorOf(h, e) ? f = h.then(function () {
+            return t;
+          }) : (f = function _revive(t, r, o, s, l) {
+            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),
+              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;
-                };
-
-                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);
+                      return hasConstructorOf(e, p) ? v[n] = void 0 : void 0 !== e && (v[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],
+                    j = b[3],
+                    m = getByKeyPath(d, _);
+                  if (void 0 === m) break;
+                  O[j] = m, c.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;
+              }
+              return [].concat(f).reduce(function reducer(t, r) {
+                return hasConstructorOf(t, e) ? t.then(function (e) {
+                  return reducer(e, r);
+                }) : executeReviver(r, t);
+              }, r);
             }
-
-            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);
+          }("", t, null), y.length && (f = e.resolve(f).then(function (t) {
+            return e.all([t].concat(y));
+          }).then(function (e) {
+            return _slicedToArray(e, 1)[0];
+          }))), isThenable(f) ? o && r.throwOnBadSyncType ? function () {
+            throw new TypeError("Sync method requested but async result obtained");
+          }() : hasConstructorOf(f, e) ? f.p.then(checkUndefined) : f : !o && r.throwOnBadSyncType ? function () {
+            throw new TypeError("Async method requested but sync result obtained");
+          }() : o ? 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 && 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);
+                  }
+                };
+              } 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
+                  }];
                 }
-              };
-            } 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] = o;
               }
-
-              r.types[n] = a;
-            }
-          });
-        };
-
-        return [].concat(e).forEach(function (e) {
-          return n(e);
-        }), this;
-      }
-    }]), Typeson;
-  }(),
-      p = _createClass(function Undefined() {
-    _classCallCheck(this, Undefined);
-  });
-
+            });
+          };
+          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"];
+  var l = ["null", "boolean", "number", "string", "array", "object"];
 
   /*
    * base64-arraybuffer
@@ -926,7 +1137,6 @@
   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;
   }
@@ -937,30 +1147,27 @@
    * @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
+    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;
   };
   /**
@@ -968,24 +1175,19 @@
    * @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);
-
+      bytes = new Uint8Array(arraybuffer);
     for (var _i2 = 0; _i2 < len; _i2 += 4) {
       encoded1 = lookup[base64.codePointAt(_i2)];
       encoded2 = lookup[base64.codePointAt(_i2 + 1)];
@@ -995,7 +1197,6 @@
       bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
       bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
     }
-
     return arraybuffer;
   };
 
@@ -1008,15 +1209,12 @@
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
-
         var index = stateObj.buffers.indexOf(b);
-
         if (index > -1) {
           return {
             index: index
           };
         }
-
         stateObj.buffers.push(b);
         return encode(b);
       },
@@ -1024,27 +1222,24 @@
         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!
+
+  // 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);
-      },
+      replace: String,
       revive: function revive(s) {
         // Filed this to avoid error: https://github.com/eslint/eslint/issues/11810
         // eslint-disable-next-line no-new-object
@@ -1054,17 +1249,14 @@
   };
 
   /* 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);
-      }
+      replace: String,
+      revive: BigInt
     }
   };
 
@@ -1073,13 +1265,12 @@
    * @param {ArrayBuffer} buf
    * @returns {Uint8Array}
    */
+
   /**
    *
    * @param {string} str
    * @returns {ArrayBuffer}
    */
-
-
   function string2arraybuffer(str) {
     /*
     // UTF-8 approaches
@@ -1116,7 +1307,6 @@
     }
     return utf8;
     */
-
     /*
     // Working UTF-16 options (equivalents)
     const buf = new ArrayBuffer(str.length * 2); // 2 bytes for each char
@@ -1126,8 +1316,8 @@
     }
     return buf;
     */
-    var array = new Uint8Array(str.length);
 
+    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
@@ -1148,15 +1338,13 @@
         var req = new XMLHttpRequest();
         req.overrideMimeType('text/plain; charset=x-user-defined');
         req.open('GET', URL.createObjectURL(b), false); // Sync
+        req.send();
 
-        req.send(); // Seems not feasible to accurately simulate
-
+        // 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
@@ -1164,7 +1352,7 @@
       },
       revive: function revive(_ref) {
         var type = _ref.type,
-            stringContents = _ref.stringContents;
+          stringContents = _ref.stringContents;
         return new Blob([string2arraybuffer(stringContents)], {
           type: type
         });
@@ -1183,10 +1371,9 @@
               type: b.type,
               stringContents: reader.result
             });
-          }); // Seems not feasible to accurately simulate
-
+          });
+          // Seems not feasible to accurately simulate
           /* c8 ignore next 3 */
-
           reader.addEventListener('error', function () {
             reject(reader.error);
           });
@@ -1197,6 +1384,7 @@
   };
 
   /* globals performance */
+
   // The `performance` global is optional
 
   /**
@@ -1208,10 +1396,9 @@
    */
   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
-
+    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) {
@@ -1240,7 +1427,7 @@
       },
       revive: function revive(_ref) {
         var uuid = _ref.uuid,
-            encapsulated = _ref.encapsulated;
+          encapsulated = _ref.encapsulated;
         return cloneableObjectsByUUID[uuid][Symbol["for"]('cloneRevive')](encapsulated);
       }
     }
@@ -1253,42 +1440,35 @@
       },
       replaceAsync: function replaceAsync(key) {
         return new e( /*#__PURE__*/function () {
-          var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(resolve, reject) {
+          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();
-                }
+            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);
           };
@@ -1296,8 +1476,8 @@
       },
       revive: function revive(_ref2) {
         var jwk = _ref2.jwk,
-            algorithm = _ref2.algorithm,
-            usages = _ref2.usages;
+          algorithm = _ref2.algorithm,
+          usages = _ref2.usages;
         return crypto.subtle.importKey('jwk', jwk, algorithm, true, usages);
       }
     }
@@ -1310,15 +1490,12 @@
       },
       replace: function replace(_ref, stateObj) {
         var buffer = _ref.buffer,
-            byteOffset = _ref.byteOffset,
-            byteLength = _ref.byteLength;
-
+          byteOffset = _ref.byteOffset,
+          byteLength = _ref.byteLength;
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
-
         var index = stateObj.buffers.indexOf(buffer);
-
         if (index > -1) {
           return {
             index: index,
@@ -1326,7 +1503,6 @@
             byteLength: byteLength
           };
         }
-
         stateObj.buffers.push(buffer);
         return {
           encoded: encode(buffer),
@@ -1338,20 +1514,17 @@
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
-
         var byteOffset = b64Obj.byteOffset,
-            byteLength = b64Obj.byteLength,
-            encoded = b64Obj.encoded,
-            index = b64Obj.index;
+          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);
       }
     }
@@ -1364,18 +1537,15 @@
       },
       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);
       }
     }
@@ -1388,7 +1558,7 @@
       },
       replace: function replace(_ref) {
         var name = _ref.name,
-            message = _ref.message;
+          message = _ref.message;
         return {
           name: name,
           message: message
@@ -1396,39 +1566,47 @@
       },
       revive: function revive(_ref2) {
         var name = _ref2.name,
-            message = _ref2.message;
+          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;
+  /* globals InternalError */
+  var errors = {};
 
-  var errors = {}; // Comprises all built-in errors.
+  // JS standard
+  [TypeError, RangeError, SyntaxError, ReferenceError, EvalError, URIError].forEach(function (error) {
+    return create$2(error);
+  });
 
-  ['TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'EvalError', 'URIError', 'InternalError' // non-standard
-  ].forEach(function (errName) {
-    var Cnstrctr = _global$2[errName];
+  /* c8 ignore next 2 */
+  // @ts-ignore Non-standard
+  typeof InternalError === 'function' && create$2(InternalError);
 
-    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);
-        }
-      };
-    }
-  });
+  /**
+   * Comprises all built-in errors.
+   * @param {
+   *   TypeError|RangeError|SyntaxError|ReferenceError|EvalError|URIError|
+   *   InternalError
+   * } Ctor
+   * @returns {void}
+   */
+  function create$2(Ctor) {
+    errors[Ctor.name.toLowerCase()] = {
+      test: function test(x) {
+        return hasConstructorOf(x, Ctor);
+      },
+      replace: function replace(e) {
+        return e.message;
+      },
+      revive: function revive(message) {
+        return new Ctor(message);
+      }
+    };
+  }
 
   /* globals XMLHttpRequest, File, FileReader */
   var file = {
@@ -1441,15 +1619,13 @@
         var req = new XMLHttpRequest();
         req.overrideMimeType('text/plain; charset=x-user-defined');
         req.open('GET', URL.createObjectURL(f), false); // Sync
+        req.send();
 
-        req.send(); // Seems not feasible to accurately simulate
-
+        // 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,
@@ -1459,9 +1635,9 @@
       },
       revive: function revive(_ref) {
         var name = _ref.name,
-            type = _ref.type,
-            stringContents = _ref.stringContents,
-            lastModified = _ref.lastModified;
+          type = _ref.type,
+          stringContents = _ref.stringContents,
+          lastModified = _ref.lastModified;
         return new File([string2arraybuffer(stringContents)], name, {
           type: type,
           lastModified: lastModified
@@ -1483,10 +1659,9 @@
               name: f.name,
               lastModified: f.lastModified
             });
-          }); // Seems not feasible to accurately simulate
-
+          });
+          // Seems not feasible to accurately simulate
           /* c8 ignore next 3 */
-
           reader.addEventListener('error', function () {
             reject(reader.error);
           });
@@ -1504,11 +1679,9 @@
       },
       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) {
@@ -1521,7 +1694,6 @@
            */
           function FileList() {
             _classCallCheck$1(this, FileList);
-
             // eslint-disable-next-line prefer-rest-params
             this._files = arguments[0];
             this.length = this._files.length;
@@ -1530,19 +1702,15 @@
            * @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() {
@@ -1550,10 +1718,8 @@
               return 'FileList';
             }
           }]);
-
           return FileList;
         }(Symbol.toStringTag);
-
         return new FileList(o);
       }
     }
@@ -1563,20 +1729,21 @@
   var imagebitmap = {
     imagebitmap: {
       test: function test(x) {
-        return toStringTag(x) === 'ImageBitmap' || // In Node, our polyfill sets the dataset on a canvas
+        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`,
+        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) {
@@ -1591,26 +1758,25 @@
         */
         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
-
+        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
+        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
-
+        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
       }
     }
@@ -1733,12 +1899,14 @@
   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
+        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
+      replace: function replace(rexp) {
+        // Not in use
       }
     }
   };
@@ -1749,23 +1917,18 @@
       test: function test(x) {
         return toStringTag(x) === 'String' && _typeof$1(x) === 'object';
       },
-      replace: function replace(s) {
-        return String(s);
-      },
+      replace: String,
       // 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);
-      },
+      replace: Boolean,
       // convert to primitive boolean
       revive: function revive(b) {
         // Revive to an objectified Boolean
@@ -1777,14 +1940,11 @@
       test: function test(x) {
         return toStringTag(x) === 'Number' && _typeof$1(x) === 'object';
       },
-      replace: function replace(n) {
-        return Number(n);
-      },
+      replace: Number,
       // convert to primitive number
       revive: function revive(n) {
         return new Number(n);
       } // Revive to an objectified number
-
     }
   };
 
@@ -1801,7 +1961,7 @@
       },
       revive: function revive(_ref) {
         var source = _ref.source,
-            flags = _ref.flags;
+          flags = _ref.flags;
         return new RegExp(source, flags);
       }
     }
@@ -1839,27 +1999,26 @@
   };
 
   /* eslint-env browser, node */
-  /* c8 ignore next */
-
-  var _global$1 = typeof self === 'undefined' ? global : self; // Support all kinds of typed arrays (views of ArrayBuffers)
-
 
+  // 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;
-    }
 
+  /**
+   * @param {
+   *   Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|
+   *   Uint32Array|Float32Array|Float64Array
+   * } TypedArray
+   * @returns {void}
+   */
+  function create$1(TypedArray) {
+    var typeName = TypedArray.name;
     typedArraysSocketIO[typeName.toLowerCase()] = {
       test: function test(x) {
-        return toStringTag(x) === arrType;
+        return toStringTag(x) === typeName;
       },
       replace: function replace(a) {
-        return (a.byteOffset === 0 && a.byteLength === a.buffer.byteLength ? a // socket.io supports streaming ArrayBuffers.
+        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.
@@ -1875,38 +2034,40 @@
         return toStringTag(buf) === 'ArrayBuffer' ? new TypedArray(buf) : buf;
       }
     };
-  });
-
-  /* eslint-env browser, node */
-  /* c8 ignore next */
+  }
+  if (typeof Int8Array === 'function') {
+    // Those constructors are added in ES6 as a group.
+    // If we have Int8Array, we can assume the rest also exists.
 
-  var _global = typeof self === 'undefined' ? global : self;
+    [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array].forEach(function (TypedArray) {
+      return create$1(TypedArray);
+    });
+  }
 
+  /* eslint-env browser, node */
   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;
-    }
 
+  /**
+   * @param {
+   *   Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|
+   *   Uint32Array|Float32Array|Float64Array
+   * } TypedArray
+   * @returns {void}
+   */
+  function create(TypedArray) {
+    var typeName = TypedArray.name;
     typedArrays[typeName.toLowerCase()] = {
       test: function test(x) {
-        return toStringTag(x) === arrType;
+        return toStringTag(x) === typeName;
       },
       replace: function replace(_ref, stateObj) {
         var buffer = _ref.buffer,
-            byteOffset = _ref.byteOffset,
-            l = _ref.length;
-
+          byteOffset = _ref.byteOffset,
+          l = _ref.length;
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
-
         var index = stateObj.buffers.indexOf(buffer);
-
         if (index > -1) {
           return {
             index: index,
@@ -1914,7 +2075,6 @@
             length: l
           };
         }
-
         stateObj.buffers.push(buffer);
         return {
           encoded: encode(buffer),
@@ -1926,24 +2086,28 @@
         if (!stateObj.buffers) {
           stateObj.buffers = [];
         }
-
         var byteOffset = b64Obj.byteOffset,
-            len = b64Obj.length,
-            encoded = b64Obj.encoded,
-            index = b64Obj.index;
+          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);
       }
     };
-  });
+  }
+  if (typeof Int8Array === 'function') {
+    // Those constructors are added in ES6 as a group.
+    // If we have Int8Array, we can assume the rest also exists.
+    [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array].forEach(function (TypedArray) {
+      return create(TypedArray);
+    });
+  }
 
   // This does not preserve `undefined` in sparse arrays; see the `undef`
   var undef$1 = {
@@ -1981,7 +2145,8 @@
       testPlainObjects: true,
       test: function test(x, stateObj) {
         if (Array.isArray(x)) {
-          if ( // By avoiding serializing arrays into objects which
+          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
@@ -1998,10 +2163,8 @@
             stateObj.iterateIn = 'object';
             stateObj.addLength = true;
           }
-
           return true;
         }
-
         return false;
       },
       replace: function replace(a, stateObj) {
@@ -2013,12 +2176,11 @@
         if (Array.isArray(o)) {
           return o;
         }
-
-        var arr = []; // No map here as may be a sparse array (including
+        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;
@@ -2037,7 +2199,6 @@
       revive: function revive(s) {
         return undefined;
       } // Will avoid adding anything
-
     }
   }];
 
@@ -2058,22 +2219,17 @@
 
     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 : [],
+  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] : []);
 
   /*
@@ -2093,10 +2249,12 @@
   */
   var postmessage = [error, errors];
 
-  var socketio = [expObj$1, // Leave ArrayBuffer as is, and let socket.io stream it instead.
+  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.
+  },
+  // Encapsulate TypedArrays in ArrayBuffers instead of base64 strings.
   typedArraysSocketIO];
 
   var sparseUndefined = [{
@@ -2121,34 +2279,31 @@
       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
+  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 : [],
+  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({
@@ -2175,34 +2330,43 @@
         // 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
+        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
+        '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]])
+        'Error',
+        // Promise instances have an extra slot ([[PromiseState]])
         //    but not throwing in Chrome `postMessage`
-        'Promise', // WeakMap instances have an extra slot ([[WeakMapData]])
+        'Promise',
+        // WeakMap instances have an extra slot ([[WeakMapData]])
         //    but not throwing in Chrome `postMessage`
-        'WeakMap', // WeakSet instances have an extra slot ([[WeakSetData]])
+        '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)
+        '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?
+        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;
       }
     }
@@ -2210,11 +2374,12 @@
 
   var undef = [sparseUndefined, undef$1];
 
-  var universal = [expObj$1 // TODO: Add types that are de-facto universal even though not
+  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.JSON_TYPES = l;
   exports.Typeson = u;
   exports.TypesonPromise = e;
   exports.Undefined = p;
@@ -2268,7 +2433,5 @@
   exports.universal = universal;
   exports.userObject = userObject;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
 }));
 //# sourceMappingURL=index.umd.js.map