seroval 1.0.2 → 1.0.4

package/dist/esm/development/index.mjs

@@ -122,11 +122,11 @@ function hasReference(id) {
   return INV_REFERENCE.has(id);
 }
 function getReferenceID(value) {
-  assert(hasReferenceID(value), new Error("Missing reference id"));
+  assert(hasReferenceID(value), new SerovalMissingReferenceError(value));
   return REFERENCE.get(value);
 }
 function getReference(id) {
-  assert(hasReference(id), new Error("Missing reference for id:" + id));
+  assert(hasReference(id), new SerovalMissingReferenceForIdError(id));
   return INV_REFERENCE.get(id);
 }
 if (typeof globalThis !== "undefined") {
@@ -183,15 +183,6 @@ function resolvePlugins(plugins) {
   return void 0;
 }
 
-// src/core/UnsupportedTypeError.ts
-var { toString: objectToString } = Object.prototype;
-var UnsupportedTypeError = class extends Error {
-  constructor(value) {
-    super('Unsupported type "' + objectToString.call(value) + '"');
-    this.value = value;
-  }
-};
-
 // src/core/constants.ts
 var SYMBOL_STRING = {
   [0 /* AsyncIterator */]: "Symbol.asyncIterator",
@@ -515,10 +506,6 @@ function createArrayBufferNode(id, current) {
   };
 }
 function createWKSymbolNode(id, current) {
-  assert(
-    current in INV_SYMBOL_REF,
-    new Error("Only well-known symbols are supported.")
-  );
   return {
     t: 17 /* WKSymbol */,
     i: id,
@@ -855,6 +842,91 @@ var SPECIAL_REFS = {
   [4 /* StreamConstructor */]: {}
 };
 
+// src/core/errors.ts
+var { toString: objectToString } = Object.prototype;
+function getErrorMessage(type, cause) {
+  if (cause instanceof Error) {
+    return `Seroval caught an error during the ${type} process.
+  
+${cause.name}
+${cause.message}
+
+- For more information, please check the "cause" property of this error.
+- If you believe this is an error in Seroval, please submit an issue at https://github.com/lxsmnsyc/seroval/issues/new`;
+  }
+  return `Seroval caught an error during the ${type} process.
+
+"${objectToString.call(cause)}"
+
+For more information, please check the "cause" property of this error.`;
+}
+var SerovalError = class extends Error {
+  constructor(type, cause) {
+    super(getErrorMessage(type, cause));
+    this.cause = cause;
+  }
+};
+var SerovalParserError = class extends SerovalError {
+  constructor(cause) {
+    super("parsing", cause);
+  }
+};
+var SerovalSerializationError = class extends SerovalError {
+  constructor(cause) {
+    super("serialization", cause);
+  }
+};
+var SerovalDeserializationError = class extends SerovalError {
+  constructor(cause) {
+    super("deserialization", cause);
+  }
+};
+var SerovalUnsupportedTypeError = class extends Error {
+  constructor(value) {
+    super(
+      `The value ${objectToString.call(value)} of type "${typeof value}" cannot be parsed/serialized.
+      
+There are few workarounds for this problem:
+- Transform the value in a way that it can be serialized.
+- If the reference is present on multiple runtimes (isomorphic), you can use the Reference API to map the references.`
+    );
+    this.value = value;
+  }
+};
+var SerovalUnsupportedNodeError = class extends Error {
+  constructor(node) {
+    super('Unsupported node type "' + node.t + '".');
+  }
+};
+var SerovalMissingPluginError = class extends Error {
+  constructor(tag) {
+    super('Missing plugin for tag "' + tag + '".');
+  }
+};
+var SerovalMissingInstanceError = class extends Error {
+  constructor(tag) {
+    super('Missing "' + tag + '" instance.');
+  }
+};
+var SerovalMissingReferenceError = class extends Error {
+  constructor(value) {
+    super(
+      'Missing reference for the value "' + objectToString.call(value) + '" of type "' + typeof value + '"'
+    );
+    this.value = value;
+  }
+};
+var SerovalMissingReferenceForIdError = class extends Error {
+  constructor(id) {
+    super('Missing reference for id "' + serializeString(id) + '"');
+  }
+};
+var SerovalUnknownTypedArrayError = class extends Error {
+  constructor(name) {
+    super('Unknown TypedArray "' + name + '"');
+  }
+};
+
 // src/core/context/parser.ts
 var BaseParserContext = class {
   constructor(options) {
@@ -899,12 +971,7 @@ var BaseParserContext = class {
     return indexed;
   }
   getStrictReference(current) {
-    assert(
-      hasReferenceID(current),
-      new Error(
-        "Cannot serialize " + typeof current + " without reference ID."
-      )
-    );
+    assert(hasReferenceID(current), new SerovalUnsupportedTypeError(current));
     const result = this.getIndexedValue(current);
     if (result.type === 1 /* Indexed */) {
       return result.value;
@@ -919,10 +986,7 @@ var BaseParserContext = class {
     if (ref.type !== 0 /* Fresh */) {
       return ref.value;
     }
-    assert(
-      current in INV_SYMBOL_REF,
-      new Error("Cannot serialized unsupported symbol.")
-    );
+    assert(current in INV_SYMBOL_REF, new SerovalUnsupportedTypeError(current));
     return createWKSymbolNode(ref.value, current);
   }
   parseSpecialReference(ref) {
@@ -1527,33 +1591,37 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     if (Symbol.iterator in current || Symbol.asyncIterator in current) {
       return this.parsePlainObject(id, current, !!currentClass);
     }
-    throw new UnsupportedTypeError(current);
+    throw new SerovalUnsupportedTypeError(current);
   }
   async parse(current) {
-    switch (typeof current) {
-      case "boolean":
-        return current ? TRUE_NODE : FALSE_NODE;
-      case "undefined":
-        return UNDEFINED_NODE;
-      case "string":
-        return createStringNode(current);
-      case "number":
-        return createNumberNode(current);
-      case "bigint":
-        return createBigIntNode(current);
-      case "object": {
-        if (current) {
-          const ref = this.getReference(current);
-          return ref.type === 0 ? await this.parseObject(ref.value, current) : ref.value;
+    try {
+      switch (typeof current) {
+        case "boolean":
+          return current ? TRUE_NODE : FALSE_NODE;
+        case "undefined":
+          return UNDEFINED_NODE;
+        case "string":
+          return createStringNode(current);
+        case "number":
+          return createNumberNode(current);
+        case "bigint":
+          return createBigIntNode(current);
+        case "object": {
+          if (current) {
+            const ref = this.getReference(current);
+            return ref.type === 0 ? await this.parseObject(ref.value, current) : ref.value;
+          }
+          return NULL_NODE;
         }
-        return NULL_NODE;
+        case "symbol":
+          return this.parseWellKnownSymbol(current);
+        case "function":
+          return this.parseFunction(current);
+        default:
+          throw new SerovalUnsupportedTypeError(current);
       }
-      case "symbol":
-        return this.parseWellKnownSymbol(current);
-      case "function":
-        return this.parseFunction(current);
-      default:
-        throw new UnsupportedTypeError(current);
+    } catch (error) {
+      throw new SerovalParserError(error);
     }
   }
 };
@@ -1592,7 +1660,7 @@ function getTypedArrayConstructor(name) {
     case "BigUint64Array":
       return BigUint64Array;
     default:
-      throw new Error(`Unknown TypedArray "${name}"`);
+      throw new SerovalUnknownTypedArrayError(name);
   }
 }
 
@@ -1761,20 +1829,20 @@ var BaseDeserializerContext = class {
         }
       }
     }
-    throw new Error('Missing plugin for tag "' + node.c + '".');
+    throw new SerovalMissingPluginError(node.c);
   }
   deserializePromiseConstructor(node) {
     return this.assignIndexedValue(node.i, createDeferred()).promise;
   }
   deserializePromiseResolve(node) {
     const deferred = this.refs.get(node.i);
-    assert(deferred, new Error("Missing Promise instance."));
+    assert(deferred, new SerovalMissingInstanceError("Promise"));
     deferred.resolve(this.deserialize(node.a[1]));
     return void 0;
   }
   deserializePromiseReject(node) {
     const deferred = this.refs.get(node.i);
-    assert(deferred, new Error("Missing Promise instance."));
+    assert(deferred, new SerovalMissingInstanceError("Promise"));
     deferred.reject(this.deserialize(node.a[1]));
     return void 0;
   }
@@ -1800,19 +1868,19 @@ var BaseDeserializerContext = class {
   }
   deserializeStreamNext(node) {
     const deferred = this.refs.get(node.i);
-    assert(deferred, new Error("Missing Stream instance."));
+    assert(deferred, new SerovalMissingInstanceError("Stream"));
     deferred.next(this.deserialize(node.f));
     return void 0;
   }
   deserializeStreamThrow(node) {
     const deferred = this.refs.get(node.i);
-    assert(deferred, new Error("Missing Stream instance."));
+    assert(deferred, new SerovalMissingInstanceError("Stream"));
     deferred.throw(this.deserialize(node.f));
     return void 0;
   }
   deserializeStreamReturn(node) {
     const deferred = this.refs.get(node.i);
-    assert(deferred, new Error("Missing Stream instance."));
+    assert(deferred, new SerovalMissingInstanceError("Stream"));
     deferred.return(this.deserialize(node.f));
     return void 0;
   }
@@ -1825,75 +1893,79 @@ var BaseDeserializerContext = class {
     return void 0;
   }
   deserialize(node) {
-    switch (node.t) {
-      case 2 /* Constant */:
-        return CONSTANT_VAL[node.s];
-      case 0 /* Number */:
-        return node.s;
-      case 1 /* String */:
-        return deserializeString(node.s);
-      case 3 /* BigInt */:
-        return BigInt(node.s);
-      case 4 /* IndexedValue */:
-        return this.refs.get(node.i);
-      case 18 /* Reference */:
-        return this.deserializeReference(node);
-      case 9 /* Array */:
-        return this.deserializeArray(node);
-      case 10 /* Object */:
-      case 11 /* NullConstructor */:
-        return this.deserializeObject(node);
-      case 5 /* Date */:
-        return this.deserializeDate(node);
-      case 6 /* RegExp */:
-        return this.deserializeRegExp(node);
-      case 7 /* Set */:
-        return this.deserializeSet(node);
-      case 8 /* Map */:
-        return this.deserializeMap(node);
-      case 19 /* ArrayBuffer */:
-        return this.deserializeArrayBuffer(node);
-      case 16 /* BigIntTypedArray */:
-      case 15 /* TypedArray */:
-        return this.deserializeTypedArray(node);
-      case 20 /* DataView */:
-        return this.deserializeDataView(node);
-      case 14 /* AggregateError */:
-        return this.deserializeAggregateError(node);
-      case 13 /* Error */:
-        return this.deserializeError(node);
-      case 12 /* Promise */:
-        return this.deserializePromise(node);
-      case 17 /* WKSymbol */:
-        return SYMBOL_REF[node.s];
-      case 21 /* Boxed */:
-        return this.deserializeBoxed(node);
-      case 25 /* Plugin */:
-        return this.deserializePlugin(node);
-      case 22 /* PromiseConstructor */:
-        return this.deserializePromiseConstructor(node);
-      case 23 /* PromiseResolve */:
-        return this.deserializePromiseResolve(node);
-      case 24 /* PromiseReject */:
-        return this.deserializePromiseReject(node);
-      case 28 /* IteratorFactoryInstance */:
-        return this.deserializeIteratorFactoryInstance(node);
-      case 30 /* AsyncIteratorFactoryInstance */:
-        return this.deserializeAsyncIteratorFactoryInstance(node);
-      case 31 /* StreamConstructor */:
-        return this.deserializeStreamConstructor(node);
-      case 32 /* StreamNext */:
-        return this.deserializeStreamNext(node);
-      case 33 /* StreamThrow */:
-        return this.deserializeStreamThrow(node);
-      case 34 /* StreamReturn */:
-        return this.deserializeStreamReturn(node);
-      case 27 /* IteratorFactory */:
-        return this.deserializeIteratorFactory(node);
-      case 29 /* AsyncIteratorFactory */:
-        return this.deserializeAsyncIteratorFactory(node);
-      default:
-        throw new Error("invariant");
+    try {
+      switch (node.t) {
+        case 2 /* Constant */:
+          return CONSTANT_VAL[node.s];
+        case 0 /* Number */:
+          return node.s;
+        case 1 /* String */:
+          return deserializeString(node.s);
+        case 3 /* BigInt */:
+          return BigInt(node.s);
+        case 4 /* IndexedValue */:
+          return this.refs.get(node.i);
+        case 18 /* Reference */:
+          return this.deserializeReference(node);
+        case 9 /* Array */:
+          return this.deserializeArray(node);
+        case 10 /* Object */:
+        case 11 /* NullConstructor */:
+          return this.deserializeObject(node);
+        case 5 /* Date */:
+          return this.deserializeDate(node);
+        case 6 /* RegExp */:
+          return this.deserializeRegExp(node);
+        case 7 /* Set */:
+          return this.deserializeSet(node);
+        case 8 /* Map */:
+          return this.deserializeMap(node);
+        case 19 /* ArrayBuffer */:
+          return this.deserializeArrayBuffer(node);
+        case 16 /* BigIntTypedArray */:
+        case 15 /* TypedArray */:
+          return this.deserializeTypedArray(node);
+        case 20 /* DataView */:
+          return this.deserializeDataView(node);
+        case 14 /* AggregateError */:
+          return this.deserializeAggregateError(node);
+        case 13 /* Error */:
+          return this.deserializeError(node);
+        case 12 /* Promise */:
+          return this.deserializePromise(node);
+        case 17 /* WKSymbol */:
+          return SYMBOL_REF[node.s];
+        case 21 /* Boxed */:
+          return this.deserializeBoxed(node);
+        case 25 /* Plugin */:
+          return this.deserializePlugin(node);
+        case 22 /* PromiseConstructor */:
+          return this.deserializePromiseConstructor(node);
+        case 23 /* PromiseResolve */:
+          return this.deserializePromiseResolve(node);
+        case 24 /* PromiseReject */:
+          return this.deserializePromiseReject(node);
+        case 28 /* IteratorFactoryInstance */:
+          return this.deserializeIteratorFactoryInstance(node);
+        case 30 /* AsyncIteratorFactoryInstance */:
+          return this.deserializeAsyncIteratorFactoryInstance(node);
+        case 31 /* StreamConstructor */:
+          return this.deserializeStreamConstructor(node);
+        case 32 /* StreamNext */:
+          return this.deserializeStreamNext(node);
+        case 33 /* StreamThrow */:
+          return this.deserializeStreamThrow(node);
+        case 34 /* StreamReturn */:
+          return this.deserializeStreamReturn(node);
+        case 27 /* IteratorFactory */:
+          return this.deserializeIteratorFactory(node);
+        case 29 /* AsyncIteratorFactory */:
+          return this.deserializeAsyncIteratorFactory(node);
+        default:
+          throw new SerovalUnsupportedNodeError(node);
+      }
+    } catch (error) {
+      throw new SerovalDeserializationError(error);
     }
   }
 };
@@ -2164,7 +2236,18 @@ var BaseSerializerContext = class {
   serializeProperty(source, key, val) {
     if (typeof key === "string") {
       const check = Number(key);
-      const isIdentifier = check >= 0 || isValidIdentifier(key);
+      const isIdentifier = (
+        // Test if key is a valid positive number or JS identifier
+        // so that we don't have to serialize the key and wrap with brackets
+        check >= 0 && // It's also important to consider that if the key is
+        // indeed numeric, we need to make sure that when
+        // converted back into a string, it's still the same
+        // to the original key. This allows us to differentiate
+        // keys that has numeric formats but in a different
+        // format, which can cause unintentional key declaration
+        // Example: { 0x1: 1 } vs { '0x1': 1 }
+        check.toString() === key || isValidIdentifier(key)
+      );
       if (this.isIndexedValueInStack(val)) {
         const refParam = this.getRefParam(val.i);
         this.markRef(source.i);
@@ -2216,7 +2299,18 @@ var BaseSerializerContext = class {
   serializeStringKeyAssignment(source, mainAssignments, key, value) {
     const serialized = this.serialize(value);
     const check = Number(key);
-    const isIdentifier = check >= 0 || isValidIdentifier(key);
+    const isIdentifier = (
+      // Test if key is a valid positive number or JS identifier
+      // so that we don't have to serialize the key and wrap with brackets
+      check >= 0 && // It's also important to consider that if the key is
+      // indeed numeric, we need to make sure that when
+      // converted back into a string, it's still the same
+      // to the original key. This allows us to differentiate
+      // keys that has numeric formats but in a different
+      // format, which can cause unintentional key declaration
+      // Example: { 0x1: 1 } vs { '0x1': 1 }
+      check.toString() === key || isValidIdentifier(key)
+    );
     if (this.isIndexedValueInStack(value)) {
       if (isIdentifier && check !== check) {
         this.createObjectAssign(source.i, key, serialized);
@@ -2230,7 +2324,7 @@ var BaseSerializerContext = class {
     } else {
       const parentAssignment = this.assignments;
       this.assignments = mainAssignments;
-      if (isIdentifier) {
+      if (isIdentifier && check !== check) {
         this.createObjectAssign(source.i, key, serialized);
       } else {
         this.createArrayAssign(
@@ -2470,7 +2564,7 @@ var BaseSerializerContext = class {
         }
       }
     }
-    throw new Error('Missing plugin for tag "' + node.c + '".');
+    throw new SerovalMissingPluginError(node.c);
   }
   getConstructor(node) {
     const current = this.serialize(node);
@@ -2636,78 +2730,82 @@ var BaseSerializerContext = class {
     return this.getRefParam(node.i) + ".return(" + this.serialize(node.f) + ")";
   }
   serialize(node) {
-    switch (node.t) {
-      case 2 /* Constant */:
-        return CONSTANT_STRING[node.s];
-      case 0 /* Number */:
-        return "" + node.s;
-      case 1 /* String */:
-        return '"' + node.s + '"';
-      case 3 /* BigInt */:
-        return node.s + "n";
-      case 4 /* IndexedValue */:
-        return this.getRefParam(node.i);
-      case 18 /* Reference */:
-        return this.serializeReference(node);
-      case 9 /* Array */:
-        return this.serializeArray(node);
-      case 10 /* Object */:
-        return this.serializeObject(node);
-      case 11 /* NullConstructor */:
-        return this.serializeNullConstructor(node);
-      case 5 /* Date */:
-        return this.serializeDate(node);
-      case 6 /* RegExp */:
-        return this.serializeRegExp(node);
-      case 7 /* Set */:
-        return this.serializeSet(node);
-      case 8 /* Map */:
-        return this.serializeMap(node);
-      case 19 /* ArrayBuffer */:
-        return this.serializeArrayBuffer(node);
-      case 16 /* BigIntTypedArray */:
-      case 15 /* TypedArray */:
-        return this.serializeTypedArray(node);
-      case 20 /* DataView */:
-        return this.serializeDataView(node);
-      case 14 /* AggregateError */:
-        return this.serializeAggregateError(node);
-      case 13 /* Error */:
-        return this.serializeError(node);
-      case 12 /* Promise */:
-        return this.serializePromise(node);
-      case 17 /* WKSymbol */:
-        return this.serializeWellKnownSymbol(node);
-      case 21 /* Boxed */:
-        return this.serializeBoxed(node);
-      case 22 /* PromiseConstructor */:
-        return this.serializePromiseConstructor(node);
-      case 23 /* PromiseResolve */:
-        return this.serializePromiseResolve(node);
-      case 24 /* PromiseReject */:
-        return this.serializePromiseReject(node);
-      case 25 /* Plugin */:
-        return this.serializePlugin(node);
-      case 26 /* SpecialReference */:
-        return this.serializeSpecialReference(node);
-      case 27 /* IteratorFactory */:
-        return this.serializeIteratorFactory(node);
-      case 28 /* IteratorFactoryInstance */:
-        return this.serializeIteratorFactoryInstance(node);
-      case 29 /* AsyncIteratorFactory */:
-        return this.serializeAsyncIteratorFactory(node);
-      case 30 /* AsyncIteratorFactoryInstance */:
-        return this.serializeAsyncIteratorFactoryInstance(node);
-      case 31 /* StreamConstructor */:
-        return this.serializeStreamConstructor(node);
-      case 32 /* StreamNext */:
-        return this.serializeStreamNext(node);
-      case 33 /* StreamThrow */:
-        return this.serializeStreamThrow(node);
-      case 34 /* StreamReturn */:
-        return this.serializeStreamReturn(node);
-      default:
-        throw new Error("invariant");
+    try {
+      switch (node.t) {
+        case 2 /* Constant */:
+          return CONSTANT_STRING[node.s];
+        case 0 /* Number */:
+          return "" + node.s;
+        case 1 /* String */:
+          return '"' + node.s + '"';
+        case 3 /* BigInt */:
+          return node.s + "n";
+        case 4 /* IndexedValue */:
+          return this.getRefParam(node.i);
+        case 18 /* Reference */:
+          return this.serializeReference(node);
+        case 9 /* Array */:
+          return this.serializeArray(node);
+        case 10 /* Object */:
+          return this.serializeObject(node);
+        case 11 /* NullConstructor */:
+          return this.serializeNullConstructor(node);
+        case 5 /* Date */:
+          return this.serializeDate(node);
+        case 6 /* RegExp */:
+          return this.serializeRegExp(node);
+        case 7 /* Set */:
+          return this.serializeSet(node);
+        case 8 /* Map */:
+          return this.serializeMap(node);
+        case 19 /* ArrayBuffer */:
+          return this.serializeArrayBuffer(node);
+        case 16 /* BigIntTypedArray */:
+        case 15 /* TypedArray */:
+          return this.serializeTypedArray(node);
+        case 20 /* DataView */:
+          return this.serializeDataView(node);
+        case 14 /* AggregateError */:
+          return this.serializeAggregateError(node);
+        case 13 /* Error */:
+          return this.serializeError(node);
+        case 12 /* Promise */:
+          return this.serializePromise(node);
+        case 17 /* WKSymbol */:
+          return this.serializeWellKnownSymbol(node);
+        case 21 /* Boxed */:
+          return this.serializeBoxed(node);
+        case 22 /* PromiseConstructor */:
+          return this.serializePromiseConstructor(node);
+        case 23 /* PromiseResolve */:
+          return this.serializePromiseResolve(node);
+        case 24 /* PromiseReject */:
+          return this.serializePromiseReject(node);
+        case 25 /* Plugin */:
+          return this.serializePlugin(node);
+        case 26 /* SpecialReference */:
+          return this.serializeSpecialReference(node);
+        case 27 /* IteratorFactory */:
+          return this.serializeIteratorFactory(node);
+        case 28 /* IteratorFactoryInstance */:
+          return this.serializeIteratorFactoryInstance(node);
+        case 29 /* AsyncIteratorFactory */:
+          return this.serializeAsyncIteratorFactory(node);
+        case 30 /* AsyncIteratorFactoryInstance */:
+          return this.serializeAsyncIteratorFactoryInstance(node);
+        case 31 /* StreamConstructor */:
+          return this.serializeStreamConstructor(node);
+        case 32 /* StreamNext */:
+          return this.serializeStreamNext(node);
+        case 33 /* StreamThrow */:
+          return this.serializeStreamThrow(node);
+        case 34 /* StreamReturn */:
+          return this.serializeStreamReturn(node);
+        default:
+          throw new SerovalUnsupportedNodeError(node);
+      }
+    } catch (error) {
+      throw new SerovalSerializationError(error);
     }
   }
 };
@@ -2769,13 +2867,13 @@ var VanillaSerializerContext = class extends BaseSerializerContext {
     return value;
   }
   serializePromiseConstructor(node) {
-    throw new Error('Unsupported node type "' + node.t + '".');
+    throw new SerovalUnsupportedNodeError(node);
   }
   serializePromiseResolve(node) {
-    throw new Error('Unsupported node type "' + node.t + '".');
+    throw new SerovalUnsupportedNodeError(node);
   }
   serializePromiseReject(node) {
-    throw new Error('Unsupported node type "' + node.t + '".');
+    throw new SerovalUnsupportedNodeError(node);
   }
   serializeTop(tree) {
     const result = this.serialize(tree);
@@ -3026,33 +3124,37 @@ var BaseSyncParserContext = class extends BaseParserContext {
     if (Symbol.iterator in current || Symbol.asyncIterator in current) {
       return this.parsePlainObject(id, current, !!currentClass);
     }
-    throw new UnsupportedTypeError(current);
+    throw new SerovalUnsupportedTypeError(current);
   }
   parse(current) {
-    switch (typeof current) {
-      case "boolean":
-        return current ? TRUE_NODE : FALSE_NODE;
-      case "undefined":
-        return UNDEFINED_NODE;
-      case "string":
-        return createStringNode(current);
-      case "number":
-        return createNumberNode(current);
-      case "bigint":
-        return createBigIntNode(current);
-      case "object": {
-        if (current) {
-          const ref = this.getReference(current);
-          return ref.type === 0 ? this.parseObject(ref.value, current) : ref.value;
+    try {
+      switch (typeof current) {
+        case "boolean":
+          return current ? TRUE_NODE : FALSE_NODE;
+        case "undefined":
+          return UNDEFINED_NODE;
+        case "string":
+          return createStringNode(current);
+        case "number":
+          return createNumberNode(current);
+        case "bigint":
+          return createBigIntNode(current);
+        case "object": {
+          if (current) {
+            const ref = this.getReference(current);
+            return ref.type === 0 ? this.parseObject(ref.value, current) : ref.value;
+          }
+          return NULL_NODE;
         }
-        return NULL_NODE;
+        case "symbol":
+          return this.parseWellKnownSymbol(current);
+        case "function":
+          return this.parseFunction(current);
+        default:
+          throw new SerovalUnsupportedTypeError(current);
       }
-      case "symbol":
-        return this.parseWellKnownSymbol(current);
-      case "function":
-        return this.parseFunction(current);
-      default:
-        throw new UnsupportedTypeError(current);
+    } catch (error) {
+      throw new SerovalParserError(error);
     }
   }
 };
@@ -3644,6 +3746,17 @@ var Serializer = class {
 export {
   Feature,
   Serializer,
+  SerovalDeserializationError,
+  SerovalError,
+  SerovalMissingInstanceError,
+  SerovalMissingPluginError,
+  SerovalMissingReferenceError,
+  SerovalMissingReferenceForIdError,
+  SerovalParserError,
+  SerovalSerializationError,
+  SerovalUnknownTypedArrayError,
+  SerovalUnsupportedNodeError,
+  SerovalUnsupportedTypeError,
   compileJSON,
   createPlugin,
   createReference,