seroval 0.4.0-alpha.0 → 0.4.0-alpha.2

package/src/tree.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
 /* eslint-disable guard-for-in */
 /* eslint-disable @typescript-eslint/no-for-in-array */
 /* eslint-disable no-await-in-loop */
@@ -481,53 +482,53 @@ function generateSemiPrimitiveValue(
     return [SerovalNodeType.RegExp, current, id];
   }
   if (constructorCheck<Int8Array>(current, Int8Array)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Int8Array"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Int8Array"');
     return [SerovalNodeType.TypedArray, ['Int8Array', current], id];
   }
   if (constructorCheck<Int16Array>(current, Int16Array)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Int16Array"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Int16Array"');
     return [SerovalNodeType.TypedArray, ['Int16Array', current], id];
   }
   if (constructorCheck<Int32Array>(current, Int32Array)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Int32Array"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Int32Array"');
     return [SerovalNodeType.TypedArray, ['Int32Array', current], id];
   }
   if (constructorCheck<Uint8Array>(current, Uint8Array)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Uint8Array"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Uint8Array"');
     return [SerovalNodeType.TypedArray, ['Uint8Array', current], id];
   }
   if (constructorCheck<Uint16Array>(current, Uint16Array)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Uint16Array"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Uint16Array"');
     return [SerovalNodeType.TypedArray, ['Uint16Array', current], id];
   }
   if (constructorCheck<Uint32Array>(current, Uint32Array)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Uint32Array"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Uint32Array"');
     return [SerovalNodeType.TypedArray, ['Uint32Array', current], id];
   }
   if (constructorCheck<Uint8ClampedArray>(current, Uint8ClampedArray)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Uint8ClampedArray"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Uint8ClampedArray"');
     return [SerovalNodeType.TypedArray, ['Uint8ClampedArray', current], id];
   }
   if (constructorCheck<Float32Array>(current, Float32Array)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Float32Array"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Float32Array"');
     return [SerovalNodeType.TypedArray, ['Float32Array', current], id];
   }
   if (constructorCheck<Float64Array>(current, Float64Array)) {
-    assert(ctx.features.has('typed-arrays'), 'Unsupported value type "Float64Array"');
+    assert(ctx.features.has(Feature.TypedArray), 'Unsupported value type "Float64Array"');
     return [SerovalNodeType.TypedArray, ['Float64Array', current], id];
   }
   if (constructorCheck<BigInt64Array>(current, BigInt64Array)) {
     assert(
-      ctx.features.has('typed-arrays')
-      && ctx.features.has('bigint'),
+      ctx.features.has(Feature.TypedArray)
+      && ctx.features.has(Feature.BigInt),
       'Unsupported value type "BigInt64Array"',
     );
     return [SerovalNodeType.TypedArray, ['BigInt64Array', current], id];
   }
   if (constructorCheck<BigUint64Array>(current, BigUint64Array)) {
     assert(
-      ctx.features.has('typed-arrays')
-      && ctx.features.has('bigint'),
+      ctx.features.has(Feature.TypedArray)
+      && ctx.features.has(Feature.BigInt),
       'Unsupported value type "BigUint64Array"',
     );
     return [SerovalNodeType.TypedArray, ['BigUint64Array', current], id];
@@ -535,35 +536,37 @@ function generateSemiPrimitiveValue(
   return undefined;
 }
 
+function serializePropertiesSync(
+  ctx: SerializationContext,
+  properties: Record<string, unknown>,
+): SerovalDictionaryNode {
+  const keyNodes: string[] = [];
+  const valueNodes: SerovalNode[] = [];
+  const deferredKeys: string[] = [];
+  const deferredValues: ServerValue[] = [];
+  const keys = Object.keys(properties);
+  let deferredSize = 0;
+  for (const key of keys) {
+    if (isIterable(properties[key])) {
+      deferredKeys.push(key);
+      deferredValues.push(properties[key] as ServerValue);
+      deferredSize++;
+    } else {
+      keyNodes.push(key);
+      valueNodes.push(generateTreeSync(ctx, properties[key] as ServerValue));
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes.push(deferredKeys[i]);
+    valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
+  }
+  return [keyNodes, valueNodes, keys.length];
+}
+
 export function generateTreeSync(
   ctx: SerializationContext,
   current: ServerValue,
 ): SerovalNode {
-  function serializeProperties(
-    properties: Record<string, unknown>,
-  ): SerovalDictionaryNode {
-    const keyNodes: string[] = [];
-    const valueNodes: SerovalNode[] = [];
-    const deferredKeys: string[] = [];
-    const deferredValues: ServerValue[] = [];
-    const keys = Object.keys(properties);
-    let deferredSize = 0;
-    for (const key of keys) {
-      if (isIterable(properties[key])) {
-        deferredKeys.push(key);
-        deferredValues.push(properties[key] as ServerValue);
-        deferredSize++;
-      } else {
-        keyNodes.push(key);
-        valueNodes.push(generateTreeSync(ctx, properties[key] as ServerValue));
-      }
-    }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(deferredKeys[i]);
-      valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
-    }
-    return [keyNodes, valueNodes, keys.length];
-  }
   if (isPrimitive(current)) {
     return [SerovalNodeType.Primitive, current];
   }
@@ -578,7 +581,7 @@ export function generateTreeSync(
     return semiPrimitive;
   }
   if (constructorCheck<Set<ServerValue>>(current, Set)) {
-    assert(ctx.features.has('set'), 'Unsupported type "Set"');
+    assert(ctx.features.has(Feature.Set), 'Unsupported type "Set"');
     const nodes: SerovalNode[] = [];
     const deferred: ServerValue[] = [];
     for (const item of current.keys()) {
@@ -596,7 +599,7 @@ export function generateTreeSync(
     return [SerovalNodeType.Set, nodes, id];
   }
   if (constructorCheck<Map<ServerValue, ServerValue>>(current, Map)) {
-    assert(ctx.features.has('map'), 'Unsupported type "Map"');
+    assert(ctx.features.has(Feature.Map), 'Unsupported type "Map"');
     const keyNodes: SerovalNode[] = [];
     const valueNodes: SerovalNode[] = [];
     const deferredKey: ServerValue[] = [];
@@ -639,10 +642,10 @@ export function generateTreeSync(
     }
     return [SerovalNodeType.Array, nodes, id];
   }
-  if (current instanceof AggregateError && ctx.features.has('aggregate-error')) {
+  if (current instanceof AggregateError && ctx.features.has(Feature.AggregateError)) {
     const options = getErrorOptions(current);
     const optionsNode = options
-      ? serializeProperties(options)
+      ? serializePropertiesSync(ctx, options)
       : undefined;
     const errorsNode = generateTreeSync(ctx, current.errors as ServerValue);
     return [SerovalNodeType.AggregateError, [current.message, optionsNode, errorsNode], id];
@@ -650,7 +653,7 @@ export function generateTreeSync(
   if (current instanceof Error) {
     const options = getErrorOptions(current);
     const optionsNode = options
-      ? serializeProperties(options)
+      ? serializePropertiesSync(ctx, options)
       : undefined;
     return [
       SerovalNodeType.Error,
@@ -659,11 +662,11 @@ export function generateTreeSync(
     ];
   }
   if (isIterable(current)) {
-    assert(ctx.features.has('symbol-iterator'), 'Unsupported type "Iterable"');
+    assert(ctx.features.has(Feature.SymbolIterator), 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
     return [SerovalNodeType.Iterable, [
       // Parse options first before the items
-      options ? serializeProperties(options) : undefined,
+      options ? serializePropertiesSync(ctx, options) : undefined,
       generateTreeSync(ctx, Array.from(current)),
     ], id];
   }
@@ -671,42 +674,44 @@ export function generateTreeSync(
   if (current.constructor === Object || empty) {
     return [
       empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      serializeProperties(current as Record<string, unknown>),
+      serializePropertiesSync(ctx, current as Record<string, unknown>),
       id,
     ];
   }
   throw new Error('Unsupported value');
 }
 
+async function serializePropertiesAsync(
+  ctx: SerializationContext,
+  properties: Record<string, unknown>,
+): Promise<SerovalDictionaryNode> {
+  const keyNodes: string[] = [];
+  const valueNodes: SerovalNode[] = [];
+  const deferredKeys: string[] = [];
+  const deferredValues: ServerValue[] = [];
+  const keys = Object.keys(properties);
+  let deferredSize = 0;
+  for (const key of keys) {
+    if (isIterable(properties[key])) {
+      deferredKeys.push(key);
+      deferredValues.push(properties[key] as ServerValue);
+      deferredSize++;
+    } else {
+      keyNodes.push(key);
+      valueNodes.push(await generateTreeAsync(ctx, properties[key] as ServerValue));
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes.push(deferredKeys[i]);
+    valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
+  }
+  return [keyNodes, valueNodes, keys.length];
+}
+
 export async function generateTreeAsync(
   ctx: SerializationContext,
   current: AsyncServerValue,
 ): Promise<SerovalNode> {
-  async function serializeProperties(
-    properties: Record<string, unknown>,
-  ): Promise<SerovalDictionaryNode> {
-    const keyNodes: string[] = [];
-    const valueNodes: SerovalNode[] = [];
-    const deferredKeys: string[] = [];
-    const deferredValues: ServerValue[] = [];
-    const keys = Object.keys(properties);
-    let deferredSize = 0;
-    for (const key of keys) {
-      if (isIterable(properties[key])) {
-        deferredKeys.push(key);
-        deferredValues.push(properties[key] as ServerValue);
-        deferredSize++;
-      } else {
-        keyNodes.push(key);
-        valueNodes.push(await generateTreeAsync(ctx, properties[key] as ServerValue));
-      }
-    }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(deferredKeys[i]);
-      valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
-    }
-    return [keyNodes, valueNodes, keys.length];
-  }
   if (isPrimitive(current)) {
     return [SerovalNodeType.Primitive, current];
   }
@@ -719,7 +724,7 @@ export async function generateTreeAsync(
     return semiPrimitive;
   }
   if (isPromise(current)) {
-    assert(ctx.features.has('promise'), 'Unsupported type "Promise"');
+    assert(ctx.features.has(Feature.Promise), 'Unsupported type "Promise"');
     return current.then(async (value) => [
       SerovalNodeType.Promise,
       await generateTreeAsync(ctx, value),
@@ -727,7 +732,7 @@ export async function generateTreeAsync(
     ]);
   }
   if (constructorCheck<Set<AsyncServerValue>>(current, Set)) {
-    assert(ctx.features.has('set'), 'Unsupported type "Set"');
+    assert(ctx.features.has(Feature.Set), 'Unsupported type "Set"');
     const nodes: SerovalNode[] = [];
     const deferred: AsyncServerValue[] = [];
     for (const item of current.keys()) {
@@ -743,7 +748,7 @@ export async function generateTreeAsync(
     return [SerovalNodeType.Set, nodes, id];
   }
   if (constructorCheck<Map<AsyncServerValue, AsyncServerValue>>(current, Map)) {
-    assert(ctx.features.has('map'), 'Unsupported type "Map"');
+    assert(ctx.features.has(Feature.Map), 'Unsupported type "Map"');
     const keyNodes: SerovalNode[] = [];
     const valueNodes: SerovalNode[] = [];
     const deferredKey: AsyncServerValue[] = [];
@@ -789,7 +794,7 @@ export async function generateTreeAsync(
   if (current instanceof AggregateError) {
     const options = getErrorOptions(current);
     const optionsNode = options
-      ? await serializeProperties(options)
+      ? await serializePropertiesAsync(ctx, options)
       : undefined;
     const errorsNode = await generateTreeAsync(ctx, current.errors as ServerValue);
     return [SerovalNodeType.AggregateError, [current.message, optionsNode, errorsNode], id];
@@ -797,7 +802,7 @@ export async function generateTreeAsync(
   if (current instanceof Error) {
     const options = getErrorOptions(current);
     const optionsNode = options
-      ? await serializeProperties(options)
+      ? await serializePropertiesAsync(ctx, options)
       : undefined;
     return [
       SerovalNodeType.Error,
@@ -806,11 +811,11 @@ export async function generateTreeAsync(
     ];
   }
   if (isIterable(current)) {
-    assert(ctx.features.has('symbol-iterator'), 'Unsupported type "Iterable"');
+    assert(ctx.features.has(Feature.SymbolIterator), 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
     return [SerovalNodeType.Iterable, [
       options
-        ? await serializeProperties(options)
+        ? await serializePropertiesAsync(ctx, options)
         : undefined,
       await generateTreeAsync(ctx, Array.from(current)),
     ], id];
@@ -819,7 +824,7 @@ export async function generateTreeAsync(
   if (current.constructor === Object || empty) {
     return [
       empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      await serializeProperties(current as Record<string, unknown>),
+      await serializePropertiesAsync(ctx, current as Record<string, unknown>),
       id,
     ];
   }
@@ -844,7 +849,7 @@ export function serializePrimitive(
     return 'null';
   }
   if (typeof value === 'bigint') {
-    assert(ctx.features.has('bigint'), 'Unsupported type "BigInt"');
+    assert(ctx.features.has(Feature.BigInt), 'Unsupported type "BigInt"');
     return `${value}n`;
   }
   if (typeof value === 'string') {
@@ -863,80 +868,86 @@ export function serializePrimitive(
   return String(value);
 }
 
-export function serializeTree(
+const IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
+
+function serializeAssignments(
   ctx: SerializationContext,
-  [type, value, id]: SerovalNode,
-): string {
-  function serializeAssignments(
-    targetRef: number,
-    [keys, values, size]: SerovalDictionaryNode,
-  ) {
-    ctx.stack.push(targetRef);
-    const mainAssignments: Assignment[] = [];
-    for (let i = 0; i < size; i++) {
-      const parentStack = ctx.stack;
-      ctx.stack = [];
-      const refParam = serializeTree(ctx, values[i]);
-      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) && /^([$A-Z_][0-9A-Z_$]*)$/i.test(key))
-      ) {
-        if (!Number.isNaN(check)) {
-          createObjectComputedAssign(ctx, targetRef, key, refParam);
-        } else {
-          createObjectIdentifierAssign(ctx, targetRef, key, refParam);
-        }
+  targetRef: number,
+  [keys, values, size]: SerovalDictionaryNode,
+) {
+  ctx.stack.push(targetRef);
+  const mainAssignments: Assignment[] = [];
+  for (let i = 0; i < size; i++) {
+    const parentStack = ctx.stack;
+    ctx.stack = [];
+    const refParam = serializeTree(ctx, values[i]);
+    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 {
-        createObjectComputedAssign(ctx, targetRef, quote(key), refParam);
+        createObjectIdentifierAssign(ctx, targetRef, key, refParam);
       }
-      ctx.assignments = parentAssignment;
+    } else {
+      createObjectComputedAssign(ctx, targetRef, quote(key), refParam);
     }
-    ctx.stack.pop();
-    return resolveAssignments(mainAssignments);
+    ctx.assignments = parentAssignment;
   }
-  function serializeObject(
-    sourceID: number,
-    [keys, values, size]: SerovalDictionaryNode,
-  ) {
-    let result = '';
-    ctx.stack.push(sourceID);
-    for (let i = 0; i < size; i++) {
-      const key = keys[i];
-      const val = values[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
-      if (
-        check >= 0
-        || (Number.isNaN(check) && /^([$A-Z_][0-9A-Z_$]*)$/i.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);
-          }
+  ctx.stack.pop();
+  return resolveAssignments(mainAssignments);
+}
+
+function serializeObject(
+  ctx: SerializationContext,
+  sourceID: number,
+  [keys, values, size]: SerovalDictionaryNode,
+) {
+  let result = '';
+  ctx.stack.push(sourceID);
+  for (let i = 0; i < size; i++) {
+    const key = keys[i];
+    const val = values[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
+    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 {
-          result += `${key}:${serializeTree(ctx, val)},`;
+          createObjectIdentifierAssign(ctx, sourceID, key, refParam);
         }
-      } else if (isReferenceInStack(ctx, val)) {
-        const refParam = getRefParam(ctx, val[1]);
-        createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
       } else {
-        result += `${quote(key)}:${serializeTree(ctx, val)},`;
+        result += `${key}:${serializeTree(ctx, val)},`;
       }
+    } else if (isReferenceInStack(ctx, val)) {
+      const refParam = getRefParam(ctx, val[1]);
+      createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
+    } else {
+      result += `${quote(key)}:${serializeTree(ctx, val)},`;
     }
-    ctx.stack.pop();
-    return `{${result.substring(0, result.length - 1)}}`;
   }
+  ctx.stack.pop();
+  return `{${result.substring(0, result.length - 1)}}`;
+}
+
+export function serializeTree(
+  ctx: SerializationContext,
+  [type, value, id]: SerovalNode,
+): string {
   switch (type) {
     case SerovalNodeType.Primitive:
       return serializePrimitive(ctx, value);
@@ -1089,12 +1100,12 @@ export function serializeTree(
       // either through class or custom properties
       // Make sure to assign extra properties
       if (value[1]) {
-        if (ctx.features.has('object-assign')) {
-          const options = serializeObject(id, value[1]);
+        if (ctx.features.has(Feature.ObjectAssign)) {
+          const options = serializeObject(ctx, id, value[1]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
           markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[1]);
+          const assignments = serializeAssignments(ctx, id, value[1]);
           if (assignments) {
             const ref = getRefParam(ctx, id);
             return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
@@ -1106,12 +1117,12 @@ export function serializeTree(
     case SerovalNodeType.Error: {
       let serialized = `new ${value[0]}(${quote(value[1])})`;
       if (value[2]) {
-        if (ctx.features.has('object-assign')) {
-          const options = serializeObject(id, value[2]);
+        if (ctx.features.has(Feature.ObjectAssign)) {
+          const options = serializeObject(ctx, id, value[2]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
           markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[2]);
+          const assignments = serializeAssignments(ctx, id, value[2]);
           if (assignments) {
             const ref = getRefParam(ctx, id);
             return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
@@ -1126,25 +1137,25 @@ export function serializeTree(
       const values = serializeTree(ctx, value[1]);
       ctx.stack = parent;
       let serialized: string;
-      if (ctx.features.has('array-values')) {
+      if (ctx.features.has(Feature.ArrayPrototypeValues)) {
         serialized = `${values}.values()`;
       } else {
         serialized = `${values}[Symbol.iterator]()`;
       }
-      if (ctx.features.has('arrow-function')) {
+      if (ctx.features.has(Feature.ArrowFunction)) {
         serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-      } else if (ctx.features.has('method-shorthand')) {
+      } else if (ctx.features.has(Feature.MethodShorthand)) {
         serialized = `{[Symbol.iterator](){return ${serialized}}}`;
       } else {
         serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
       }
       if (value[0]) {
-        if (ctx.features.has('object-assign')) {
-          const options = serializeObject(id, value[0]);
+        if (ctx.features.has(Feature.ObjectAssign)) {
+          const options = serializeObject(ctx, id, value[0]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
           markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[0]);
+          const assignments = serializeAssignments(ctx, id, value[0]);
           if (assignments) {
             const ref = getRefParam(ctx, id);
             return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
@@ -1155,14 +1166,14 @@ export function serializeTree(
     }
     case SerovalNodeType.NullConstructor: {
       let serialized = 'Object.create(null)';
-      if (ctx.features.has('object-assign')) {
-        const fields = serializeObject(id, value);
+      if (ctx.features.has(Feature.ObjectAssign)) {
+        const fields = serializeObject(ctx, id, value);
         if (fields !== '{}') {
           serialized = `Object.assign(${serialized},${fields})`;
         }
       } else {
         markRef(ctx, id);
-        const assignments = serializeAssignments(id, value);
+        const assignments = serializeAssignments(ctx, id, value);
         if (assignments) {
           const ref = getRefParam(ctx, id);
           return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
@@ -1171,7 +1182,7 @@ export function serializeTree(
       return assignRef(ctx, id, serialized);
     }
     case SerovalNodeType.Object:
-      return assignRef(ctx, id, serializeObject(id, value));
+      return assignRef(ctx, id, serializeObject(ctx, id, value));
     default:
       throw new Error('Unsupported type');
   }