seroval 1.3.2 → 1.4.0

package/dist/types/core/cross/stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../src/core/cross/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,uBAAuB,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,MAAM,MAAM,+BAA+B,GAAG,8BAA8B,CAAC;AAE7E,MAAM,CAAC,OAAO,OAAO,wBAAyB,SAAQ,uBAAuB;IAC3E,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAW;CACtC"}

package/dist/types/core/cross/sync.d.ts

@@ -1,8 +0,0 @@
-import BaseSyncParserContext from '../context/parser/sync';
-import type { SerovalMode } from '../plugin';
-import type { CrossParserContextOptions } from './parser';
-export type CrossSyncParserContextOptions = CrossParserContextOptions;
-export default class CrossSyncParserContext extends BaseSyncParserContext {
-    readonly mode: SerovalMode;
-}
-//# sourceMappingURL=sync.d.ts.map

package/dist/types/core/cross/sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/core/cross/sync.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAE1D,MAAM,MAAM,6BAA6B,GAAG,yBAAyB,CAAC;AAEtE,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,qBAAqB;IACvE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAW;CACtC"}

package/dist/types/core/tree/async.d.ts

@@ -1,8 +0,0 @@
-import type { BaseParserContextOptions } from '../context/parser';
-import BaseAsyncParserContext from '../context/parser/async';
-import type { SerovalMode } from '../plugin';
-export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
-export default class AsyncParserContext extends BaseAsyncParserContext {
-    readonly mode: SerovalMode;
-}
-//# sourceMappingURL=async.d.ts.map

package/dist/types/core/tree/async.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../../../src/core/tree/async.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,sBAAsB,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC;AAE/E,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,sBAAsB;IACpE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAa;CACxC"}

package/dist/types/core/tree/deserializer.d.ts

@@ -1,13 +0,0 @@
-import type { BaseDeserializerOptions } from '../context/deserializer';
-import BaseDeserializerContext from '../context/deserializer';
-import type { SerovalMode } from '../plugin';
-export interface VanillaDeserializerContextOptions extends Omit<BaseDeserializerOptions, 'refs'> {
-    markedRefs: number[] | Set<number>;
-}
-export default class VanillaDeserializerContext extends BaseDeserializerContext {
-    readonly mode: SerovalMode;
-    marked: Set<number>;
-    constructor(options: VanillaDeserializerContextOptions);
-    assignIndexedValue<T>(index: number, value: T): T;
-}
-//# sourceMappingURL=deserializer.d.ts.map

package/dist/types/core/tree/deserializer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deserializer.d.ts","sourceRoot":"","sources":["../../../../src/core/tree/deserializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,uBAAuB,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,MAAM,WAAW,iCACf,SAAQ,IAAI,CAAC,uBAAuB,EAAE,MAAM,CAAC;IAC7C,UAAU,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,CAAC,OAAO,OAAO,0BAA2B,SAAQ,uBAAuB;IAC7E,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAa;IAEvC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;gBAER,OAAO,EAAE,iCAAiC;IAKtD,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;CAMlD"}

package/dist/types/core/tree/serializer.d.ts

@@ -1,29 +0,0 @@
-import type { BaseSerializerContextOptions } from '../context/serializer';
-import BaseSerializerContext from '../context/serializer';
-import type { SerovalMode } from '../plugin';
-import type { SerovalNode, SerovalPromiseConstructorNode, SerovalPromiseRejectNode, SerovalPromiseResolveNode } from '../types';
-export type VanillaSerializerContextOptions = BaseSerializerContextOptions;
-export default class VanillaSerializerContext extends BaseSerializerContext {
-    readonly mode: SerovalMode;
-    /**
-     * Map tree refs to actual refs
-     * @private
-     */
-    valid: Map<number, number>;
-    /**
-     * Variables
-     * @private
-     */
-    vars: string[];
-    /**
-     * Creates the reference param (identifier) from the given reference ID
-     * Calling this function means the value has been referenced somewhere
-     */
-    getRefParam(index: number): string;
-    protected assignIndexedValue(index: number, value: string): string;
-    protected serializePromiseConstructor(node: SerovalPromiseConstructorNode): string;
-    protected serializePromiseResolve(node: SerovalPromiseResolveNode): string;
-    protected serializePromiseReject(node: SerovalPromiseRejectNode): string;
-    serializeTop(tree: SerovalNode): string;
-}
-//# sourceMappingURL=serializer.d.ts.map

package/dist/types/core/tree/serializer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../../src/core/tree/serializer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAC1E,OAAO,qBAAqB,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EACV,WAAW,EACX,6BAA6B,EAC7B,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,UAAU,CAAC;AAGlB,MAAM,MAAM,+BAA+B,GAAG,4BAA4B,CAAC;AAE3E,MAAM,CAAC,OAAO,OAAO,wBAAyB,SAAQ,qBAAqB;IACzE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAa;IAEvC;;;OAGG;IACH,KAAK,sBAA6B;IAElC;;;OAGG;IACH,IAAI,EAAE,MAAM,EAAE,CAAM;IAEpB;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAoBlC,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAOlE,SAAS,CAAC,2BAA2B,CACnC,IAAI,EAAE,6BAA6B,GAClC,MAAM;IAIT,SAAS,CAAC,uBAAuB,CAAC,IAAI,EAAE,yBAAyB,GAAG,MAAM;IAI1E,SAAS,CAAC,sBAAsB,CAAC,IAAI,EAAE,wBAAwB,GAAG,MAAM;IAIxE,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;CAsBxC"}

package/dist/types/core/tree/sync.d.ts

@@ -1,8 +0,0 @@
-import BaseSyncParserContext from '../context/parser/sync';
-import type { BaseParserContextOptions } from '../context/parser';
-import type { SerovalMode } from '../plugin';
-export type SyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
-export default class SyncParserContext extends BaseSyncParserContext {
-    readonly mode: SerovalMode;
-}
-//# sourceMappingURL=sync.d.ts.map

package/dist/types/core/tree/sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/core/tree/sync.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC;AAE9E,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,qBAAqB;IAClE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAa;CACxC"}

package/dist/types/core/utils/assert.d.ts

@@ -1,2 +0,0 @@
-export default function assert(cond: unknown, error: Error): asserts cond;
-//# sourceMappingURL=assert.d.ts.map

package/dist/types/core/utils/assert.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/assert.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAIxE"}

package/dist/types/core/utils/deferred.d.ts

@@ -1,7 +0,0 @@
-export interface Deferred {
-    promise: Promise<unknown>;
-    resolve(value: unknown): void;
-    reject(value: unknown): void;
-}
-export declare function createDeferred(): Deferred;
-//# sourceMappingURL=deferred.d.ts.map

package/dist/types/core/utils/deferred.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deferred.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/deferred.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1B,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9B,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9B;AAED,wBAAgB,cAAc,IAAI,QAAQ,CAezC"}

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

@@ -1,495 +0,0 @@
-import {
-  createAggregateErrorNode,
-  createArrayBufferNode,
-  createArrayNode,
-  createAsyncIteratorFactoryInstanceNode,
-  createBigIntNode,
-  createBigIntTypedArrayNode,
-  createBoxedNode,
-  createDataViewNode,
-  createDateNode,
-  createErrorNode,
-  createIteratorFactoryInstanceNode,
-  createNumberNode,
-  createPluginNode,
-  createRegExpNode,
-  createSetNode,
-  createStreamConstructorNode,
-  createStreamNextNode,
-  createStreamReturnNode,
-  createStreamThrowNode,
-  createStringNode,
-  createTypedArrayNode,
-} from '../../base-primitives';
-import { Feature } from '../../compat';
-import { NIL, SerovalNodeType } from '../../constants';
-import { SerovalParserError, SerovalUnsupportedTypeError } from '../../errors';
-import {
-  FALSE_NODE,
-  NULL_NODE,
-  TRUE_NODE,
-  UNDEFINED_NODE,
-} from '../../literals';
-import { createSerovalNode } from '../../node';
-import { OpaqueReference } from '../../opaque-reference';
-import { SpecialReference } from '../../special-reference';
-import type { Stream } from '../../stream';
-import { createStreamFromAsyncIterable, isStream } from '../../stream';
-import { serializeString } from '../../string';
-import type {
-  SerovalAggregateErrorNode,
-  SerovalArrayNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalBoxedNode,
-  SerovalDataViewNode,
-  SerovalErrorNode,
-  SerovalMapNode,
-  SerovalNode,
-  SerovalNullConstructorNode,
-  SerovalObjectNode,
-  SerovalObjectRecordKey,
-  SerovalObjectRecordNode,
-  SerovalPluginNode,
-  SerovalPromiseNode,
-  SerovalSetNode,
-  SerovalStreamConstructorNode,
-  SerovalTypedArrayNode,
-} from '../../types';
-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, ParserNodeType } from '../parser';
-
-type ObjectLikeNode =
-  | SerovalObjectNode
-  | SerovalNullConstructorNode
-  | SerovalPromiseNode;
-
-export default abstract class BaseAsyncParserContext extends BaseParserContext {
-  private async parseItems(current: unknown[]): Promise<SerovalNode[]> {
-    const nodes = [];
-    for (let i = 0, len = current.length; i < len; i++) {
-      // For consistency in holes
-      if (i in current) {
-        nodes[i] = await this.parse(current[i]);
-      }
-    }
-    return nodes;
-  }
-
-  private async parseArray(
-    id: number,
-    current: unknown[],
-  ): Promise<SerovalArrayNode> {
-    return createArrayNode(id, current, await this.parseItems(current));
-  }
-
-  private async parseProperties(
-    properties: Record<string | symbol, unknown>,
-  ): Promise<SerovalObjectRecordNode> {
-    const entries = Object.entries(properties);
-    const keyNodes: SerovalObjectRecordKey[] = [];
-    const valueNodes: SerovalNode[] = [];
-    for (let i = 0, len = entries.length; i < len; i++) {
-      keyNodes.push(serializeString(entries[i][0]));
-      valueNodes.push(await this.parse(entries[i][1]));
-    }
-    // Check special properties
-    let symbol = Symbol.iterator;
-    if (symbol in properties) {
-      keyNodes.push(this.parseWellKnownSymbol(symbol));
-      valueNodes.push(
-        createIteratorFactoryInstanceNode(
-          this.parseIteratorFactory(),
-          await this.parse(
-            iteratorToSequence(properties as unknown as Iterable<unknown>),
-          ),
-        ),
-      );
-    }
-    symbol = Symbol.asyncIterator;
-    if (symbol in properties) {
-      keyNodes.push(this.parseWellKnownSymbol(symbol));
-      valueNodes.push(
-        createAsyncIteratorFactoryInstanceNode(
-          this.parseAsyncIteratorFactory(),
-          await this.parse(
-            createStreamFromAsyncIterable(
-              properties as unknown as AsyncIterable<unknown>,
-            ),
-          ),
-        ),
-      );
-    }
-    symbol = Symbol.toStringTag;
-    if (symbol in properties) {
-      keyNodes.push(this.parseWellKnownSymbol(symbol));
-      valueNodes.push(createStringNode(properties[symbol] as string));
-    }
-    symbol = Symbol.isConcatSpreadable;
-    if (symbol in properties) {
-      keyNodes.push(this.parseWellKnownSymbol(symbol));
-      valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
-    }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: keyNodes.length,
-    };
-  }
-
-  private async parsePlainObject(
-    id: number,
-    current: Record<string, unknown>,
-    empty: boolean,
-  ): Promise<ObjectLikeNode> {
-    return this.createObjectNode(
-      id,
-      current,
-      empty,
-      await this.parseProperties(current),
-    );
-  }
-
-  private async parseBoxed(
-    id: number,
-    current: object,
-  ): Promise<SerovalBoxedNode> {
-    return createBoxedNode(id, await this.parse(current.valueOf()));
-  }
-
-  private async parseTypedArray(
-    id: number,
-    current: TypedArrayValue,
-  ): Promise<SerovalTypedArrayNode> {
-    return createTypedArrayNode(id, current, await this.parse(current.buffer));
-  }
-
-  private async parseBigIntTypedArray(
-    id: number,
-    current: BigIntTypedArrayValue,
-  ): Promise<SerovalBigIntTypedArrayNode> {
-    return createBigIntTypedArrayNode(
-      id,
-      current,
-      await this.parse(current.buffer),
-    );
-  }
-
-  private async parseDataView(
-    id: number,
-    current: DataView,
-  ): Promise<SerovalDataViewNode> {
-    return createDataViewNode(id, current, await this.parse(current.buffer));
-  }
-
-  private async parseError(
-    id: number,
-    current: Error,
-  ): Promise<SerovalErrorNode> {
-    const options = getErrorOptions(current, this.features);
-    return createErrorNode(
-      id,
-      current,
-      options ? await this.parseProperties(options) : NIL,
-    );
-  }
-
-  private async parseAggregateError(
-    id: number,
-    current: AggregateError,
-  ): Promise<SerovalAggregateErrorNode> {
-    const options = getErrorOptions(current, this.features);
-    return createAggregateErrorNode(
-      id,
-      current,
-      options ? await this.parseProperties(options) : NIL,
-    );
-  }
-
-  private async parseMap(
-    id: number,
-    current: Map<unknown, unknown>,
-  ): Promise<SerovalMapNode> {
-    const keyNodes: SerovalNode[] = [];
-    const valueNodes: SerovalNode[] = [];
-    for (const [key, value] of current.entries()) {
-      keyNodes.push(await this.parse(key));
-      valueNodes.push(await this.parse(value));
-    }
-    return this.createMapNode(id, keyNodes, valueNodes, current.size);
-  }
-
-  private async parseSet(
-    id: number,
-    current: Set<unknown>,
-  ): Promise<SerovalSetNode> {
-    const items: SerovalNode[] = [];
-    for (const item of current.keys()) {
-      items.push(await this.parse(item));
-    }
-    return createSetNode(id, current.size, items);
-  }
-
-  private async parsePromise(
-    id: number,
-    current: Promise<unknown>,
-  ): Promise<SerovalPromiseNode> {
-    const [status, result] = await promiseToResult(current);
-
-    return createSerovalNode(
-      SerovalNodeType.Promise,
-      id,
-      status,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      await this.parse(result),
-      NIL,
-      NIL,
-    );
-  }
-
-  private async parsePlugin(
-    id: number,
-    current: unknown,
-  ): Promise<SerovalPluginNode | undefined> {
-    const currentPlugins = this.plugins;
-    if (currentPlugins) {
-      for (let i = 0, len = currentPlugins.length; i < len; i++) {
-        const plugin = currentPlugins[i];
-        if (plugin.parse.async && plugin.test(current)) {
-          return createPluginNode(
-            id,
-            plugin.tag,
-            await plugin.parse.async(current, this, {
-              id,
-            }),
-          );
-        }
-      }
-    }
-    return NIL;
-  }
-
-  private async parseStream(
-    id: number,
-    current: Stream<unknown>,
-  ): Promise<SerovalStreamConstructorNode> {
-    return createStreamConstructorNode(
-      id,
-      this.parseSpecialReference(SpecialReference.StreamConstructor),
-      await new Promise<SerovalNode[]>((resolve, reject) => {
-        const sequence: SerovalNode[] = [];
-        const cleanup = current.on({
-          next: value => {
-            this.markRef(id);
-            this.parse(value).then(
-              data => {
-                sequence.push(createStreamNextNode(id, data));
-              },
-              data => {
-                reject(data);
-                cleanup();
-              },
-            );
-          },
-          throw: value => {
-            this.markRef(id);
-            this.parse(value).then(
-              data => {
-                sequence.push(createStreamThrowNode(id, data));
-                resolve(sequence);
-                cleanup();
-              },
-              data => {
-                reject(data);
-                cleanup();
-              },
-            );
-          },
-          return: value => {
-            this.markRef(id);
-            this.parse(value).then(
-              data => {
-                sequence.push(createStreamReturnNode(id, data));
-                resolve(sequence);
-                cleanup();
-              },
-              data => {
-                reject(data);
-                cleanup();
-              },
-            );
-          },
-        });
-      }),
-    );
-  }
-
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ehh
-  private async parseObject(id: number, current: object): Promise<SerovalNode> {
-    if (Array.isArray(current)) {
-      return this.parseArray(id, current);
-    }
-    if (isStream(current)) {
-      return this.parseStream(id, current);
-    }
-    const currentClass = current.constructor;
-    if (currentClass === OpaqueReference) {
-      return this.parse(
-        (current as OpaqueReference<unknown, unknown>).replacement,
-      );
-    }
-    const parsed = await this.parsePlugin(id, current);
-    if (parsed) {
-      return parsed;
-    }
-    switch (currentClass) {
-      case Object:
-        return this.parsePlainObject(
-          id,
-          current as Record<string, unknown>,
-          false,
-        );
-      case NIL:
-        return this.parsePlainObject(
-          id,
-          current as Record<string, unknown>,
-          true,
-        );
-      case Date:
-        return createDateNode(id, current as unknown as Date);
-      case RegExp:
-        return createRegExpNode(id, current as unknown as RegExp);
-      case Error:
-      case EvalError:
-      case RangeError:
-      case ReferenceError:
-      case SyntaxError:
-      case TypeError:
-      case URIError:
-        return this.parseError(id, current as unknown as Error);
-      case Number:
-      case Boolean:
-      case String:
-      case BigInt:
-        return this.parseBoxed(id, current);
-      case ArrayBuffer:
-        return createArrayBufferNode(id, current as unknown as ArrayBuffer);
-      case Int8Array:
-      case Int16Array:
-      case Int32Array:
-      case Uint8Array:
-      case Uint16Array:
-      case Uint32Array:
-      case Uint8ClampedArray:
-      case Float32Array:
-      case Float64Array:
-        return this.parseTypedArray(id, current as unknown as TypedArrayValue);
-      case DataView:
-        return this.parseDataView(id, current as unknown as DataView);
-      case Map:
-        return this.parseMap(id, current as unknown as Map<unknown, unknown>);
-      case Set:
-        return this.parseSet(id, current as unknown as Set<unknown>);
-      default:
-        break;
-    }
-    // Promises
-    if (currentClass === Promise || current instanceof Promise) {
-      return this.parsePromise(id, current as unknown as Promise<unknown>);
-    }
-    const currentFeatures = this.features;
-    // BigInt Typed Arrays
-    if (currentFeatures & Feature.BigIntTypedArray) {
-      switch (currentClass) {
-        case BigInt64Array:
-        case BigUint64Array:
-          return this.parseBigIntTypedArray(
-            id,
-            current as unknown as BigIntTypedArrayValue,
-          );
-        default:
-          break;
-      }
-    }
-    if (
-      currentFeatures & Feature.AggregateError &&
-      typeof AggregateError !== 'undefined' &&
-      (currentClass === AggregateError || current instanceof AggregateError)
-    ) {
-      return this.parseAggregateError(id, current as unknown as AggregateError);
-    }
-    // Slow path. We only need to handle Errors and Iterators
-    // since they have very broad implementations.
-    if (current instanceof Error) {
-      return this.parseError(id, current);
-    }
-    // Generator functions don't have a global constructor
-    // despite existing
-    if (Symbol.iterator in current || Symbol.asyncIterator in current) {
-      return this.parsePlainObject(id, current, !!currentClass);
-    }
-    throw new SerovalUnsupportedTypeError(current);
-  }
-
-  protected async parseFunction(current: unknown): Promise<SerovalNode> {
-    const ref = this.getReference(current);
-    if (ref.type !== ParserNodeType.Fresh) {
-      return ref.value;
-    }
-    const plugin = await this.parsePlugin(ref.value, current);
-    if (plugin) {
-      return plugin;
-    }
-    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;
-        }
-        return NULL_NODE;
-      }
-      case 'symbol':
-        return this.parseWellKnownSymbol(current);
-      case 'function':
-        return this.parseFunction(current);
-      default:
-        throw new SerovalUnsupportedTypeError(current);
-    }
-  }
-
-  async parseTop<T>(current: T): Promise<SerovalNode> {
-    try {
-      return await this.parse(current);
-    } catch (error) {
-      throw error instanceof SerovalParserError
-        ? error
-        : new SerovalParserError(error);
-    }
-  }
-}