seroval 1.0.3 → 1.0.5

package/src/core/context/parser/async.ts

@@ -1,66 +1,66 @@
-import UnsupportedTypeError from '../../UnsupportedTypeError';
 import {
-  createPluginNode,
-  createDateNode,
-  createRegExpNode,
+  createAggregateErrorNode,
   createArrayBufferNode,
-  createBigIntNode,
-  createStringNode,
-  createNumberNode,
   createArrayNode,
-  createBoxedNode,
-  createTypedArrayNode,
+  createAsyncIteratorFactoryInstanceNode,
+  createBigIntNode,
   createBigIntTypedArrayNode,
+  createBoxedNode,
   createDataViewNode,
+  createDateNode,
   createErrorNode,
-  createSetNode,
-  createAggregateErrorNode,
   createIteratorFactoryInstanceNode,
-  createAsyncIteratorFactoryInstanceNode,
+  createNumberNode,
+  createPluginNode,
+  createRegExpNode,
+  createSetNode,
   createStreamConstructorNode,
   createStreamNextNode,
-  createStreamThrowNode,
   createStreamReturnNode,
+  createStreamThrowNode,
+  createStringNode,
+  createTypedArrayNode,
 } from '../../base-primitives';
 import { Feature } from '../../compat';
 import { SerovalNodeType } from '../../constants';
+import { SerovalParserError, SerovalUnsupportedTypeError } from '../../errors';
 import {
+  FALSE_NODE,
   NULL_NODE,
   TRUE_NODE,
-  FALSE_NODE,
   UNDEFINED_NODE,
 } from '../../literals';
-import { iteratorToSequence } from '../../utils/iterator-to-sequence';
-import { BaseParserContext } from '../parser';
-import promiseToResult from '../../utils/promise-to-result';
-import { getErrorOptions } from '../../utils/error';
+import { SpecialReference } from '../../special-reference';
+import type { Stream } from '../../stream';
+import { createStreamFromAsyncIterable, isStream } from '../../stream';
 import { serializeString } from '../../string';
 import type {
-  SerovalErrorNode,
+  SerovalAggregateErrorNode,
   SerovalArrayNode,
   SerovalBigIntTypedArrayNode,
   SerovalBoxedNode,
+  SerovalDataViewNode,
+  SerovalErrorNode,
+  SerovalMapNode,
   SerovalNode,
   SerovalNullConstructorNode,
   SerovalObjectNode,
   SerovalObjectRecordKey,
   SerovalObjectRecordNode,
-  SerovalPromiseNode,
-  SerovalTypedArrayNode,
-  SerovalAggregateErrorNode,
-  SerovalMapNode,
   SerovalPluginNode,
+  SerovalPromiseNode,
   SerovalSetNode,
-  SerovalDataViewNode,
   SerovalStreamConstructorNode,
+  SerovalTypedArrayNode,
 } from '../../types';
-import { SpecialReference } from '../../special-reference';
-import type { Stream } from '../../stream';
-import { createStreamFromAsyncIterable, isStream } from '../../stream';
+import { getErrorOptions } from '../../utils/error';
+import { iteratorToSequence } from '../../utils/iterator-to-sequence';
+import promiseToResult from '../../utils/promise-to-result';
 import type {
   BigIntTypedArrayValue,
   TypedArrayValue,
 } from '../../utils/typed-array';
+import { BaseParserContext } from '../parser';
 
 type ObjectLikeNode =
   | SerovalObjectNode
@@ -429,36 +429,40 @@ export default abstract class BaseAsyncParserContext 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<T>(current: T): Promise<SerovalNode> {
-    switch (typeof current) {
-      case 'boolean':
-        return current ? TRUE_NODE : FALSE_NODE;
-      case 'undefined':
-        return UNDEFINED_NODE;
-      case 'string':
-        return createStringNode(current as string);
-      case 'number':
-        return createNumberNode(current as number);
-      case 'bigint':
-        return createBigIntNode(current as bigint);
-      case 'object': {
-        if (current) {
-          const ref = this.getReference(current);
-          return ref.type === 0
-            ? await this.parseObject(ref.value, current as object)
-            : ref.value;
+    try {
+      switch (typeof current) {
+        case 'boolean':
+          return current ? TRUE_NODE : FALSE_NODE;
+        case 'undefined':
+          return UNDEFINED_NODE;
+        case 'string':
+          return createStringNode(current as string);
+        case 'number':
+          return createNumberNode(current as number);
+        case 'bigint':
+          return createBigIntNode(current as bigint);
+        case 'object': {
+          if (current) {
+            const ref = this.getReference(current);
+            return ref.type === 0
+              ? await this.parseObject(ref.value, current as object)
+              : ref.value;
+          }
+          return NULL_NODE;
         }
-        return NULL_NODE;
+        case 'symbol':
+          return this.parseWellKnownSymbol(current);
+        case 'function':
+          return this.parseFunction(current as (...args: unknown[]) => unknown);
+        default:
+          throw new SerovalUnsupportedTypeError(current);
       }
-      case 'symbol':
-        return this.parseWellKnownSymbol(current);
-      case 'function':
-        return this.parseFunction(current as (...args: unknown[]) => unknown);
-      default:
-        throw new UnsupportedTypeError(current);
+    } catch (error) {
+      throw new SerovalParserError(error);
     }
   }
 }

package/src/core/context/parser/stream.ts

@@ -8,10 +8,11 @@ import {
   createStreamThrowNode,
   createStringNode,
 } from '../../base-primitives';
-import type { BaseSyncParserContextOptions } from './sync';
-import BaseSyncParserContext from './sync';
 import { SerovalNodeType } from '../../constants';
 import { FALSE_NODE, TRUE_NODE } from '../../literals';
+import { SpecialReference } from '../../special-reference';
+import type { Stream } from '../../stream';
+import { createStreamFromAsyncIterable } from '../../stream';
 import { serializeString } from '../../string';
 import type {
   SerovalNode,
@@ -21,9 +22,8 @@ import type {
   SerovalPromiseConstructorNode,
 } from '../../types';
 import { iteratorToSequence } from '../../utils/iterator-to-sequence';
-import { SpecialReference } from '../../special-reference';
-import type { Stream } from '../../stream';
-import { createStreamFromAsyncIterable } from '../../stream';
+import type { BaseSyncParserContextOptions } from './sync';
+import BaseSyncParserContext from './sync';
 
 export interface BaseStreamParserContextOptions
   extends BaseSyncParserContextOptions {

package/src/core/context/parser/sync.ts

@@ -1,4 +1,3 @@
-import UnsupportedTypeError from '../../UnsupportedTypeError';
 import {
   createAggregateErrorNode,
   createArrayBufferNode,
@@ -20,42 +19,43 @@ import {
   createTypedArrayNode,
 } from '../../base-primitives';
 import { Feature } from '../../compat';
+import { SerovalParserError, SerovalUnsupportedTypeError } from '../../errors';
 import {
   FALSE_NODE,
   NULL_NODE,
   TRUE_NODE,
   UNDEFINED_NODE,
 } from '../../literals';
-import { iteratorToSequence } from '../../utils/iterator-to-sequence';
-import type { BaseParserContextOptions } from '../parser';
-import { BaseParserContext } from '../parser';
-import { getErrorOptions } from '../../utils/error';
+import { SpecialReference } from '../../special-reference';
+import type { Stream } from '../../stream';
+import { createStream, isStream } from '../../stream';
 import { serializeString } from '../../string';
 import type {
-  SerovalBoxedNode,
+  SerovalAggregateErrorNode,
   SerovalArrayNode,
+  SerovalBigIntTypedArrayNode,
+  SerovalBoxedNode,
+  SerovalDataViewNode,
+  SerovalErrorNode,
+  SerovalMapNode,
   SerovalNode,
   SerovalNullConstructorNode,
   SerovalObjectNode,
   SerovalObjectRecordKey,
   SerovalObjectRecordNode,
-  SerovalErrorNode,
-  SerovalMapNode,
-  SerovalSetNode,
   SerovalPluginNode,
-  SerovalAggregateErrorNode,
-  SerovalTypedArrayNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalDataViewNode,
   SerovalPromiseConstructorNode,
+  SerovalSetNode,
+  SerovalTypedArrayNode,
 } from '../../types';
-import { SpecialReference } from '../../special-reference';
-import type { Stream } from '../../stream';
-import { createStream, isStream } from '../../stream';
+import { getErrorOptions } from '../../utils/error';
+import { iteratorToSequence } from '../../utils/iterator-to-sequence';
 import type {
   BigIntTypedArrayValue,
   TypedArrayValue,
 } from '../../utils/typed-array';
+import type { BaseParserContextOptions } from '../parser';
+import { BaseParserContext } from '../parser';
 
 type ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode;
 
@@ -338,36 +338,40 @@ export default abstract class BaseSyncParserContext 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<T>(current: T): SerovalNode {
-    switch (typeof current) {
-      case 'boolean':
-        return current ? TRUE_NODE : FALSE_NODE;
-      case 'undefined':
-        return UNDEFINED_NODE;
-      case 'string':
-        return createStringNode(current as string);
-      case 'number':
-        return createNumberNode(current as number);
-      case 'bigint':
-        return createBigIntNode(current as bigint);
-      case 'object': {
-        if (current) {
-          const ref = this.getReference(current);
-          return ref.type === 0
-            ? this.parseObject(ref.value, current as object)
-            : ref.value;
+    try {
+      switch (typeof current) {
+        case 'boolean':
+          return current ? TRUE_NODE : FALSE_NODE;
+        case 'undefined':
+          return UNDEFINED_NODE;
+        case 'string':
+          return createStringNode(current as string);
+        case 'number':
+          return createNumberNode(current as number);
+        case 'bigint':
+          return createBigIntNode(current as bigint);
+        case 'object': {
+          if (current) {
+            const ref = this.getReference(current);
+            return ref.type === 0
+              ? this.parseObject(ref.value, current as object)
+              : ref.value;
+          }
+          return NULL_NODE;
         }
-        return NULL_NODE;
+        case 'symbol':
+          return this.parseWellKnownSymbol(current);
+        case 'function':
+          return this.parseFunction(current as (...args: unknown[]) => unknown);
+        default:
+          throw new SerovalUnsupportedTypeError(current);
       }
-      case 'symbol':
-        return this.parseWellKnownSymbol(current);
-      case 'function':
-        return this.parseFunction(current as (...args: unknown[]) => unknown);
-      default:
-        throw new UnsupportedTypeError(current);
+    } catch (error) {
+      throw new SerovalParserError(error);
     }
   }
 }

package/src/core/context/parser.ts

@@ -1,4 +1,3 @@
-import assert from '../utils/assert';
 import {
   createIndexedValueNode,
   createReferenceNode,
@@ -7,13 +6,14 @@ import {
 import { ALL_ENABLED } from '../compat';
 import type { WellKnownSymbols } from '../constants';
 import { INV_SYMBOL_REF, SerovalNodeType } from '../constants';
+import { SerovalUnsupportedTypeError } from '../errors';
 import type { Plugin, PluginAccessOptions, SerovalMode } from '../plugin';
 import { hasReferenceID } from '../reference';
 import {
-  SpecialReference,
   ASYNC_ITERATOR,
   ITERATOR,
   SPECIAL_REFS,
+  SpecialReference,
 } from '../special-reference';
 import type {
   SerovalAsyncIteratorFactoryNode,
@@ -29,6 +29,7 @@ import type {
   SerovalSpecialReferenceNode,
   SerovalWKSymbolNode,
 } from '../types';
+import assert from '../utils/assert';
 import { getObjectFlag } from '../utils/get-object-flag';
 
 export interface BaseParserContextOptions extends PluginAccessOptions {
@@ -118,12 +119,7 @@ export abstract class BaseParserContext implements PluginAccessOptions {
   protected getStrictReference<T>(
     current: T,
   ): SerovalIndexedValueNode | SerovalReferenceNode {
-    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 === NodeType.Indexed) {
       return result.value;
@@ -144,10 +140,7 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     if (ref.type !== NodeType.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 as WellKnownSymbols);
   }