seroval 0.4.0-alpha.8 → 0.4.0

package/src/tree/serialize.ts

@@ -7,17 +7,31 @@ import {
   markRef,
 } from '../context';
 import quote from '../quote';
-import { isReferenceInStack } from './shared';
-import { SerovalDictionaryNode, SerovalNode, SerovalNodeType } from './types';
+import {
+  SerovalAggregateErrorNode,
+  SerovalArrayNode,
+  SerovalBigIntTypedArrayNode,
+  SerovalErrorNode,
+  SerovalIterableNode,
+  SerovalMapNode,
+  SerovalNode,
+  SerovalNodeType,
+  SerovalNullConstructorNode,
+  SerovalObjectRecordNode,
+  SerovalPromiseNode,
+  SerovalReferenceNode,
+  SerovalSetNode,
+  SerovalTypedArrayNode,
+} from './types';
 
 function getAssignmentExpression(assignment: Assignment): string {
-  switch (assignment.type) {
+  switch (assignment.t) {
     case 'index':
-      return `${assignment.source}=${assignment.value}`;
+      return assignment.s + '=' + assignment.v;
     case 'map':
-      return `${assignment.source}.set(${assignment.key},${assignment.value})`;
+      return assignment.s + '.set(' + assignment.k + ',' + assignment.v + ')';
     case 'set':
-      return `${assignment.source}.add(${assignment.value})`;
+      return assignment.s + '.add(' + assignment.v + ')';
     default:
       return '';
   }
@@ -27,31 +41,34 @@ function mergeAssignments(assignments: Assignment[]) {
   const newAssignments = [];
   let current = assignments[0];
   let prev = current;
+  let item: Assignment;
   for (let i = 1, len = assignments.length; i < len; i++) {
-    const item = assignments[i];
-    if (item.type === prev.type) {
-      if (item.type === 'index' && item.value === prev.value) {
+    item = assignments[i];
+    if (item.t === prev.t) {
+      if (item.t === 'index' && item.v === prev.v) {
         // Merge if the right-hand value is the same
         // saves at least 2 chars
         current = {
-          type: 'index',
-          source: item.source,
-          value: getAssignmentExpression(current),
+          t: 'index',
+          s: item.s,
+          k: undefined,
+          v: getAssignmentExpression(current),
         };
-      } else if (item.type === 'map' && item.source === prev.source) {
+      } else if (item.t === 'map' && item.s === prev.s) {
         // Maps has chaining methods, merge if source is the same
         current = {
-          type: 'map',
-          source: getAssignmentExpression(current),
-          key: item.key,
-          value: item.value,
+          t: 'map',
+          s: getAssignmentExpression(current),
+          k: item.k,
+          v: item.v,
         };
-      } else if (item.type === 'set' && item.source === prev.source) {
+      } else if (item.t === 'set' && item.s === prev.s) {
         // Sets has chaining methods too
         current = {
-          type: 'set',
-          source: getAssignmentExpression(current),
-          value: item.value,
+          t: 'set',
+          s: getAssignmentExpression(current),
+          k: undefined,
+          v: item.v,
         };
       } else {
         // Different assignment, push current
@@ -75,7 +92,7 @@ function resolveAssignments(assignments: Assignment[]) {
     let result = '';
     const merged = mergeAssignments(assignments);
     for (let i = 0, len = merged.length; i < len; i++) {
-      result += `${getAssignmentExpression(merged[i])},`;
+      result += getAssignmentExpression(merged[i]) + ',';
     }
     return result;
   }
@@ -91,16 +108,6 @@ export function resolvePatches(ctx: SerializationContext) {
  * This is different from the assignments array as this one
  * signifies creation rather than mutation
  */
-function assignRef(
-  ctx: SerializationContext,
-  index: number,
-  value: string,
-) {
-  if (ctx.markedRefs[index]) {
-    return `${getRefParam(ctx, index)}=${value}`;
-  }
-  return value;
-}
 
 function createAssignment(
   ctx: SerializationContext,
@@ -108,9 +115,10 @@ function createAssignment(
   value: string,
 ) {
   ctx.assignments.push({
-    type: 'index',
-    source,
-    value,
+    t: 'index',
+    s: source,
+    k: undefined,
+    v: value,
   });
 }
 
@@ -121,9 +129,10 @@ function createSetAdd(
 ) {
   markRef(ctx, ref);
   ctx.assignments.push({
-    type: 'set',
-    source: getRefParam(ctx, ref),
-    value,
+    t: 'set',
+    s: getRefParam(ctx, ref),
+    k: undefined,
+    v: value,
   });
 }
 
@@ -135,10 +144,10 @@ function createMapSet(
 ) {
   markRef(ctx, ref);
   ctx.assignments.push({
-    type: 'map',
-    source: getRefParam(ctx, ref),
-    key,
-    value,
+    t: 'map',
+    s: getRefParam(ctx, ref),
+    k: key,
+    v: value,
   });
 }
 
@@ -149,7 +158,7 @@ function createArrayAssign(
   value: string,
 ) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
+  createAssignment(ctx, getRefParam(ctx, ref) + '[' + index.toString() + ']', value);
 }
 
 function createObjectAssign(
@@ -159,183 +168,281 @@ function createObjectAssign(
   value: string,
 ) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
+  createAssignment(ctx, getRefParam(ctx, ref) + '.' + key, value);
+}
+
+function assignRef(
+  ctx: SerializationContext,
+  index: number,
+  value: string,
+) {
+  if (ctx.markedRefs.has(index)) {
+    return getRefParam(ctx, index) + '=' + value;
+  }
+  return value;
+}
+
+function isReferenceInStack(
+  ctx: SerializationContext,
+  node: SerovalNode,
+): node is SerovalReferenceNode {
+  return node.t === SerovalNodeType.Reference && ctx.stack.includes(node.i);
 }
 
 const IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
 
-function serializeAssignments(
+function serializeNodeList(
   ctx: SerializationContext,
-  targetRef: number,
-  [keys, values, size]: SerovalDictionaryNode,
+  node: SerovalArrayNode | SerovalIterableNode,
 ) {
-  ctx.stack.push(targetRef);
-  const mainAssignments: Assignment[] = [];
+  // This is different than Map and Set
+  // because we also need to serialize
+  // the holes of the Array
+  const size = node.a.length;
+  let values = '';
+  let item: SerovalNode;
+  let isHoley = false;
   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);
-    const parentAssignment = ctx.assignments;
-    ctx.assignments = mainAssignments;
-    // 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);
-    if (isIdentifier && Number.isNaN(check)) {
-      createObjectAssign(ctx, targetRef, key, refParam);
+    if (i !== 0) {
+      // Add an empty item
+      values += ',';
+    }
+    item = node.a[i];
+    // Check if index is a hole
+    if (item) {
+      // Check if item is a parent
+      if (isReferenceInStack(ctx, item)) {
+        createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
+        isHoley = true;
+      } else {
+        values += serializeTree(ctx, item);
+        isHoley = false;
+      }
     } else {
-      createArrayAssign(ctx, targetRef, isIdentifier ? key : quote(key), refParam);
+      isHoley = true;
     }
-    ctx.assignments = parentAssignment;
   }
+  if (isHoley) {
+    values += ',';
+  }
+  return '[' + values + ']';
+}
+
+function serializeArray(
+  ctx: SerializationContext,
+  node: SerovalArrayNode,
+) {
+  ctx.stack.push(node.i);
+  const result = serializeNodeList(ctx, node);
   ctx.stack.pop();
-  return resolveAssignments(mainAssignments);
+  return assignRef(ctx, node.i, result);
 }
 
 function serializeObject(
   ctx: SerializationContext,
   sourceID: number,
-  [keys, values, size]: SerovalDictionaryNode,
+  node: SerovalObjectRecordNode,
 ) {
-  if (size === 0) {
+  if (node.s === 0) {
     return '{}';
   }
   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);
+  let key: string;
+  let val: SerovalNode;
+  let check: number;
+  let isIdentifier: boolean;
+  let refParam: string;
+  let hasPrev = false;
+  for (let i = 0; i < node.s; i++) {
+    key = node.k[i];
+    val = node.v[i];
+    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 isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
     if (isReferenceInStack(ctx, val)) {
-      const refParam = getRefParam(ctx, val[1]);
+      refParam = getRefParam(ctx, val.i);
       if (isIdentifier && Number.isNaN(check)) {
         createObjectAssign(ctx, sourceID, key, refParam);
       } else {
         createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
       }
     } else {
-      result += `${isIdentifier ? key : quote(key)}:${serializeTree(ctx, val)},`;
+      if (hasPrev) {
+        result += ',';
+      }
+      result += isIdentifier ? key : quote(key);
+      result += ':' + serializeTree(ctx, val);
+      hasPrev = true;
     }
   }
   ctx.stack.pop();
-  return `{${result.substring(0, result.length - 1)}}`;
+  return '{' + result + '}';
 }
 
-function serializePromise(
+function serializeWithObjectAssign(
   ctx: SerializationContext,
-  value: SerovalNode,
+  value: SerovalObjectRecordNode,
   id: number,
+  serialized: string,
 ) {
-  let serialized: string;
-  // Check if resolved value is a parent expression
-  if (isReferenceInStack(ctx, value)) {
-    // A Promise trick, reference the value
-    // inside the `then` expression so that
-    // the Promise evaluates after the parent
-    // has initialized
-    serialized = `Promise.resolve().then(()=>${getRefParam(ctx, value[1])})`;
-  } else {
-    ctx.stack.push(id);
-    const result = serializeTree(ctx, value);
-    ctx.stack.pop();
-    // just inline the value/reference here
-    serialized = `Promise.resolve(${result})`;
+  const fields = serializeObject(ctx, id, value);
+  if (fields !== '{}') {
+    return 'Object.assign(' + serialized + ',' + fields + ')';
   }
-  return assignRef(ctx, id, serialized);
+  return serialized;
 }
 
-function serializeTypedArray(
+function serializeAssignments(
   ctx: SerializationContext,
-  constructor: string,
+  sourceID: number,
+  node: SerovalObjectRecordNode,
+) {
+  ctx.stack.push(sourceID);
+  const mainAssignments: Assignment[] = [];
+  let parentStack: number[];
+  let refParam: string;
+  let key: string;
+  let check: number;
+  let parentAssignment: Assignment[];
+  let isIdentifier: boolean;
+  for (let i = 0; i < node.s; i++) {
+    parentStack = ctx.stack;
+    ctx.stack = [];
+    refParam = serializeTree(ctx, node.v[i]);
+    ctx.stack = parentStack;
+    key = node.k[i];
+    check = Number(key);
+    parentAssignment = ctx.assignments;
+    ctx.assignments = mainAssignments;
+    // Test if key is a valid number or JS identifier
+    // so that we don't have to serialize the key and wrap with brackets
+    isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    if (isIdentifier && Number.isNaN(check)) {
+      createObjectAssign(ctx, sourceID, key, refParam);
+    } else {
+      createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+    }
+    ctx.assignments = parentAssignment;
+  }
+  ctx.stack.pop();
+  return resolveAssignments(mainAssignments);
+}
+
+function serializeDictionary(
+  ctx: SerializationContext,
+  i: number,
+  d: SerovalObjectRecordNode | undefined,
   init: string,
-  byteOffset: number,
-  id: number,
 ) {
-  let args = `[${init}]`;
-  if (byteOffset !== 0) {
-    args += `,${byteOffset}`;
+  if (d) {
+    if (ctx.features & Feature.ObjectAssign) {
+      init = serializeWithObjectAssign(ctx, d, i, init);
+    } else {
+      markRef(ctx, i);
+      const assignments = serializeAssignments(ctx, i, d);
+      if (assignments) {
+        const ref = getRefParam(ctx, i);
+        return '(' + assignRef(ctx, i, init) + ',' + assignments + ref + ')';
+      }
+    }
   }
-  return assignRef(ctx, id, `new ${constructor}(${args})`);
+  return assignRef(ctx, i, init);
+}
+
+function serializeNullConstructor(
+  ctx: SerializationContext,
+  node: SerovalNullConstructorNode,
+) {
+  return serializeDictionary(ctx, node.i, node.d, 'Object.create(null)');
 }
 
 function serializeSet(
   ctx: SerializationContext,
-  value: SerovalNode[],
-  id: number,
+  node: SerovalSetNode,
 ) {
   let serialized = 'new Set';
-  const size = value.length;
+  const size = node.a.length;
   if (size) {
     let result = '';
-    ctx.stack.push(id);
+    ctx.stack.push(node.i);
+    let item: SerovalNode;
+    let hasPrev = false;
     for (let i = 0; i < size; i++) {
-      const item = value[i];
+      item = node.a[i];
       if (isReferenceInStack(ctx, item)) {
-        createSetAdd(ctx, id, getRefParam(ctx, item[1]));
+        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
       } else {
         // Push directly
-        result += `${serializeTree(ctx, item)},`;
+        if (hasPrev) {
+          result += ',';
+        }
+        result += serializeTree(ctx, item);
+        hasPrev = true;
       }
     }
     ctx.stack.pop();
     if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
+      serialized += '([' + result + '])';
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
 
 function serializeMap(
   ctx: SerializationContext,
-  keys: SerovalNode[],
-  values: SerovalNode[],
-  size: number,
-  id: number,
+  node: SerovalMapNode,
 ) {
   let serialized = 'new Map';
-  if (size) {
+  if (node.d.s) {
     let result = '';
-    ctx.stack.push(id);
-    for (let i = 0; i < size; i++) {
+    ctx.stack.push(node.i);
+    let key: SerovalNode;
+    let val: SerovalNode;
+    let keyRef: string;
+    let valueRef: string;
+    let parent: number[];
+    let hasPrev = false;
+    for (let i = 0; i < node.d.s; i++) {
       // Check if key is a parent
-      const key = keys[i];
-      const val = values[i];
+      key = node.d.k[i];
+      val = node.d.v[i];
       if (isReferenceInStack(ctx, key)) {
         // Create reference for the map instance
-        const keyRef = getRefParam(ctx, key[1]);
+        keyRef = getRefParam(ctx, key.i);
         // Check if value is a parent
         if (isReferenceInStack(ctx, val)) {
-          const valueRef = getRefParam(ctx, val[1]);
+          valueRef = getRefParam(ctx, val.i);
           // Register an assignment since
           // both key and value are a parent of this
           // Map instance
-          createMapSet(ctx, id, keyRef, valueRef);
+          createMapSet(ctx, node.i, keyRef, valueRef);
         } else {
           // Reset the stack
           // This is required because the serialized
           // value is no longer part of the expression
           // tree and has been moved to the deferred
           // assignment
-          const parent = ctx.stack;
+          parent = ctx.stack;
           ctx.stack = [];
-          createMapSet(ctx, id, keyRef, serializeTree(ctx, val));
+          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
           ctx.stack = parent;
         }
       } else if (isReferenceInStack(ctx, val)) {
         // Create ref for the Map instance
-        const valueRef = getRefParam(ctx, val[1]);
+        valueRef = getRefParam(ctx, val.i);
         // Reset stack for the key serialization
-        const parent = ctx.stack;
+        parent = ctx.stack;
         ctx.stack = [];
-        createMapSet(ctx, id, serializeTree(ctx, key), valueRef);
+        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
         ctx.stack = parent;
       } else {
-        result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
+        if (hasPrev) {
+          result += ',';
+        }
+        result += '[' + serializeTree(ctx, key) + ',' + serializeTree(ctx, val) + ']';
+        hasPrev = true;
       }
     }
     ctx.stack.pop();
@@ -343,213 +450,132 @@ function serializeMap(
     // so that the empty Map constructor
     // can be used instead
     if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
+      serialized += '([' + result + '])';
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
 
-function serializeNodeList(
-  ctx: SerializationContext,
-  value: SerovalNode[],
-  id: number,
-) {
-  // This is different than Map and Set
-  // because we also need to serialize
-  // the holes of the Array
-  const size = value.length;
-  let values = '';
-  for (let i = 0; i < size; i++) {
-    const item = value[i];
-    // Check if index is a hole
-    if (item) {
-      // Check if item is a parent
-      if (isReferenceInStack(ctx, item)) {
-        createArrayAssign(ctx, id, i, getRefParam(ctx, item[1]));
-        values += ',';
-      } else {
-        values += serializeTree(ctx, item);
-        if (i < size - 1) {
-          values += ',';
-        }
-      }
-    } else {
-      // Add an empty item
-      values += ',';
-    }
-  }
-  return `[${values}]`;
-}
-
-function serializeArray(
+function serializeAggregateError(
   ctx: SerializationContext,
-  value: SerovalNode[],
-  id: number,
+  node: SerovalAggregateErrorNode,
 ) {
-  ctx.stack.push(id);
-  const result = serializeNodeList(ctx, value, id);
+  // Serialize the required arguments
+  ctx.stack.push(node.i);
+  const serialized = 'new AggregateError(' + serializeTree(ctx, node.n) + ',' + quote(node.m) + ')';
   ctx.stack.pop();
-  return assignRef(ctx, id, result);
+  // `AggregateError` might've been extended
+  // either through class or custom properties
+  // Make sure to assign extra properties
+  return serializeDictionary(ctx, node.i, node.d, serialized);
 }
 
-function serializeWithObjectAssign(
+function serializeError(
   ctx: SerializationContext,
-  value: SerovalDictionaryNode,
-  id: number,
-  serialized: string,
+  node: SerovalErrorNode,
 ) {
-  const fields = serializeObject(ctx, id, value);
-  if (fields !== '{}') {
-    return `Object.assign(${serialized},${fields})`;
-  }
-  return serialized;
+  const serialized = 'new ' + node.c + '(' + quote(node.m) + ')';
+  return serializeDictionary(ctx, node.i, node.d, serialized);
 }
 
-function serializeAggregateError(
+function serializePromise(
   ctx: SerializationContext,
-  message: string,
-  options: SerovalDictionaryNode | undefined,
-  errors: SerovalNode,
-  id: number,
+  node: SerovalPromiseNode,
 ) {
-  // Serialize the required arguments
-  ctx.stack.push(id);
-  let serialized = `new AggregateError(${serializeTree(ctx, errors)},${quote(message)})`;
-  ctx.stack.pop();
-  // `AggregateError` might've been extended
-  // either through class or custom properties
-  // Make sure to assign extra properties
-  if (options) {
-    if (ctx.features & Feature.ObjectAssign) {
-      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
+  let serialized: string;
+  // Check if resolved value is a parent expression
+  if (isReferenceInStack(ctx, node.n)) {
+    // A Promise trick, reference the value
+    // inside the `then` expression so that
+    // the Promise evaluates after the parent
+    // has initialized
+    const ref = getRefParam(ctx, node.n.i);
+    if (ctx.features & Feature.ArrowFunction) {
+      serialized = 'Promise.resolve().then(()=>' + ref + ')';
     } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
-      if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-      }
+      serialized = 'Promise.resolve().then(function(){return ' + ref + '})';
     }
+  } else {
+    ctx.stack.push(node.i);
+    const result = serializeTree(ctx, node.n);
+    ctx.stack.pop();
+    // just inline the value/reference here
+    serialized = 'Promise.resolve(' + result + ')';
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
 
-function serializeError(
+function serializeTypedArray(
   ctx: SerializationContext,
-  constructor: string,
-  message: string,
-  options: SerovalDictionaryNode | undefined,
-  id: number,
+  node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
 ) {
-  let serialized = `new ${constructor}(${quote(message)})`;
-  if (options) {
-    if (ctx.features & Feature.ObjectAssign) {
-      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
-    } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
-      if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-      }
-    }
+  let args = '[' + node.s + ']';
+  if (node.l !== 0) {
+    args += ',' + node.l.toString();
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, 'new ' + node.c + '(' + args + ')');
 }
 
 function serializeIterable(
   ctx: SerializationContext,
-  options: SerovalDictionaryNode | undefined,
-  items: SerovalNode[],
-  id: number,
+  node: SerovalIterableNode,
 ) {
   const parent = ctx.stack;
   ctx.stack = [];
-  const values = serializeNodeList(ctx, items, id);
+  const values = serializeNodeList(ctx, node);
   ctx.stack = parent;
-  let serialized: string;
+  let serialized = values;
   if (ctx.features & Feature.ArrayPrototypeValues) {
-    serialized = `${values}.values()`;
+    serialized += '.values()';
   } else {
-    serialized = `${values}[Symbol.iterator]()`;
+    serialized += '[Symbol.iterator]()';
   }
   if (ctx.features & Feature.ArrowFunction) {
-    serialized = `{[Symbol.iterator]:()=>${serialized}}`;
+    serialized = '{[Symbol.iterator]:()=>' + serialized + '}';
   } else if (ctx.features & Feature.MethodShorthand) {
-    serialized = `{[Symbol.iterator](){return ${serialized}}}`;
+    serialized = '{[Symbol.iterator](){return ' + serialized + '}}';
   } else {
-    serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
+    serialized = '{[Symbol.iterator]:function(){return ' + serialized + '}}';
   }
-  if (options) {
-    if (ctx.features & Feature.ObjectAssign) {
-      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
-    } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
-      if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-      }
-    }
-  }
-  return assignRef(ctx, id, serialized);
-}
-
-function serializeNullConstructor(
-  ctx: SerializationContext,
-  value: SerovalDictionaryNode,
-  id: number,
-) {
-  let serialized = 'Object.create(null)';
-  if (ctx.features & Feature.ObjectAssign) {
-    serialized = serializeWithObjectAssign(ctx, value, id, serialized);
-  } else {
-    markRef(ctx, id);
-    const assignments = serializeAssignments(ctx, id, value);
-    if (assignments) {
-      const ref = getRefParam(ctx, id);
-      return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-    }
-  }
-  return assignRef(ctx, id, serialized);
+  return serializeDictionary(ctx, node.i, node.d, serialized);
 }
 
 export default function serializeTree(
   ctx: SerializationContext,
-  [type, value, id]: SerovalNode,
+  node: SerovalNode,
 ): string {
-  switch (type) {
+  switch (node.t) {
     case SerovalNodeType.Primitive:
-      return String(value);
-    case SerovalNodeType.Reference:
-      return getRefParam(ctx, value);
-    case SerovalNodeType.Promise:
-      return serializePromise(ctx, value, id);
+      return String(node.s);
     case SerovalNodeType.BigInt:
-      return value;
+      return node.s;
+    case SerovalNodeType.Reference:
+      return getRefParam(ctx, node.i);
+    case SerovalNodeType.Array:
+      return serializeArray(ctx, node);
+    case SerovalNodeType.Object:
+      return assignRef(ctx, node.i, serializeObject(ctx, node.i, node.d));
+    case SerovalNodeType.NullConstructor:
+      return serializeNullConstructor(ctx, node);
     case SerovalNodeType.Date:
-      return assignRef(ctx, id, `new Date("${value}")`);
+      return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
     case SerovalNodeType.RegExp:
-      return assignRef(ctx, id, value);
-    case SerovalNodeType.BigIntTypedArray:
-    case SerovalNodeType.TypedArray:
-      return serializeTypedArray(ctx, value[0], value[1], value[2], id);
+      return assignRef(ctx, node.i, node.s);
     case SerovalNodeType.Set:
-      return serializeSet(ctx, value, id);
+      return serializeSet(ctx, node);
     case SerovalNodeType.Map:
-      return serializeMap(ctx, value[0], value[1], value[2], id);
-    case SerovalNodeType.Array:
-      return serializeArray(ctx, value, id);
+      return serializeMap(ctx, node);
+    case SerovalNodeType.BigIntTypedArray:
+    case SerovalNodeType.TypedArray:
+      return serializeTypedArray(ctx, node);
     case SerovalNodeType.AggregateError:
-      return serializeAggregateError(ctx, value[0], value[1], value[2], id);
+      return serializeAggregateError(ctx, node);
     case SerovalNodeType.Error:
-      return serializeError(ctx, value[0], value[1], value[2], id);
+      return serializeError(ctx, node);
     case SerovalNodeType.Iterable:
-      return serializeIterable(ctx, value[0], value[1], id);
-    case SerovalNodeType.NullConstructor:
-      return serializeNullConstructor(ctx, value, id);
-    case SerovalNodeType.Object:
-      return assignRef(ctx, id, serializeObject(ctx, id, value));
+      return serializeIterable(ctx, node);
+    case SerovalNodeType.Promise:
+      return serializePromise(ctx, node);
     default:
       throw new Error('Unsupported type');
   }