seroval 1.0.3 → 1.0.5

package/dist/cjs/development/index.cjs

@@ -22,6 +22,17 @@ var src_exports = {};
 __export(src_exports, {
   Feature: () => Feature,
   Serializer: () => Serializer,
+  SerovalDeserializationError: () => SerovalDeserializationError,
+  SerovalError: () => SerovalError,
+  SerovalMissingInstanceError: () => SerovalMissingInstanceError,
+  SerovalMissingPluginError: () => SerovalMissingPluginError,
+  SerovalMissingReferenceError: () => SerovalMissingReferenceError,
+  SerovalMissingReferenceForIdError: () => SerovalMissingReferenceForIdError,
+  SerovalParserError: () => SerovalParserError,
+  SerovalSerializationError: () => SerovalSerializationError,
+  SerovalUnknownTypedArrayError: () => SerovalUnknownTypedArrayError,
+  SerovalUnsupportedNodeError: () => SerovalUnsupportedNodeError,
+  SerovalUnsupportedTypeError: () => SerovalUnsupportedTypeError,
   compileJSON: () => compileJSON,
   createPlugin: () => createPlugin,
   createReference: () => createReference,
@@ -55,13 +66,6 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
 })(Feature || {});
 var ALL_ENABLED = 31;
 
-// src/core/utils/assert.ts
-function assert(cond, error) {
-  if (!cond) {
-    throw error;
-  }
-}
-
 // src/core/string.ts
 function serializeChar(str) {
   switch (str) {
@@ -153,6 +157,13 @@ function getCrossReferenceHeader(id) {
   )}"]=[]`;
 }
 
+// src/core/utils/assert.ts
+function assert(cond, error) {
+  if (!cond) {
+    throw error;
+  }
+}
+
 // src/core/reference.ts
 var REFERENCE = /* @__PURE__ */ new Map();
 var INV_REFERENCE = /* @__PURE__ */ new Map();
@@ -168,11 +179,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") {
@@ -229,15 +240,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",
@@ -289,20 +291,20 @@ var CONSTANT_STRING = {
   [3 /* False */]: "!1",
   [1 /* Undefined */]: "void 0",
   [0 /* Null */]: "null",
-  [4 /* NegativeZero */]: "-0",
-  [5 /* Infinity */]: "1/0",
-  [6 /* NegativeInfinity */]: "-1/0",
-  [7 /* NaN */]: "0/0"
+  [4 /* NegZero */]: "-0",
+  [5 /* Inf */]: "1/0",
+  [6 /* NegInf */]: "-1/0",
+  [7 /* Nan */]: "0/0"
 };
 var CONSTANT_VAL = {
   [2 /* True */]: true,
   [3 /* False */]: false,
   [1 /* Undefined */]: void 0,
   [0 /* Null */]: null,
-  [4 /* NegativeZero */]: -0,
-  [5 /* Infinity */]: Infinity,
-  [6 /* NegativeInfinity */]: -Infinity,
-  [7 /* NaN */]: NaN
+  [4 /* NegZero */]: -0,
+  [5 /* Inf */]: Number.POSITIVE_INFINITY,
+  [6 /* NegInf */]: Number.NEGATIVE_INFINITY,
+  [7 /* Nan */]: Number.NaN
 };
 var ERROR_CONSTRUCTOR_STRING = {
   [0 /* Error */]: "Error",
@@ -353,15 +355,15 @@ var NULL_NODE = /* @__PURE__ */ createConstantNode(
   0 /* Null */
 );
 var NEG_ZERO_NODE = /* @__PURE__ */ createConstantNode(
-  4 /* NegativeZero */
+  4 /* NegZero */
 );
 var INFINITY_NODE = /* @__PURE__ */ createConstantNode(
-  5 /* Infinity */
+  5 /* Inf */
 );
 var NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(
-  6 /* NegativeInfinity */
+  6 /* NegInf */
 );
-var NAN_NODE = /* @__PURE__ */ createConstantNode(7 /* NaN */);
+var NAN_NODE = /* @__PURE__ */ createConstantNode(7 /* Nan */);
 
 // src/core/utils/error.ts
 function getErrorConstructor(error) {
@@ -432,9 +434,9 @@ function getObjectFlag(obj) {
 // src/core/base-primitives.ts
 function createNumberNode(value) {
   switch (value) {
-    case Infinity:
+    case Number.POSITIVE_INFINITY:
       return INFINITY_NODE;
-    case -Infinity:
+    case Number.NEGATIVE_INFINITY:
       return NEG_INFINITY_NODE;
   }
   if (value !== value) {
@@ -561,10 +563,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,
@@ -837,6 +835,288 @@ function createStreamReturnNode(id, parsed) {
   };
 }
 
+// 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/special-reference.ts
+var ITERATOR = {};
+var ASYNC_ITERATOR = {};
+var SPECIAL_REFS = {
+  [0 /* MapSentinel */]: {},
+  [1 /* PromiseConstructor */]: {},
+  [2 /* PromiseResolve */]: {},
+  [3 /* PromiseReject */]: {},
+  [4 /* StreamConstructor */]: {}
+};
+
+// src/core/utils/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  return {
+    promise: new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    }),
+    resolve(value) {
+      resolve(value);
+    },
+    reject(value) {
+      reject(value);
+    }
+  };
+}
+
+// src/core/stream.ts
+function isStream(value) {
+  return "__SEROVAL_STREAM__" in value;
+}
+function createStream() {
+  const listeners = /* @__PURE__ */ new Set();
+  const buffer = [];
+  let alive = true;
+  let success = false;
+  function flushNext(value) {
+    for (const listener of listeners.keys()) {
+      listener.next(value);
+    }
+  }
+  function flushThrow(value) {
+    for (const listener of listeners.keys()) {
+      listener.throw(value);
+    }
+  }
+  function flushReturn(value) {
+    for (const listener of listeners.keys()) {
+      listener.return(value);
+    }
+  }
+  return {
+    __SEROVAL_STREAM__: true,
+    on(listener) {
+      if (alive) {
+        listeners.add(listener);
+      }
+      for (let i = 0, len = buffer.length; i < len; i++) {
+        const value = buffer[i];
+        if (i === len - 1) {
+          if (success) {
+            listener.return(value);
+          } else {
+            listener.throw(value);
+          }
+        } else {
+          listener.next(value);
+        }
+      }
+      return () => {
+        if (alive) {
+          listeners.delete(listener);
+        }
+      };
+    },
+    next(value) {
+      if (alive) {
+        buffer.push(value);
+        flushNext(value);
+      }
+    },
+    throw(value) {
+      if (alive) {
+        buffer.push(value);
+        flushThrow(value);
+        alive = false;
+        success = false;
+        listeners.clear();
+      }
+    },
+    return(value) {
+      if (alive) {
+        buffer.push(value);
+        flushReturn(value);
+        alive = false;
+        success = true;
+        listeners.clear();
+      }
+    }
+  };
+}
+function createStreamFromAsyncIterable(iterable) {
+  const stream = createStream();
+  const iterator = iterable[Symbol.asyncIterator]();
+  async function push() {
+    try {
+      const value = await iterator.next();
+      if (value.done) {
+        stream.return(value.value);
+      } else {
+        stream.next(value.value);
+        await push();
+      }
+    } catch (error) {
+      stream.throw(error);
+    }
+  }
+  push().catch(() => {
+  });
+  return stream;
+}
+function streamToAsyncIterable(stream) {
+  return () => {
+    const buffer = [];
+    const pending = [];
+    let count = 0;
+    let doneAt = -1;
+    let isThrow = false;
+    function resolveAll() {
+      for (let i = 0, len = pending.length; i < len; i++) {
+        pending[i].resolve({ done: true, value: void 0 });
+      }
+    }
+    stream.on({
+      next(value) {
+        const current = pending.shift();
+        if (current) {
+          current.resolve({ done: false, value });
+        }
+        buffer.push(value);
+      },
+      throw(value) {
+        const current = pending.shift();
+        if (current) {
+          current.reject(value);
+        }
+        resolveAll();
+        doneAt = buffer.length;
+        buffer.push(value);
+        isThrow = true;
+      },
+      return(value) {
+        const current = pending.shift();
+        if (current) {
+          current.resolve({ done: true, value });
+        }
+        resolveAll();
+        doneAt = buffer.length;
+        buffer.push(value);
+      }
+    });
+    function finalize() {
+      const current = count++;
+      const value = buffer[current];
+      if (current !== doneAt) {
+        return { done: false, value };
+      }
+      if (isThrow) {
+        throw value;
+      }
+      return { done: true, value };
+    }
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        if (doneAt === -1) {
+          const current = count++;
+          if (current >= buffer.length) {
+            const deferred = createDeferred();
+            pending.push(deferred);
+            return await deferred.promise;
+          }
+          return { done: false, value: buffer[current] };
+        }
+        if (count > doneAt) {
+          return { done: true, value: void 0 };
+        }
+        return finalize();
+      }
+    };
+  };
+}
+
 // src/core/utils/iterator-to-sequence.ts
 function iteratorToSequence(source) {
   const values = [];
@@ -890,16 +1170,14 @@ function sequenceToIterator(sequence) {
   };
 }
 
-// src/core/special-reference.ts
-var ITERATOR = {};
-var ASYNC_ITERATOR = {};
-var SPECIAL_REFS = {
-  [0 /* MapSentinel */]: {},
-  [1 /* PromiseConstructor */]: {},
-  [2 /* PromiseResolve */]: {},
-  [3 /* PromiseReject */]: {},
-  [4 /* StreamConstructor */]: {}
-};
+// src/core/utils/promise-to-result.ts
+async function promiseToResult(current) {
+  try {
+    return [1, await current];
+  } catch (e) {
+    return [0, e];
+  }
+}
 
 // src/core/context/parser.ts
 var BaseParserContext = class {
@@ -945,12 +1223,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;
@@ -965,10 +1238,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) {
@@ -1084,201 +1354,6 @@ var BaseParserContext = class {
   }
 };
 
-// src/core/utils/promise-to-result.ts
-async function promiseToResult(current) {
-  try {
-    return [1, await current];
-  } catch (e) {
-    return [0, e];
-  }
-}
-
-// src/core/utils/deferred.ts
-function createDeferred() {
-  let resolve;
-  let reject;
-  return {
-    promise: new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    }),
-    resolve(value) {
-      resolve(value);
-    },
-    reject(value) {
-      reject(value);
-    }
-  };
-}
-
-// src/core/stream.ts
-function isStream(value) {
-  return "__SEROVAL_STREAM__" in value;
-}
-function createStream() {
-  const listeners = /* @__PURE__ */ new Set();
-  const buffer = [];
-  let alive = true;
-  let success = false;
-  function flushNext(value) {
-    for (const listener of listeners.keys()) {
-      listener.next(value);
-    }
-  }
-  function flushThrow(value) {
-    for (const listener of listeners.keys()) {
-      listener.throw(value);
-    }
-  }
-  function flushReturn(value) {
-    for (const listener of listeners.keys()) {
-      listener.return(value);
-    }
-  }
-  return {
-    __SEROVAL_STREAM__: true,
-    on(listener) {
-      if (alive) {
-        listeners.add(listener);
-      }
-      for (let i = 0, len = buffer.length; i < len; i++) {
-        const value = buffer[i];
-        if (i === len - 1) {
-          if (success) {
-            listener.return(value);
-          } else {
-            listener.throw(value);
-          }
-        } else {
-          listener.next(value);
-        }
-      }
-      return () => {
-        if (alive) {
-          listeners.delete(listener);
-        }
-      };
-    },
-    next(value) {
-      if (alive) {
-        buffer.push(value);
-        flushNext(value);
-      }
-    },
-    throw(value) {
-      if (alive) {
-        buffer.push(value);
-        flushThrow(value);
-        alive = false;
-        success = false;
-        listeners.clear();
-      }
-    },
-    return(value) {
-      if (alive) {
-        buffer.push(value);
-        flushReturn(value);
-        alive = false;
-        success = true;
-        listeners.clear();
-      }
-    }
-  };
-}
-function createStreamFromAsyncIterable(iterable) {
-  const stream = createStream();
-  const iterator = iterable[Symbol.asyncIterator]();
-  async function push() {
-    try {
-      const value = await iterator.next();
-      if (value.done) {
-        stream.return(value.value);
-      } else {
-        stream.next(value.value);
-        await push();
-      }
-    } catch (error) {
-      stream.throw(error);
-    }
-  }
-  push().catch(() => {
-  });
-  return stream;
-}
-function streamToAsyncIterable(stream) {
-  return () => {
-    const buffer = [];
-    const pending = [];
-    let count = 0;
-    let doneAt = -1;
-    let isThrow = false;
-    function resolveAll() {
-      for (let i = 0, len = pending.length; i < len; i++) {
-        pending[i].resolve({ done: true, value: void 0 });
-      }
-    }
-    stream.on({
-      next(value) {
-        const current = pending.shift();
-        if (current) {
-          current.resolve({ done: false, value });
-        }
-        buffer.push(value);
-      },
-      throw(value) {
-        const current = pending.shift();
-        if (current) {
-          current.reject(value);
-        }
-        resolveAll();
-        doneAt = buffer.length;
-        buffer.push(value);
-        isThrow = true;
-      },
-      return(value) {
-        const current = pending.shift();
-        if (current) {
-          current.resolve({ done: true, value });
-        }
-        resolveAll();
-        doneAt = buffer.length;
-        buffer.push(value);
-      }
-    });
-    function finalize() {
-      const current = count++;
-      const value = buffer[current];
-      if (current !== doneAt) {
-        return { done: false, value };
-      }
-      if (isThrow) {
-        throw value;
-      }
-      return { done: true, value };
-    }
-    return {
-      [Symbol.asyncIterator]() {
-        return this;
-      },
-      async next() {
-        if (doneAt === -1) {
-          const current = count++;
-          if (current >= buffer.length) {
-            const deferred = createDeferred();
-            pending.push(deferred);
-            return await deferred.promise;
-          }
-          return { done: false, value: buffer[current] };
-        }
-        if (count > doneAt) {
-          return { done: true, value: void 0 };
-        }
-        return finalize();
-      }
-    };
-  };
-}
-
 // src/core/context/parser/async.ts
 var BaseAsyncParserContext = class extends BaseParserContext {
   async parseItems(current) {
@@ -1573,33 +1648,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);
     }
   }
 };
@@ -1638,7 +1717,7 @@ function getTypedArrayConstructor(name) {
     case "BigUint64Array":
       return BigUint64Array;
     default:
-      throw new Error(`Unknown TypedArray "${name}"`);
+      throw new SerovalUnknownTypedArrayError(name);
   }
 }
 
@@ -1807,20 +1886,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;
   }
@@ -1846,19 +1925,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;
   }
@@ -1871,75 +1950,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);
     }
   }
 };
@@ -2213,7 +2296,14 @@ var BaseSerializerContext = class {
       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 && check.toString() === key || isValidIdentifier(key)
+        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);
@@ -2269,7 +2359,14 @@ var BaseSerializerContext = class {
     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 && check.toString() === key || isValidIdentifier(key)
+      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) {
@@ -2524,7 +2621,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);
@@ -2690,78 +2787,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);
     }
   }
 };
@@ -2823,13 +2924,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);
@@ -3080,33 +3181,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);
     }
   }
 };