@aiwayds/dsh-opentui 0.1.0 → 0.2.0

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/context/deserializer.ts

@@ -0,0 +1,832 @@
+import { ALL_ENABLED, Feature } from '../compat';
+import {
+  CONSTANT_VAL,
+  ERROR_CONSTRUCTOR,
+  NIL,
+  SerovalNodeType,
+  SerovalObjectFlags,
+  SYMBOL_REF,
+} from '../constants';
+import {
+  ARRAY_BUFFER_CONSTRUCTOR,
+  PROMISE_CONSTRUCTOR,
+  type PromiseConstructorResolver,
+} from '../constructors';
+import {
+  SerovalDepthLimitError,
+  SerovalDeserializationError,
+  SerovalMalformedNodeError,
+  SerovalMissingInstanceError,
+  SerovalMissingPluginError,
+  SerovalUnsupportedNodeError,
+} from '../errors';
+import type { PluginAccessOptions } from '../plugin';
+import { SerovalMode } from '../plugin';
+import { getReference } from '../reference';
+import { createSequence, type Sequence, sequenceToIterator } from '../sequence';
+import type { Stream } from '../stream';
+import { createStream, streamToAsyncIterable } from '../stream';
+import { deserializeString } from '../string';
+import type {
+  SerovalAggregateErrorNode,
+  SerovalArrayBufferNode,
+  SerovalArrayNode,
+  SerovalAsyncIteratorFactoryInstanceNode,
+  SerovalAsyncIteratorFactoryNode,
+  SerovalBigIntTypedArrayNode,
+  SerovalBoxedNode,
+  SerovalDataViewNode,
+  SerovalDateNode,
+  SerovalErrorNode,
+  SerovalIteratorFactoryInstanceNode,
+  SerovalIteratorFactoryNode,
+  SerovalMapNode,
+  SerovalNode,
+  SerovalNullConstructorNode,
+  SerovalObjectNode,
+  SerovalObjectRecordNode,
+  SerovalPluginNode,
+  SerovalPromiseConstructorNode,
+  SerovalPromiseNode,
+  SerovalPromiseRejectNode,
+  SerovalPromiseResolveNode,
+  SerovalReferenceNode,
+  SerovalRegExpNode,
+  SerovalSequenceNode,
+  SerovalSetNode,
+  SerovalStreamConstructorNode,
+  SerovalStreamNextNode,
+  SerovalStreamReturnNode,
+  SerovalStreamThrowNode,
+  SerovalTypedArrayNode,
+} from '../types';
+import type {
+  BigIntTypedArrayValue,
+  TypedArrayValue,
+} from '../utils/typed-array';
+import { getTypedArrayConstructor } from '../utils/typed-array';
+import { isValidKey, isValidSymbol } from '../utils/valid-properties';
+
+const MAX_BASE64_LENGTH = 1_000_000; // ~0.75MB decoded
+const MAX_BIGINT_LENGTH = 10_000;
+const MAX_REGEXP_SOURCE_LENGTH = 20_000;
+
+function applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {
+  switch (flag) {
+    case SerovalObjectFlags.Frozen:
+      return Object.freeze(obj);
+    case SerovalObjectFlags.NonExtensible:
+      return Object.preventExtensions(obj);
+    case SerovalObjectFlags.Sealed:
+      return Object.seal(obj);
+    default:
+      return obj;
+  }
+}
+
+type AssignableValue = AggregateError | Error | Iterable<unknown>;
+type AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode;
+
+export interface BaseDeserializerContextOptions extends PluginAccessOptions {
+  refs?: Map<number, unknown>;
+  features?: number;
+  disabledFeatures?: number;
+  depthLimit?: number;
+}
+
+export interface BaseDeserializerContext extends PluginAccessOptions {
+  readonly mode: SerovalMode;
+  /**
+   * Mapping ids to values
+   */
+  refs: Map<number, unknown> & { types: Map<number, SerovalNodeType> };
+  features: number;
+  depthLimit: number;
+}
+
+const DEFAULT_DEPTH_LIMIT = 1000;
+
+export function createBaseDeserializerContext(
+  mode: SerovalMode,
+  options: BaseDeserializerContextOptions,
+): BaseDeserializerContext {
+  const refs = options.refs || new Map();
+  if (!('types' in refs)) {
+    Object.assign(refs, {
+      types: new Map(),
+    });
+  }
+  return {
+    mode,
+    plugins: options.plugins,
+    refs: refs as BaseDeserializerContext['refs'],
+    features: options.features ?? ALL_ENABLED ^ (options.disabledFeatures || 0),
+    depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT,
+  };
+}
+
+export interface VanillaDeserializerContextOptions
+  extends Omit<BaseDeserializerContextOptions, 'refs'> {
+  markedRefs: number[] | Set<number>;
+}
+
+export interface VanillaDeserializerState {
+  marked: Set<number>;
+}
+
+export interface VanillaDeserializerContext {
+  mode: SerovalMode.Vanilla;
+  base: BaseDeserializerContext;
+  child: DeserializePluginContext | undefined;
+  state: VanillaDeserializerState;
+}
+
+export function createVanillaDeserializerContext(
+  options: VanillaDeserializerContextOptions,
+): VanillaDeserializerContext {
+  return {
+    mode: SerovalMode.Vanilla,
+    base: createBaseDeserializerContext(SerovalMode.Vanilla, options),
+    child: NIL,
+    state: {
+      marked: new Set(options.markedRefs),
+    },
+  };
+}
+
+export interface CrossDeserializerContext {
+  mode: SerovalMode.Cross;
+  base: BaseDeserializerContext;
+  child: DeserializePluginContext | undefined;
+}
+
+export type CrossDeserializerContextOptions = BaseDeserializerContextOptions;
+
+export function createCrossDeserializerContext(
+  options: CrossDeserializerContextOptions,
+): CrossDeserializerContext {
+  return {
+    mode: SerovalMode.Cross,
+    base: createBaseDeserializerContext(SerovalMode.Cross, options),
+    child: NIL,
+  };
+}
+
+type DeserializerContext =
+  | VanillaDeserializerContext
+  | CrossDeserializerContext;
+
+export class DeserializePluginContext {
+  constructor(
+    private _p: DeserializerContext,
+    private depth: number,
+  ) {}
+
+  deserialize<T>(node: SerovalNode): T {
+    return deserialize(this._p, this.depth, node) as T;
+  }
+}
+
+function guardIndexedValue(ctx: BaseDeserializerContext, id: number): void {
+  if (id < 0 || !Number.isFinite(id) || !Number.isInteger(id)) {
+    throw new SerovalMalformedNodeError({
+      t: SerovalNodeType.IndexedValue,
+      i: id,
+    } as SerovalNode);
+  }
+  if (ctx.refs.has(id)) {
+    throw new Error('Conflicted ref id: ' + id);
+  }
+}
+
+function assignIndexedValueVanilla<T>(
+  ctx: VanillaDeserializerContext,
+  id: number,
+  value: T,
+): T {
+  guardIndexedValue(ctx.base, id);
+  if (ctx.state.marked.has(id)) {
+    ctx.base.refs.set(id, value);
+  }
+  return value;
+}
+
+function assignIndexedValueCross<T>(
+  ctx: CrossDeserializerContext,
+  id: number,
+  value: T,
+): T {
+  guardIndexedValue(ctx.base, id);
+  ctx.base.refs.set(id, value);
+  return value;
+}
+
+function assignIndexedValue<T>(
+  ctx: DeserializerContext,
+  id: number,
+  value: T,
+): T {
+  return ctx.mode === SerovalMode.Vanilla
+    ? assignIndexedValueVanilla(ctx, id, value)
+    : assignIndexedValueCross(ctx, id, value);
+}
+
+function deserializeKnownValue<
+  T extends Record<string, unknown>,
+  K extends keyof T,
+>(node: SerovalNode, record: T, key: K): T[K] {
+  if (Object.hasOwn(record, key)) {
+    return record[key];
+  }
+  throw new SerovalMalformedNodeError(node);
+}
+
+function deserializeReference(
+  ctx: DeserializerContext,
+  node: SerovalReferenceNode,
+): unknown {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    getReference(deserializeString(node.s)),
+  );
+}
+
+function deserializeArray(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalArrayNode,
+): unknown[] {
+  const items = node.a;
+  const len = items.length;
+  const result: unknown[] = assignIndexedValue(
+    ctx,
+    node.i,
+    new Array<unknown>(len),
+  );
+  for (let i = 0, item: SerovalNode | 0; i < len; i++) {
+    item = items[i];
+    if (item) {
+      result[i] = deserialize(ctx, depth, item);
+    }
+  }
+  applyObjectFlag(result, node.o);
+  return result;
+}
+
+function assignStringProperty(
+  object: Record<string | symbol, unknown>,
+  key: string,
+  value: unknown,
+): void {
+  if (isValidKey(key)) {
+    object[key] = value;
+  } else {
+    Object.defineProperty(object, key, {
+      value,
+      configurable: true,
+      enumerable: true,
+      writable: true,
+    });
+  }
+}
+
+function assignProperty(
+  ctx: DeserializerContext,
+  depth: number,
+  object: Record<string | symbol, unknown>,
+  key: string | SerovalNode,
+  value: SerovalNode,
+): void {
+  if (typeof key === 'string') {
+    assignStringProperty(
+      object,
+      deserializeString(key),
+      deserialize(ctx, depth, value),
+    );
+  } else {
+    const actual = deserialize(ctx, depth, key);
+    switch (typeof actual) {
+      case 'string':
+        assignStringProperty(object, actual, deserialize(ctx, depth, value));
+        break;
+      case 'symbol':
+        if (isValidSymbol(actual)) {
+          object[actual] = deserialize(ctx, depth, value);
+        }
+        break;
+      default:
+        throw new SerovalMalformedNodeError(key);
+    }
+  }
+}
+
+function assignNodeType(
+  ctx: DeserializerContext,
+  id: number,
+  type: SerovalNodeType,
+): void {
+  ctx.base.refs.types.set(id, type);
+}
+
+function validateNodeType(
+  ctx: DeserializerContext,
+  node: SerovalNode,
+  id: number,
+  type: SerovalNodeType,
+): asserts id is SerovalNodeType {
+  if (ctx.base.refs.types.get(id) !== type) {
+    throw new SerovalMalformedNodeError(node);
+  }
+}
+
+function deserializeProperties(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalObjectRecordNode,
+  result: Record<string | symbol, unknown>,
+): Record<string | symbol, unknown> {
+  const keys = node.k;
+  const len = keys.length;
+  if (len > 0) {
+    for (let i = 0, vals = node.v, len = keys.length; i < len; i++) {
+      assignProperty(ctx, depth, result, keys[i], vals[i]);
+    }
+  }
+  return result;
+}
+
+function deserializeObject(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalObjectNode | SerovalNullConstructorNode,
+): Record<string, unknown> {
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    (node.t === SerovalNodeType.Object ? {} : Object.create(null)) as Record<
+      string,
+      unknown
+    >,
+  );
+  deserializeProperties(ctx, depth, node.p, result);
+  applyObjectFlag(result, node.o);
+  return result;
+}
+
+function deserializeDate(
+  ctx: DeserializerContext,
+  node: SerovalDateNode,
+): Date {
+  return assignIndexedValue(ctx, node.i, new Date(node.s));
+}
+
+function deserializeRegExp(
+  ctx: DeserializerContext,
+  node: SerovalRegExpNode,
+): RegExp {
+  if (ctx.base.features & Feature.RegExp) {
+    const source = deserializeString(node.c);
+    if (source.length > MAX_REGEXP_SOURCE_LENGTH) {
+      throw new SerovalMalformedNodeError(node);
+    }
+    return assignIndexedValue(ctx, node.i, new RegExp(source, node.m));
+  }
+  throw new SerovalUnsupportedNodeError(node);
+}
+
+function deserializeSet(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalSetNode,
+): Set<unknown> {
+  const result = assignIndexedValue(ctx, node.i, new Set<unknown>());
+  for (let i = 0, items = node.a, len = items.length; i < len; i++) {
+    result.add(deserialize(ctx, depth, items[i]));
+  }
+  return result;
+}
+
+function deserializeMap(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalMapNode,
+): Map<unknown, unknown> {
+  const result = assignIndexedValue(ctx, node.i, new Map<unknown, unknown>());
+  for (
+    let i = 0, keys = node.e.k, vals = node.e.v, len = keys.length;
+    i < len;
+    i++
+  ) {
+    result.set(
+      deserialize(ctx, depth, keys[i]),
+      deserialize(ctx, depth, vals[i]),
+    );
+  }
+  return result;
+}
+
+function deserializeArrayBuffer(
+  ctx: DeserializerContext,
+  node: SerovalArrayBufferNode,
+): ArrayBuffer {
+  if (node.s.length > MAX_BASE64_LENGTH) {
+    throw new SerovalMalformedNodeError(node);
+  }
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    ARRAY_BUFFER_CONSTRUCTOR(deserializeString(node.s)),
+  );
+  return result;
+}
+
+function deserializeTypedArray(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
+): TypedArrayValue | BigIntTypedArrayValue {
+  const construct = getTypedArrayConstructor(node.c) as Int8ArrayConstructor;
+  const source = deserialize(ctx, depth, node.f) as ArrayBuffer;
+  const offset = node.b ?? 0;
+  if (offset < 0 || offset > source.byteLength) {
+    throw new SerovalMalformedNodeError(node);
+  }
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    new construct(source, offset, node.l),
+  );
+  return result;
+}
+
+function deserializeDataView(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalDataViewNode,
+): DataView {
+  const source = deserialize(ctx, depth, node.f) as ArrayBuffer;
+  const offset = node.b ?? 0;
+  if (offset < 0 || offset > source.byteLength) {
+    throw new SerovalMalformedNodeError(node);
+  }
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    new DataView(source, offset, node.l),
+  );
+  return result;
+}
+
+function deserializeDictionary<T extends AssignableValue>(
+  ctx: DeserializerContext,
+  depth: number,
+  node: AssignableNode,
+  result: T,
+): T {
+  if (node.p) {
+    const fields = deserializeProperties(ctx, depth, node.p, {});
+    Object.defineProperties(result, Object.getOwnPropertyDescriptors(fields));
+  }
+  return result;
+}
+
+function deserializeAggregateError(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalAggregateErrorNode,
+): AggregateError {
+  // Serialize the required arguments
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    new AggregateError([], deserializeString(node.m)),
+  );
+  // `AggregateError` might've been extended
+  // either through class or custom properties
+  // Make sure to assign extra properties
+  return deserializeDictionary(ctx, depth, node, result);
+}
+
+function deserializeError(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalErrorNode,
+): Error {
+  const construct = deserializeKnownValue(node, ERROR_CONSTRUCTOR, node.s);
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    new construct(deserializeString(node.m)),
+  );
+  return deserializeDictionary(ctx, depth, node, result);
+}
+
+function deserializePromise(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalPromiseNode,
+): Promise<unknown> {
+  const deferred = PROMISE_CONSTRUCTOR();
+  const result = assignIndexedValue(ctx, node.i, deferred.p);
+  const deserialized = deserialize(ctx, depth, node.f);
+  if (node.s) {
+    deferred.s(deserialized);
+  } else {
+    deferred.f(deserialized);
+  }
+  return result;
+}
+
+function deserializeBoxed(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalBoxedNode,
+): unknown {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    // biome-ignore lint/style/useConsistentBuiltinInstantiation: intended
+    Object(deserialize(ctx, depth, node.f)),
+  );
+}
+
+function deserializePlugin(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalPluginNode,
+): unknown {
+  const currentPlugins = ctx.base.plugins;
+  if (currentPlugins) {
+    const tag = deserializeString(node.c);
+    for (let i = 0, len = currentPlugins.length; i < len; i++) {
+      const plugin = currentPlugins[i];
+      if (plugin.tag === tag) {
+        return assignIndexedValue(
+          ctx,
+          node.i,
+          plugin.deserialize(node.s, new DeserializePluginContext(ctx, depth), {
+            id: node.i,
+          }),
+        );
+      }
+    }
+  }
+  throw new SerovalMissingPluginError(node.c);
+}
+
+function deserializePromiseConstructor(
+  ctx: DeserializerContext,
+  node: SerovalPromiseConstructorNode,
+): unknown {
+  const value = assignIndexedValue(
+    ctx,
+    node.i,
+    assignIndexedValue(ctx, node.s, PROMISE_CONSTRUCTOR()).p,
+  );
+  assignNodeType(ctx, node.s, SerovalNodeType.PromiseConstructor);
+  return value;
+}
+
+function deserializePromiseResolve(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalPromiseResolveNode,
+): unknown {
+  const deferred = ctx.base.refs.get(node.i) as
+    | PromiseConstructorResolver
+    | undefined;
+  if (deferred) {
+    validateNodeType(ctx, node, node.i, SerovalNodeType.PromiseConstructor);
+    deferred.s(deserialize(ctx, depth, node.a[1]));
+    return NIL;
+  }
+  throw new SerovalMissingInstanceError('Promise');
+}
+
+function deserializePromiseReject(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalPromiseRejectNode,
+): unknown {
+  const deferred = ctx.base.refs.get(node.i) as
+    | PromiseConstructorResolver
+    | undefined;
+  if (deferred) {
+    validateNodeType(ctx, node, node.i, SerovalNodeType.PromiseConstructor);
+    deferred.f(deserialize(ctx, depth, node.a[1]));
+    return NIL;
+  }
+  throw new SerovalMissingInstanceError('Promise');
+}
+
+function deserializeIteratorFactoryInstance(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalIteratorFactoryInstanceNode,
+): unknown {
+  deserialize(ctx, depth, node.a[0]);
+  const source = deserialize(ctx, depth, node.a[1]);
+  return sequenceToIterator(source as Sequence);
+}
+
+function deserializeAsyncIteratorFactoryInstance(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalAsyncIteratorFactoryInstanceNode,
+): unknown {
+  deserialize(ctx, depth, node.a[0]);
+  const source = deserialize(ctx, depth, node.a[1]);
+  return streamToAsyncIterable(source as Stream<any>);
+}
+
+function deserializeStreamConstructor(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalStreamConstructorNode,
+): unknown {
+  const result = assignIndexedValue(ctx, node.i, createStream());
+  assignNodeType(ctx, node.i, SerovalNodeType.StreamConstructor);
+  const items = node.a;
+  const len = items.length;
+  if (len) {
+    for (let i = 0; i < len; i++) {
+      deserialize(ctx, depth, items[i]);
+    }
+  }
+  return result;
+}
+
+function deserializeStreamNext(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalStreamNextNode,
+): unknown {
+  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
+  if (deferred) {
+    validateNodeType(ctx, node, node.i, SerovalNodeType.StreamConstructor);
+    deferred.next(deserialize(ctx, depth, node.f));
+    return NIL;
+  }
+  throw new SerovalMissingInstanceError('Stream');
+}
+
+function deserializeStreamThrow(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalStreamThrowNode,
+): unknown {
+  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
+  if (deferred) {
+    validateNodeType(ctx, node, node.i, SerovalNodeType.StreamConstructor);
+    deferred.throw(deserialize(ctx, depth, node.f));
+    return NIL;
+  }
+  throw new SerovalMissingInstanceError('Stream');
+}
+
+function deserializeStreamReturn(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalStreamReturnNode,
+): unknown {
+  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
+  if (deferred) {
+    validateNodeType(ctx, node, node.i, SerovalNodeType.StreamConstructor);
+    deferred.return(deserialize(ctx, depth, node.f));
+    return NIL;
+  }
+  throw new SerovalMissingInstanceError('Stream');
+}
+
+function deserializeIteratorFactory(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalIteratorFactoryNode,
+): unknown {
+  deserialize(ctx, depth, node.f);
+  return NIL;
+}
+
+function deserializeAsyncIteratorFactory(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalAsyncIteratorFactoryNode,
+): unknown {
+  deserialize(ctx, depth, node.a[1]);
+  return NIL;
+}
+
+function deserializeSequence(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalSequenceNode,
+): Sequence {
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    createSequence([], node.s, node.l),
+  );
+  for (let i = 0, len = node.a.length; i < len; i++) {
+    result.v[i] = deserialize(ctx, depth, node.a[i]);
+  }
+  return result;
+}
+
+function deserialize(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalNode,
+): unknown {
+  if (depth > ctx.base.depthLimit) {
+    throw new SerovalDepthLimitError(ctx.base.depthLimit);
+  }
+  depth += 1;
+  switch (node.t) {
+    case SerovalNodeType.Constant:
+      return deserializeKnownValue(node, CONSTANT_VAL, node.s);
+    case SerovalNodeType.Number:
+      return Number(node.s);
+    case SerovalNodeType.String:
+      return deserializeString(String(node.s));
+    case SerovalNodeType.BigInt:
+      if (String(node.s).length > MAX_BIGINT_LENGTH) {
+        throw new SerovalMalformedNodeError(node);
+      }
+      return BigInt(node.s);
+    case SerovalNodeType.IndexedValue:
+      return ctx.base.refs.get(node.i);
+    case SerovalNodeType.Reference:
+      return deserializeReference(ctx, node);
+    case SerovalNodeType.Array:
+      return deserializeArray(ctx, depth, node);
+    case SerovalNodeType.Object:
+    case SerovalNodeType.NullConstructor:
+      return deserializeObject(ctx, depth, node);
+    case SerovalNodeType.Date:
+      return deserializeDate(ctx, node);
+    case SerovalNodeType.RegExp:
+      return deserializeRegExp(ctx, node);
+    case SerovalNodeType.Set:
+      return deserializeSet(ctx, depth, node);
+    case SerovalNodeType.Map:
+      return deserializeMap(ctx, depth, node);
+    case SerovalNodeType.ArrayBuffer:
+      return deserializeArrayBuffer(ctx, node);
+    case SerovalNodeType.BigIntTypedArray:
+    case SerovalNodeType.TypedArray:
+      return deserializeTypedArray(ctx, depth, node);
+    case SerovalNodeType.DataView:
+      return deserializeDataView(ctx, depth, node);
+    case SerovalNodeType.AggregateError:
+      return deserializeAggregateError(ctx, depth, node);
+    case SerovalNodeType.Error:
+      return deserializeError(ctx, depth, node);
+    case SerovalNodeType.Promise:
+      return deserializePromise(ctx, depth, node);
+    case SerovalNodeType.WKSymbol:
+      return deserializeKnownValue(node, SYMBOL_REF, node.s);
+    case SerovalNodeType.Boxed:
+      return deserializeBoxed(ctx, depth, node);
+    case SerovalNodeType.Plugin:
+      return deserializePlugin(ctx, depth, node);
+    case SerovalNodeType.PromiseConstructor:
+      return deserializePromiseConstructor(ctx, node);
+    case SerovalNodeType.PromiseSuccess:
+      return deserializePromiseResolve(ctx, depth, node);
+    case SerovalNodeType.PromiseFailure:
+      return deserializePromiseReject(ctx, depth, node);
+    case SerovalNodeType.IteratorFactoryInstance:
+      return deserializeIteratorFactoryInstance(ctx, depth, node);
+    case SerovalNodeType.AsyncIteratorFactoryInstance:
+      return deserializeAsyncIteratorFactoryInstance(ctx, depth, node);
+    case SerovalNodeType.StreamConstructor:
+      return deserializeStreamConstructor(ctx, depth, node);
+    case SerovalNodeType.StreamNext:
+      return deserializeStreamNext(ctx, depth, node);
+    case SerovalNodeType.StreamThrow:
+      return deserializeStreamThrow(ctx, depth, node);
+    case SerovalNodeType.StreamReturn:
+      return deserializeStreamReturn(ctx, depth, node);
+    case SerovalNodeType.IteratorFactory:
+      return deserializeIteratorFactory(ctx, depth, node);
+    case SerovalNodeType.AsyncIteratorFactory:
+      return deserializeAsyncIteratorFactory(ctx, depth, node);
+    // case SerovalNodeType.SpecialReference:
+    case SerovalNodeType.Sequence:
+      return deserializeSequence(ctx, depth, node);
+    default:
+      throw new SerovalUnsupportedNodeError(node);
+  }
+}
+
+export function deserializeTop(
+  ctx: DeserializerContext,
+  node: SerovalNode,
+): unknown {
+  try {
+    return deserialize(ctx, 0, node);
+  } catch (error) {
+    throw new SerovalDeserializationError(error);
+  }
+}