seroval 0.4.0-alpha.2 → 0.4.0-alpha.4

package/src/tree.ts

@@ -14,7 +14,6 @@ import {
   ErrorValue,
   PrimitiveValue,
   ServerValue,
-  TypedArrayValue,
 } from './types';
 import getIdentifier from './get-identifier';
 import { Feature, parseTargets } from './compat';
@@ -45,20 +44,24 @@ export type Assignment =
   | MapAssignment
   | SetAssignment;
 
+export interface ParserContext {
+  refs: Map<unknown, number>;
+  markedRefs: Set<number>;
+  features: number;
+}
+
 export interface SerializationContext {
   stack: number[];
-  // Value-to-ref map
-  refs: Map<unknown, number>;
   // Map tree refs to actual refs
   validRefs: Map<number, number>;
   // Refs that are...referenced
-  markedRefs: boolean[];
+  markedRefs: Set<number>;
   // Variables
   vars: string[];
   // Array of assignments to be done (used for recursion)
   assignments: Assignment[];
   // Supported features
-  features: Set<Feature>;
+  features: number;
 }
 
 export interface Options {
@@ -69,17 +72,29 @@ const DEFAULT_OPTIONS: Options = {
   target: 'es2023',
 };
 
-export function createSerializationContext(options: Partial<Options> = {}): SerializationContext {
+export function createParserContext(options: Partial<Options> = {}): ParserContext {
   // eslint-disable-next-line prefer-object-spread
   const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    markedRefs: [],
-    stack: [],
+    markedRefs: new Set(),
     refs: new Map(),
+    features: parseTargets(result.target),
+  };
+}
+
+export interface SerializationOptions {
+  markedRefs: number[] | Set<number>;
+  features: number;
+}
+
+export function createSerializationContext(options: SerializationOptions): SerializationContext {
+  return {
+    stack: [],
     vars: [],
     assignments: [],
     validRefs: new Map(),
-    features: parseTargets(result.target),
+    features: options.features,
+    markedRefs: new Set(options.markedRefs),
   };
 }
 
@@ -162,24 +177,8 @@ export function resolvePatches(ctx: SerializationContext) {
 /**
  * Increments the number of references the referenced value has
  */
-function markRef(ctx: SerializationContext, current: number) {
-  ctx.markedRefs[current] = true;
-}
-
-/**
- * Creates a reference ID from the given values
- */
-export function createRef(
-  ctx: SerializationContext,
-  index: unknown,
-) {
-  const current = ctx.refs.get(index);
-  if (current != null) {
-    return current;
-  }
-  const id = ctx.refs.size;
-  ctx.refs.set(index, id);
-  return id;
+function markRef(ctx: ParserContext | SerializationContext, current: number) {
+  ctx.markedRefs.add(current);
 }
 
 /**
@@ -225,12 +224,28 @@ function assignRef(
   index: number,
   value: string,
 ) {
-  if (ctx.markedRefs[index]) {
+  if (ctx.markedRefs.has(index)) {
     return `${getRefParam(ctx, index)}=${value}`;
   }
   return value;
 }
 
+/**
+ * Creates a reference ID from the given values
+ */
+function createRef(
+  ctx: ParserContext,
+  index: unknown,
+) {
+  const current = ctx.refs.get(index);
+  if (current != null) {
+    return current;
+  }
+  const id = ctx.refs.size;
+  ctx.refs.set(index, id);
+  return id;
+}
+
 function createAssignment(
   ctx: SerializationContext,
   source: string,
@@ -281,24 +296,16 @@ function createArrayAssign(
   createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
 }
 
-function createObjectIdentifierAssign(
+function createObjectAssign(
   ctx: SerializationContext,
   ref: number,
   key: string,
   value: string,
+  computed: boolean,
 ) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
-}
-
-function createObjectComputedAssign(
-  ctx: SerializationContext,
-  ref: number,
-  key: string,
-  value: string,
-) {
-  markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${key}]`, value);
+  const member = computed ? `[${key}]` : `.${key}`;
+  createAssignment(ctx, `${getRefParam(ctx, ref)}${member}`, value);
 }
 
 function getErrorConstructor(error: ErrorValue) {
@@ -360,6 +367,7 @@ function getIterableOptions(obj: Iterable<any>) {
 
 const enum SerovalNodeType {
   Primitive,
+  BigInt,
   Reference,
   Date,
   RegExp,
@@ -373,16 +381,23 @@ const enum SerovalNodeType {
   AggregateError,
   Iterable,
   TypedArray,
+  BigIntTypedArray,
 }
 
 type SerovalPrimitiveNode = [type: SerovalNodeType.Primitive, value: PrimitiveValue];
 type SerovalReferenceNode = [type: SerovalNodeType.Reference, value: number];
 type SerovalSemiPrimitiveNode =
-  | [type: SerovalNodeType.Date, value: Date, id: number]
-  | [type: SerovalNodeType.RegExp, value: RegExp, id: number]
+  | [type: SerovalNodeType.BigInt, value: string]
+  | [type: SerovalNodeType.Date, value: string, id: number]
+  | [type: SerovalNodeType.RegExp, value: string, id: number]
   | [
     type: SerovalNodeType.TypedArray,
-    value: [constructor: string, array: TypedArrayValue],
+    value: [constructor: string, array: string, byteOffset: number],
+    id: number
+  ]
+  | [
+    type: SerovalNodeType.BigIntTypedArray,
+    value: [constructor: string, array: string, byteOffset: number],
     id: number
   ];
 
@@ -429,7 +444,7 @@ type SerovalIterableNode = [
   id: number,
 ];
 
-type SerovalNode =
+export type SerovalNode =
   | SerovalPrimitiveNode
   | SerovalReferenceNode
   | SerovalSemiPrimitiveNode
@@ -451,7 +466,7 @@ function isReferenceInStack(
 }
 
 function generateRef(
-  ctx: SerializationContext,
+  ctx: ParserContext,
   current: unknown,
 ): number | SerovalReferenceNode {
   // Check if reference number already exists
@@ -471,104 +486,129 @@ function generateRef(
 }
 
 function generateSemiPrimitiveValue(
-  ctx: SerializationContext,
+  ctx: ParserContext,
   current: unknown,
   id: number,
 ): SerovalNode | undefined {
+  if (typeof current === 'bigint') {
+    assert(ctx.features & Feature.BigInt, 'Unsupported type "BigInt"');
+    return [SerovalNodeType.BigInt, `${current}n`];
+  }
   if (constructorCheck<Date>(current, Date)) {
-    return [SerovalNodeType.Date, current, id];
+    return [SerovalNodeType.Date, current.toISOString(), id];
   }
   if (constructorCheck<RegExp>(current, RegExp)) {
-    return [SerovalNodeType.RegExp, current, id];
+    return [SerovalNodeType.RegExp, String(current), id];
   }
   if (constructorCheck<Int8Array>(current, Int8Array)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Int8Array"');
-    return [SerovalNodeType.TypedArray, ['Int8Array', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Int8Array"');
+    return [SerovalNodeType.TypedArray, ['Int8Array', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<Int16Array>(current, Int16Array)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Int16Array"');
-    return [SerovalNodeType.TypedArray, ['Int16Array', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Int16Array"');
+    return [SerovalNodeType.TypedArray, ['Int16Array', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<Int32Array>(current, Int32Array)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Int32Array"');
-    return [SerovalNodeType.TypedArray, ['Int32Array', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Int32Array"');
+    return [SerovalNodeType.TypedArray, ['Int32Array', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<Uint8Array>(current, Uint8Array)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Uint8Array"');
-    return [SerovalNodeType.TypedArray, ['Uint8Array', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Uint8Array"');
+    return [SerovalNodeType.TypedArray, ['Uint8Array', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<Uint16Array>(current, Uint16Array)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Uint16Array"');
-    return [SerovalNodeType.TypedArray, ['Uint16Array', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Uint16Array"');
+    return [SerovalNodeType.TypedArray, ['Uint16Array', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<Uint32Array>(current, Uint32Array)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Uint32Array"');
-    return [SerovalNodeType.TypedArray, ['Uint32Array', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Uint32Array"');
+    return [SerovalNodeType.TypedArray, ['Uint32Array', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<Uint8ClampedArray>(current, Uint8ClampedArray)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Uint8ClampedArray"');
-    return [SerovalNodeType.TypedArray, ['Uint8ClampedArray', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Uint8ClampedArray"');
+    return [SerovalNodeType.TypedArray, ['Uint8ClampedArray', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<Float32Array>(current, Float32Array)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Float32Array"');
-    return [SerovalNodeType.TypedArray, ['Float32Array', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Float32Array"');
+    return [SerovalNodeType.TypedArray, ['Float32Array', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<Float64Array>(current, Float64Array)) {
-    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Float64Array"');
-    return [SerovalNodeType.TypedArray, ['Float64Array', current], id];
+    assert(ctx.features & Feature.TypedArray, 'Unsupported value type "Float64Array"');
+    return [SerovalNodeType.TypedArray, ['Float64Array', current.toString(), current.byteOffset], id];
   }
   if (constructorCheck<BigInt64Array>(current, BigInt64Array)) {
     assert(
-      ctx.features.has(Feature.TypedArray)
-      && ctx.features.has(Feature.BigInt),
+      ctx.features & (Feature.BigIntTypedArray),
       'Unsupported value type "BigInt64Array"',
     );
-    return [SerovalNodeType.TypedArray, ['BigInt64Array', current], id];
+    let result = '';
+    const cap = current.length - 1;
+    for (let i = 0; i < cap; i++) {
+      result += `${current[i]}n,`;
+    }
+    result += `"${current[cap]}"`;
+    return [
+      SerovalNodeType.BigIntTypedArray,
+      ['BigInt64Array', result, current.byteOffset],
+      id,
+    ];
   }
   if (constructorCheck<BigUint64Array>(current, BigUint64Array)) {
     assert(
-      ctx.features.has(Feature.TypedArray)
-      && ctx.features.has(Feature.BigInt),
+      ctx.features & (Feature.BigIntTypedArray),
       'Unsupported value type "BigUint64Array"',
     );
-    return [SerovalNodeType.TypedArray, ['BigUint64Array', current], id];
+    let result = '';
+    const cap = current.length - 1;
+    for (let i = 0; i < cap; i++) {
+      result += `"${current[i]}n",`;
+    }
+    result += `"${current[cap]}"`;
+    return [
+      SerovalNodeType.BigIntTypedArray,
+      ['BigInt64Array', result, current.byteOffset],
+      id,
+    ];
   }
   return undefined;
 }
 
 function serializePropertiesSync(
-  ctx: SerializationContext,
+  ctx: ParserContext,
   properties: Record<string, unknown>,
 ): SerovalDictionaryNode {
-  const keyNodes: string[] = [];
-  const valueNodes: SerovalNode[] = [];
-  const deferredKeys: string[] = [];
-  const deferredValues: ServerValue[] = [];
   const keys = Object.keys(properties);
+  const size = keys.length;
+  const keyNodes = new Array<string>(size);
+  const valueNodes = new Array<SerovalNode>(size);
+  const deferredKeys = new Array<string>(size);
+  const deferredValues = new Array<ServerValue>(size);
   let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferredKeys.push(key);
-      deferredValues.push(properties[key] as ServerValue);
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key] as ServerValue;
       deferredSize++;
     } else {
-      keyNodes.push(key);
-      valueNodes.push(generateTreeSync(ctx, properties[key] as ServerValue));
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key] as ServerValue);
+      nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes.push(deferredKeys[i]);
-    valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, keys.length];
+  return [keyNodes, valueNodes, size];
 }
 
-export function generateTreeSync(
-  ctx: SerializationContext,
+function generateTreeSync(
+  ctx: ParserContext,
   current: ServerValue,
 ): SerovalNode {
   if (isPrimitive(current)) {
-    return [SerovalNodeType.Primitive, current];
+    return [SerovalNodeType.Primitive, serializePrimitive(current)];
   }
   // Non-primitive values needs a reference ID
   // mostly because the values themselves are stateful
@@ -581,46 +621,52 @@ export function generateTreeSync(
     return semiPrimitive;
   }
   if (constructorCheck<Set<ServerValue>>(current, Set)) {
-    assert(ctx.features.has(Feature.Set), 'Unsupported type "Set"');
-    const nodes: SerovalNode[] = [];
-    const deferred: ServerValue[] = [];
+    assert(ctx.features & Feature.Set, 'Unsupported type "Set"');
+    const len = current.size;
+    const nodes = new Array<SerovalNode>(len);
+    const deferred = new Array<ServerValue>(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
     for (const item of current.keys()) {
       // Iterables are lazy, so the evaluation must be deferred
       if (isIterable(item)) {
-        deferred.push(item);
+        deferred[deferredSize++] = item;
       } else {
-        nodes.push(generateTreeSync(ctx, item));
+        nodes[nodeSize++] = generateTreeSync(ctx, item);
       }
     }
     // Parse deferred items
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(generateTreeSync(ctx, deferred[i]));
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
     }
     return [SerovalNodeType.Set, nodes, id];
   }
   if (constructorCheck<Map<ServerValue, ServerValue>>(current, Map)) {
-    assert(ctx.features.has(Feature.Map), 'Unsupported type "Map"');
-    const keyNodes: SerovalNode[] = [];
-    const valueNodes: SerovalNode[] = [];
-    const deferredKey: ServerValue[] = [];
-    const deferredValue: ServerValue[] = [];
+    assert(ctx.features & Feature.Map, 'Unsupported type "Map"');
+    const len = current.size;
+    const keyNodes = new Array<SerovalNode>(len);
+    const valueNodes = new Array<SerovalNode>(len);
+    const deferredKey = new Array<ServerValue>(len);
+    const deferredValue = new Array<ServerValue>(len);
     let deferredSize = 0;
+    let nodeSize = 0;
     for (const [key, value] of current.entries()) {
       // Either key or value might be an iterable
       if (isIterable(key) || isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
+        deferredKey[deferredSize] = key;
+        deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes.push(generateTreeSync(ctx, key));
-        valueNodes.push(generateTreeSync(ctx, value));
+        keyNodes[nodeSize] = generateTreeSync(ctx, key);
+        valueNodes[nodeSize] = generateTreeSync(ctx, value);
+        nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(generateTreeSync(ctx, deferredKey[i]));
-      valueNodes.push(generateTreeSync(ctx, deferredValue[i]));
+      keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
     }
-    return [SerovalNodeType.Map, [keyNodes, valueNodes, current.size], id];
+    return [SerovalNodeType.Map, [keyNodes, valueNodes, len], id];
   }
   if (Array.isArray(current)) {
     const size = current.length;
@@ -642,7 +688,7 @@ export function generateTreeSync(
     }
     return [SerovalNodeType.Array, nodes, id];
   }
-  if (current instanceof AggregateError && ctx.features.has(Feature.AggregateError)) {
+  if (current instanceof AggregateError && ctx.features & Feature.AggregateError) {
     const options = getErrorOptions(current);
     const optionsNode = options
       ? serializePropertiesSync(ctx, options)
@@ -662,7 +708,7 @@ export function generateTreeSync(
     ];
   }
   if (isIterable(current)) {
-    assert(ctx.features.has(Feature.SymbolIterator), 'Unsupported type "Iterable"');
+    assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
     return [SerovalNodeType.Iterable, [
       // Parse options first before the items
@@ -681,39 +727,50 @@ export function generateTreeSync(
   throw new Error('Unsupported value');
 }
 
+export function parseSync(
+  ctx: ParserContext,
+  current: ServerValue,
+) {
+  const result = generateTreeSync(ctx, current);
+  return [result, createRef(ctx, current), result[0] === SerovalNodeType.Object] as const;
+}
+
 async function serializePropertiesAsync(
-  ctx: SerializationContext,
+  ctx: ParserContext,
   properties: Record<string, unknown>,
 ): Promise<SerovalDictionaryNode> {
-  const keyNodes: string[] = [];
-  const valueNodes: SerovalNode[] = [];
-  const deferredKeys: string[] = [];
-  const deferredValues: ServerValue[] = [];
   const keys = Object.keys(properties);
+  const size = keys.length;
+  const keyNodes = new Array<string>(size);
+  const valueNodes = new Array<SerovalNode>(size);
+  const deferredKeys = new Array<string>(size);
+  const deferredValues = new Array<ServerValue>(size);
   let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferredKeys.push(key);
-      deferredValues.push(properties[key] as ServerValue);
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key] as ServerValue;
       deferredSize++;
     } else {
-      keyNodes.push(key);
-      valueNodes.push(await generateTreeAsync(ctx, properties[key] as ServerValue));
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key] as ServerValue);
+      nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes.push(deferredKeys[i]);
-    valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, keys.length];
+  return [keyNodes, valueNodes, size];
 }
 
-export async function generateTreeAsync(
-  ctx: SerializationContext,
+async function generateTreeAsync(
+  ctx: ParserContext,
   current: AsyncServerValue,
 ): Promise<SerovalNode> {
   if (isPrimitive(current)) {
-    return [SerovalNodeType.Primitive, current];
+    return [SerovalNodeType.Primitive, serializePrimitive(current)];
   }
   const id = generateRef(ctx, current);
   if (Array.isArray(id)) {
@@ -724,7 +781,7 @@ export async function generateTreeAsync(
     return semiPrimitive;
   }
   if (isPromise(current)) {
-    assert(ctx.features.has(Feature.Promise), 'Unsupported type "Promise"');
+    assert(ctx.features & Feature.Promise, 'Unsupported type "Promise"');
     return current.then(async (value) => [
       SerovalNodeType.Promise,
       await generateTreeAsync(ctx, value),
@@ -732,43 +789,52 @@ export async function generateTreeAsync(
     ]);
   }
   if (constructorCheck<Set<AsyncServerValue>>(current, Set)) {
-    assert(ctx.features.has(Feature.Set), 'Unsupported type "Set"');
-    const nodes: SerovalNode[] = [];
-    const deferred: AsyncServerValue[] = [];
+    assert(ctx.features & Feature.Set, 'Unsupported type "Set"');
+    const len = current.size;
+    const nodes = new Array<SerovalNode>(len);
+    const deferred = new Array<AsyncServerValue>(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
     for (const item of current.keys()) {
+      // Iterables are lazy, so the evaluation must be deferred
       if (isIterable(item)) {
-        deferred.push(item);
+        deferred[deferredSize++] = item;
       } else {
-        nodes.push(await generateTreeAsync(ctx, item));
+        nodes[nodeSize++] = await generateTreeAsync(ctx, item);
       }
     }
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(await generateTreeAsync(ctx, deferred[i]));
+    // Parse deferred items
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
     }
     return [SerovalNodeType.Set, nodes, id];
   }
   if (constructorCheck<Map<AsyncServerValue, AsyncServerValue>>(current, Map)) {
-    assert(ctx.features.has(Feature.Map), 'Unsupported type "Map"');
-    const keyNodes: SerovalNode[] = [];
-    const valueNodes: SerovalNode[] = [];
-    const deferredKey: AsyncServerValue[] = [];
-    const deferredValue: AsyncServerValue[] = [];
+    assert(ctx.features & Feature.Map, 'Unsupported type "Map"');
+    const len = current.size;
+    const keyNodes = new Array<SerovalNode>(len);
+    const valueNodes = new Array<SerovalNode>(len);
+    const deferredKey = new Array<AsyncServerValue>(len);
+    const deferredValue = new Array<AsyncServerValue>(len);
     let deferredSize = 0;
+    let nodeSize = 0;
     for (const [key, value] of current.entries()) {
+      // Either key or value might be an iterable
       if (isIterable(key) || isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
+        deferredKey[deferredSize] = key;
+        deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes.push(await generateTreeAsync(ctx, key));
-        valueNodes.push(await generateTreeAsync(ctx, value));
+        keyNodes[nodeSize] = await generateTreeAsync(ctx, key);
+        valueNodes[nodeSize] = await generateTreeAsync(ctx, value);
+        nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(await generateTreeAsync(ctx, deferredKey[i]));
-      valueNodes.push(await generateTreeAsync(ctx, deferredValue[i]));
+      keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
     }
-    return [SerovalNodeType.Map, [keyNodes, valueNodes, current.size], id];
+    return [SerovalNodeType.Map, [keyNodes, valueNodes, len], id];
   }
   if (Array.isArray(current)) {
     const size = current.length;
@@ -791,7 +857,7 @@ export async function generateTreeAsync(
     }
     return [SerovalNodeType.Array, nodes, id];
   }
-  if (current instanceof AggregateError) {
+  if (current instanceof AggregateError && ctx.features & Feature.AggregateError) {
     const options = getErrorOptions(current);
     const optionsNode = options
       ? await serializePropertiesAsync(ctx, options)
@@ -811,7 +877,7 @@ export async function generateTreeAsync(
     ];
   }
   if (isIterable(current)) {
-    assert(ctx.features.has(Feature.SymbolIterator), 'Unsupported type "Iterable"');
+    assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
     return [SerovalNodeType.Iterable, [
       options
@@ -831,10 +897,17 @@ export async function generateTreeAsync(
   throw new Error('Unsupported value');
 }
 
+export async function parseAsync(
+  ctx: ParserContext,
+  current: AsyncServerValue,
+) {
+  const result = await generateTreeAsync(ctx, current);
+  return [result, createRef(ctx, current), result[0] === SerovalNodeType.Object] as const;
+}
+
 export function serializePrimitive(
-  ctx: SerializationContext,
   value: PrimitiveValue,
-): string {
+): string | number | null {
   // Shortened forms
   if (value === true) {
     return '!0';
@@ -846,11 +919,7 @@ export function serializePrimitive(
     return 'void 0';
   }
   if (value === null) {
-    return 'null';
-  }
-  if (typeof value === 'bigint') {
-    assert(ctx.features.has(Feature.BigInt), 'Unsupported type "BigInt"');
-    return `${value}n`;
+    return null;
   }
   if (typeof value === 'string') {
     return quote(value);
@@ -865,7 +934,7 @@ export function serializePrimitive(
   if (Object.is(value, -Infinity)) {
     return '-1/0';
   }
-  return String(value);
+  return value;
 }
 
 const IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
@@ -884,22 +953,18 @@ function serializeAssignments(
     ctx.stack = parentStack;
     const key = keys[i];
     const check = Number(key);
-    // Test if key is a valid number or JS identifier
-    // so that we don't have to serialize the key and wrap with brackets
     const parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
-    if (
-      check >= 0
-      || (Number.isNaN(check) && IDENTIFIER_CHECK.test(key))
-    ) {
-      if (!Number.isNaN(check)) {
-        createObjectComputedAssign(ctx, targetRef, key, refParam);
-      } else {
-        createObjectIdentifierAssign(ctx, targetRef, key, refParam);
-      }
-    } else {
-      createObjectComputedAssign(ctx, targetRef, quote(key), refParam);
-    }
+    // Test if key is a valid number or JS identifier
+    // so that we don't have to serialize the key and wrap with brackets
+    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    createObjectAssign(
+      ctx,
+      targetRef,
+      isIdentifier ? key : quote(key),
+      refParam,
+      !(isIdentifier && Number.isNaN(check)),
+    );
     ctx.assignments = parentAssignment;
   }
   ctx.stack.pop();
@@ -919,25 +984,19 @@ function serializeObject(
     const check = Number(key);
     // Test if key is a valid number or JS identifier
     // so that we don't have to serialize the key and wrap with brackets
-    if (
-      check >= 0
-      || (Number.isNaN(check) && IDENTIFIER_CHECK.test(key))
-    ) {
-      if (isReferenceInStack(ctx, val)) {
-        const refParam = getRefParam(ctx, val[1]);
-        if (!Number.isNaN(check)) {
-          createObjectComputedAssign(ctx, sourceID, key, refParam);
-        } else {
-          createObjectIdentifierAssign(ctx, sourceID, key, refParam);
-        }
-      } else {
-        result += `${key}:${serializeTree(ctx, val)},`;
-      }
-    } else if (isReferenceInStack(ctx, val)) {
+    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    const validKey = isIdentifier ? key : quote(key);
+    if (isReferenceInStack(ctx, val)) {
       const refParam = getRefParam(ctx, val[1]);
-      createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
+      createObjectAssign(
+        ctx,
+        sourceID,
+        validKey,
+        refParam,
+        !(isIdentifier && Number.isNaN(check)),
+      );
     } else {
-      result += `${quote(key)}:${serializeTree(ctx, val)},`;
+      result += `${validKey}:${serializeTree(ctx, val)},`;
     }
   }
   ctx.stack.pop();
@@ -950,7 +1009,7 @@ export function serializeTree(
 ): string {
   switch (type) {
     case SerovalNodeType.Primitive:
-      return serializePrimitive(ctx, value);
+      return String(value);
     case SerovalNodeType.Reference:
       return getRefParam(ctx, value);
     case SerovalNodeType.Promise: {
@@ -971,19 +1030,17 @@ export function serializeTree(
       }
       return assignRef(ctx, id, serialized);
     }
+    case SerovalNodeType.BigInt:
+      return value;
     case SerovalNodeType.Date:
-      return assignRef(ctx, id, `new Date("${value.toISOString()}")`);
+      return assignRef(ctx, id, `new Date("${value}")`);
     case SerovalNodeType.RegExp:
-      return assignRef(ctx, id, String(value));
+      return assignRef(ctx, id, value);
+    case SerovalNodeType.BigIntTypedArray:
     case SerovalNodeType.TypedArray: {
-      // BigInt typed arrays are broken for toString()
-      let values = '';
-      for (let i = 0, len = value[1].length; i < len; i++) {
-        values += `${serializePrimitive(ctx, value[1][i])},`;
-      }
-      let args = values ? `[${values.substring(0, values.length - 1)}]` : '[]';
-      if (value[1].byteOffset !== 0) {
-        args += `,${value[1].byteOffset}`;
+      let args = `[${value[1]}]`;
+      if (value[2] !== 0) {
+        args += `,${value[2]}`;
       }
       return assignRef(ctx, id, `new ${value[0]}(${args})`);
     }
@@ -1072,7 +1129,7 @@ export function serializeTree(
       for (let i = 0; i < size; i++) {
         const item = value[i];
         // Check if index is a hole
-        if (i in value) {
+        if (item) {
           // Check if item is a parent
           if (isReferenceInStack(ctx, item)) {
             createArrayAssign(ctx, id, i, getRefParam(ctx, item[1]));
@@ -1100,7 +1157,7 @@ export function serializeTree(
       // either through class or custom properties
       // Make sure to assign extra properties
       if (value[1]) {
-        if (ctx.features.has(Feature.ObjectAssign)) {
+        if (ctx.features & Feature.ObjectAssign) {
           const options = serializeObject(ctx, id, value[1]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
@@ -1117,7 +1174,7 @@ export function serializeTree(
     case SerovalNodeType.Error: {
       let serialized = `new ${value[0]}(${quote(value[1])})`;
       if (value[2]) {
-        if (ctx.features.has(Feature.ObjectAssign)) {
+        if (ctx.features & Feature.ObjectAssign) {
           const options = serializeObject(ctx, id, value[2]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
@@ -1137,20 +1194,20 @@ export function serializeTree(
       const values = serializeTree(ctx, value[1]);
       ctx.stack = parent;
       let serialized: string;
-      if (ctx.features.has(Feature.ArrayPrototypeValues)) {
+      if (ctx.features & Feature.ArrayPrototypeValues) {
         serialized = `${values}.values()`;
       } else {
         serialized = `${values}[Symbol.iterator]()`;
       }
-      if (ctx.features.has(Feature.ArrowFunction)) {
+      if (ctx.features & Feature.ArrowFunction) {
         serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-      } else if (ctx.features.has(Feature.MethodShorthand)) {
+      } else if (ctx.features & Feature.MethodShorthand) {
         serialized = `{[Symbol.iterator](){return ${serialized}}}`;
       } else {
         serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
       }
       if (value[0]) {
-        if (ctx.features.has(Feature.ObjectAssign)) {
+        if (ctx.features & Feature.ObjectAssign) {
           const options = serializeObject(ctx, id, value[0]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
@@ -1166,7 +1223,7 @@ export function serializeTree(
     }
     case SerovalNodeType.NullConstructor: {
       let serialized = 'Object.create(null)';
-      if (ctx.features.has(Feature.ObjectAssign)) {
+      if (ctx.features & Feature.ObjectAssign) {
         const fields = serializeObject(ctx, id, value);
         if (fields !== '{}') {
           serialized = `Object.assign(${serialized},${fields})`;