seroval 0.4.0-alpha.13 → 0.4.0-alpha.15

package/src/tree/serialize.ts

@@ -7,7 +7,6 @@ import {
   markRef,
 } from '../context';
 import quote from '../quote';
-import { isReferenceInStack } from './shared';
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
@@ -20,18 +19,19 @@ import {
   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 '';
   }
@@ -41,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
@@ -89,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;
   }
@@ -105,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,
@@ -122,9 +115,10 @@ function createAssignment(
   value: string,
 ) {
   ctx.assignments.push({
-    type: 'index',
-    source,
-    value,
+    t: 'index',
+    s: source,
+    k: undefined,
+    v: value,
   });
 }
 
@@ -135,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,
   });
 }
 
@@ -149,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,
   });
 }
 
@@ -163,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(
@@ -173,379 +168,412 @@ function createObjectAssign(
   value: string,
 ) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
+  createAssignment(ctx, getRefParam(ctx, ref) + '.' + key, value);
 }
 
-const IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
-
-function serializeAssignments(
+function assignRef(
   ctx: SerializationContext,
-  targetRef: number,
-  node: SerovalObjectRecordNode,
+  index: number,
+  value: string,
 ) {
-  ctx.stack.push(targetRef);
-  const mainAssignments: Assignment[] = [];
-  for (let i = 0; i < node.s; i++) {
-    const parentStack = ctx.stack;
-    ctx.stack = [];
-    const refParam = serializeTree(ctx, node.v[i]);
-    ctx.stack = parentStack;
-    const key = node.k[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);
-    } else {
-      createArrayAssign(ctx, targetRef, isIdentifier ? key : quote(key), refParam);
-    }
-    ctx.assignments = parentAssignment;
+  if (ctx.markedRefs.has(index)) {
+    return getRefParam(ctx, index) + '=' + value;
   }
-  ctx.stack.pop();
-  return resolveAssignments(mainAssignments);
+  return value;
 }
 
-function serializeObject(
+function isReferenceInStack(
   ctx: SerializationContext,
-  sourceID: number,
-  node: SerovalObjectRecordNode,
-) {
-  if (node.s === 0) {
-    return '{}';
-  }
-  let result = '';
-  ctx.stack.push(sourceID);
-  for (let i = 0; i < node.s; i++) {
-    const key = node.k[i];
-    const val = node.v[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 isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-    if (isReferenceInStack(ctx, val)) {
-      const refParam = getRefParam(ctx, val.i);
-      if (isIdentifier && Number.isNaN(check)) {
-        createObjectAssign(ctx, sourceID, key, refParam);
+  node: SerovalNode,
+): node is SerovalReferenceNode {
+  return node.t === SerovalNodeType.Reference && ctx.stack.includes(node.i);
+}
+
+const IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
+
+export default class SerovalSerializer {
+  static serializeNodeList(
+    ctx: SerializationContext,
+    node: SerovalArrayNode | SerovalIterableNode,
+  ) {
+    // 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++) {
+      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 += this.serialize(ctx, item);
+          isHoley = false;
+        }
       } else {
-        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+        isHoley = true;
       }
-    } else {
-      result += `${isIdentifier ? key : quote(key)}:${serializeTree(ctx, val)},`;
     }
+    if (isHoley) {
+      values += ',';
+    }
+    return '[' + values + ']';
   }
-  ctx.stack.pop();
-  return `{${result.substring(0, result.length - 1)}}`;
-}
 
-function serializePromise(
-  ctx: SerializationContext,
-  node: SerovalPromiseNode,
-) {
-  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
-    serialized = `Promise.resolve().then(()=>${getRefParam(ctx, node.n.i)})`;
-  } else {
+  static serializeArray(
+    ctx: SerializationContext,
+    node: SerovalArrayNode,
+  ) {
     ctx.stack.push(node.i);
-    const result = serializeTree(ctx, node.n);
+    const result = this.serializeNodeList(ctx, node);
     ctx.stack.pop();
-    // just inline the value/reference here
-    serialized = `Promise.resolve(${result})`;
+    return assignRef(ctx, node.i, result);
   }
-  return assignRef(ctx, node.i, serialized);
-}
 
-function serializeTypedArray(
-  ctx: SerializationContext,
-  node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
-) {
-  let args = `[${node.s}]`;
-  if (node.l !== 0) {
-    args += `,${node.l}`;
-  }
-  return assignRef(ctx, node.i, `new ${node.c}(${args})`);
-}
-
-function serializeSet(
-  ctx: SerializationContext,
-  node: SerovalSetNode,
-) {
-  let serialized = 'new Set';
-  const size = node.a.length;
-  if (size) {
+  static serializeObject(
+    ctx: SerializationContext,
+    sourceID: number,
+    node: SerovalObjectRecordNode,
+  ) {
+    if (node.s === 0) {
+      return '{}';
+    }
     let result = '';
-    ctx.stack.push(node.i);
-    for (let i = 0; i < size; i++) {
-      const item = node.a[i];
-      if (isReferenceInStack(ctx, item)) {
-        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
+    ctx.stack.push(sourceID);
+    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
+      isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+      if (isReferenceInStack(ctx, val)) {
+        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 {
-        // Push directly
-        result += `${serializeTree(ctx, item)},`;
+        if (hasPrev) {
+          result += ',';
+        }
+        result += isIdentifier ? key : quote(key);
+        result += ':' + this.serialize(ctx, val);
+        hasPrev = true;
       }
     }
     ctx.stack.pop();
-    if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
+    return '{' + result + '}';
+  }
+
+  static serializeWithObjectAssign(
+    ctx: SerializationContext,
+    value: SerovalObjectRecordNode,
+    id: number,
+    serialized: string,
+  ) {
+    const fields = this.serializeObject(ctx, id, value);
+    if (fields !== '{}') {
+      return 'Object.assign(' + serialized + ',' + fields + ')';
     }
+    return serialized;
   }
-  return assignRef(ctx, node.i, serialized);
-}
 
-function serializeMap(
-  ctx: SerializationContext,
-  node: SerovalMapNode,
-) {
-  let serialized = 'new Map';
-  if (node.d.s) {
-    let result = '';
-    ctx.stack.push(node.i);
-    for (let i = 0; i < node.d.s; i++) {
-      // Check if key is a parent
-      const key = node.d.k[i];
-      const val = node.d.v[i];
-      if (isReferenceInStack(ctx, key)) {
-        // Create reference for the map instance
-        const keyRef = getRefParam(ctx, key.i);
-        // Check if value is a parent
-        if (isReferenceInStack(ctx, val)) {
-          const valueRef = getRefParam(ctx, val.i);
-          // Register an assignment since
-          // both key and value are a parent of this
-          // Map instance
-          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;
-          ctx.stack = [];
-          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.i);
-        // Reset stack for the key serialization
-        const parent = ctx.stack;
-        ctx.stack = [];
-        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
-        ctx.stack = parent;
+  static serializeAssignments(
+    ctx: SerializationContext,
+    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 = this.serialize(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 {
-        result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
+        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
       }
+      ctx.assignments = parentAssignment;
     }
     ctx.stack.pop();
-    // Check if there are any values
-    // so that the empty Map constructor
-    // can be used instead
-    if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
-    }
+    return resolveAssignments(mainAssignments);
   }
-  return assignRef(ctx, node.i, serialized);
-}
 
-function serializeNodeList(
-  ctx: SerializationContext,
-  node: SerovalArrayNode | SerovalIterableNode,
-) {
-  // 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 = '';
-  for (let i = 0; i < size; i++) {
-    const 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));
-        values += ',';
+  static serializeDictionary(
+    ctx: SerializationContext,
+    i: number,
+    d: SerovalObjectRecordNode | undefined,
+    init: string,
+  ) {
+    if (d) {
+      if (ctx.features & Feature.ObjectAssign) {
+        init = this.serializeWithObjectAssign(ctx, d, i, init);
       } else {
-        values += serializeTree(ctx, item);
-        if (i < size - 1) {
-          values += ',';
+        markRef(ctx, i);
+        const assignments = this.serializeAssignments(ctx, i, d);
+        if (assignments) {
+          const ref = getRefParam(ctx, i);
+          return '(' + assignRef(ctx, i, init) + ',' + assignments + ref + ')';
         }
       }
-    } else {
-      // Add an empty item
-      values += ',';
     }
+    return assignRef(ctx, i, init);
   }
-  return `[${values}]`;
-}
-
-function serializeArray(
-  ctx: SerializationContext,
-  node: SerovalArrayNode,
-) {
-  ctx.stack.push(node.i);
-  const result = serializeNodeList(ctx, node);
-  ctx.stack.pop();
-  return assignRef(ctx, node.i, result);
-}
 
-function serializeWithObjectAssign(
-  ctx: SerializationContext,
-  value: SerovalObjectRecordNode,
-  id: number,
-  serialized: string,
-) {
-  const fields = serializeObject(ctx, id, value);
-  if (fields !== '{}') {
-    return `Object.assign(${serialized},${fields})`;
+  static serializeNullConstructor(
+    ctx: SerializationContext,
+    node: SerovalNullConstructorNode,
+  ) {
+    return this.serializeDictionary(ctx, node.i, node.d, 'Object.create(null)');
   }
-  return serialized;
-}
 
-function serializeAggregateError(
-  ctx: SerializationContext,
-  node: SerovalAggregateErrorNode,
-) {
-  // Serialize the required arguments
-  ctx.stack.push(node.i);
-  let serialized = `new AggregateError(${serializeTree(ctx, node.n)},${quote(node.m)})`;
-  ctx.stack.pop();
-  // `AggregateError` might've been extended
-  // either through class or custom properties
-  // Make sure to assign extra properties
-  if (node.d) {
-    if (ctx.features & Feature.ObjectAssign) {
-      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
-    } else {
-      markRef(ctx, node.i);
-      const assignments = serializeAssignments(ctx, node.i, node.d);
-      if (assignments) {
-        const ref = getRefParam(ctx, node.i);
-        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
+  static serializeSet(
+    ctx: SerializationContext,
+    node: SerovalSetNode,
+  ) {
+    let serialized = 'new Set';
+    const size = node.a.length;
+    if (size) {
+      let result = '';
+      ctx.stack.push(node.i);
+      let item: SerovalNode;
+      let hasPrev = false;
+      for (let i = 0; i < size; i++) {
+        item = node.a[i];
+        if (isReferenceInStack(ctx, item)) {
+          createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
+        } else {
+          // Push directly
+          if (hasPrev) {
+            result += ',';
+          }
+          result += this.serialize(ctx, item);
+          hasPrev = true;
+        }
+      }
+      ctx.stack.pop();
+      if (result) {
+        serialized += '([' + result + '])';
       }
     }
+    return assignRef(ctx, node.i, serialized);
   }
-  return assignRef(ctx, node.i, serialized);
-}
 
-function serializeError(
-  ctx: SerializationContext,
-  node: SerovalErrorNode,
-) {
-  let serialized = `new ${node.c}(${quote(node.m)})`;
-  if (node.d) {
-    if (ctx.features & Feature.ObjectAssign) {
-      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
-    } else {
-      markRef(ctx, node.i);
-      const assignments = serializeAssignments(ctx, node.i, node.d);
-      if (assignments) {
-        const ref = getRefParam(ctx, node.i);
-        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
+  static serializeMap(
+    ctx: SerializationContext,
+    node: SerovalMapNode,
+  ) {
+    let serialized = 'new Map';
+    if (node.d.s) {
+      let result = '';
+      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
+        key = node.d.k[i];
+        val = node.d.v[i];
+        if (isReferenceInStack(ctx, key)) {
+          // Create reference for the map instance
+          keyRef = getRefParam(ctx, key.i);
+          // Check if value is a parent
+          if (isReferenceInStack(ctx, val)) {
+            valueRef = getRefParam(ctx, val.i);
+            // Register an assignment since
+            // both key and value are a parent of this
+            // Map instance
+            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
+            parent = ctx.stack;
+            ctx.stack = [];
+            createMapSet(ctx, node.i, keyRef, this.serialize(ctx, val));
+            ctx.stack = parent;
+          }
+        } else if (isReferenceInStack(ctx, val)) {
+          // Create ref for the Map instance
+          valueRef = getRefParam(ctx, val.i);
+          // Reset stack for the key serialization
+          parent = ctx.stack;
+          ctx.stack = [];
+          createMapSet(ctx, node.i, this.serialize(ctx, key), valueRef);
+          ctx.stack = parent;
+        } else {
+          if (hasPrev) {
+            result += ',';
+          }
+          result += '[' + this.serialize(ctx, key) + ',' + this.serialize(ctx, val) + ']';
+          hasPrev = true;
+        }
+      }
+      ctx.stack.pop();
+      // Check if there are any values
+      // so that the empty Map constructor
+      // can be used instead
+      if (result) {
+        serialized += '([' + result + '])';
       }
     }
+    return assignRef(ctx, node.i, serialized);
   }
-  return assignRef(ctx, node.i, serialized);
-}
 
-function serializeIterable(
-  ctx: SerializationContext,
-  node: SerovalIterableNode,
-) {
-  const parent = ctx.stack;
-  ctx.stack = [];
-  const values = serializeNodeList(ctx, node);
-  ctx.stack = parent;
-  let serialized: string;
-  if (ctx.features & Feature.ArrayPrototypeValues) {
-    serialized = `${values}.values()`;
-  } else {
-    serialized = `${values}[Symbol.iterator]()`;
+  static serializeAggregateError(
+    ctx: SerializationContext,
+    node: SerovalAggregateErrorNode,
+  ) {
+    // Serialize the required arguments
+    ctx.stack.push(node.i);
+    const serialized = 'new AggregateError(' + this.serialize(ctx, node.n) + ',' + quote(node.m) + ')';
+    ctx.stack.pop();
+    // `AggregateError` might've been extended
+    // either through class or custom properties
+    // Make sure to assign extra properties
+    return this.serializeDictionary(ctx, node.i, node.d, serialized);
   }
-  if (ctx.features & Feature.ArrowFunction) {
-    serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-  } else if (ctx.features & Feature.MethodShorthand) {
-    serialized = `{[Symbol.iterator](){return ${serialized}}}`;
-  } else {
-    serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
+
+  static serializeError(
+    ctx: SerializationContext,
+    node: SerovalErrorNode,
+  ) {
+    const serialized = 'new ' + node.c + '(' + quote(node.m) + ')';
+    return this.serializeDictionary(ctx, node.i, node.d, serialized);
   }
-  if (node.d) {
-    if (ctx.features & Feature.ObjectAssign) {
-      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
+
+  static serializePromise(
+    ctx: SerializationContext,
+    node: SerovalPromiseNode,
+  ) {
+    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
+      serialized = 'Promise.resolve().then(()=>' + getRefParam(ctx, node.n.i) + ')';
     } else {
-      markRef(ctx, node.i);
-      const assignments = serializeAssignments(ctx, node.i, node.d);
-      if (assignments) {
-        const ref = getRefParam(ctx, node.i);
-        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
-      }
+      ctx.stack.push(node.i);
+      const result = this.serialize(ctx, node.n);
+      ctx.stack.pop();
+      // just inline the value/reference here
+      serialized = 'Promise.resolve(' + result + ')';
     }
+    return assignRef(ctx, node.i, serialized);
   }
-  return assignRef(ctx, node.i, serialized);
-}
 
-function serializeNullConstructor(
-  ctx: SerializationContext,
-  node: SerovalNullConstructorNode,
-) {
-  let serialized = 'Object.create(null)';
-  if (ctx.features & Feature.ObjectAssign) {
-    serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
-  } else {
-    markRef(ctx, node.i);
-    const assignments = serializeAssignments(ctx, node.i, node.d);
-    if (assignments) {
-      const ref = getRefParam(ctx, node.i);
-      return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
+  static serializeTypedArray(
+    ctx: SerializationContext,
+    node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
+  ) {
+    let args = '[' + node.s + ']';
+    if (node.l !== 0) {
+      args += ',' + node.l.toString();
     }
+    return assignRef(ctx, node.i, 'new ' + node.c + '(' + args + ')');
   }
-  return assignRef(ctx, node.i, serialized);
-}
 
-export default function serializeTree(
-  ctx: SerializationContext,
-  node: SerovalNode,
-): string {
-  switch (node.t) {
-    case SerovalNodeType.Primitive:
-      return String(node.s);
-    case SerovalNodeType.Reference:
-      return getRefParam(ctx, node.i);
-    case SerovalNodeType.Promise:
-      return serializePromise(ctx, node);
-    case SerovalNodeType.BigInt:
-      return node.s;
-    case SerovalNodeType.Date:
-      return assignRef(ctx, node.i, `new Date("${node.s}")`);
-    case SerovalNodeType.RegExp:
-      return assignRef(ctx, node.i, node.s);
-    case SerovalNodeType.BigIntTypedArray:
-    case SerovalNodeType.TypedArray:
-      return serializeTypedArray(ctx, node);
-    case SerovalNodeType.Set:
-      return serializeSet(ctx, node);
-    case SerovalNodeType.Map:
-      return serializeMap(ctx, node);
-    case SerovalNodeType.Array:
-      return serializeArray(ctx, node);
-    case SerovalNodeType.AggregateError:
-      return serializeAggregateError(ctx, node);
-    case SerovalNodeType.Error:
-      return serializeError(ctx, node);
-    case SerovalNodeType.Iterable:
-      return serializeIterable(ctx, node);
-    case SerovalNodeType.NullConstructor:
-      return serializeNullConstructor(ctx, node);
-    case SerovalNodeType.Object:
-      return assignRef(ctx, node.i, serializeObject(ctx, node.i, node.d));
-    default:
-      throw new Error('Unsupported type');
+  static serializeIterable(
+    ctx: SerializationContext,
+    node: SerovalIterableNode,
+  ) {
+    const parent = ctx.stack;
+    ctx.stack = [];
+    const values = this.serializeNodeList(ctx, node);
+    ctx.stack = parent;
+    let serialized = values;
+    if (ctx.features & Feature.ArrayPrototypeValues) {
+      serialized += '.values()';
+    } else {
+      serialized += '[Symbol.iterator]()';
+    }
+    if (ctx.features & Feature.ArrowFunction) {
+      serialized = '{[Symbol.iterator]:()=>' + serialized + '}';
+    } else if (ctx.features & Feature.MethodShorthand) {
+      serialized = '{[Symbol.iterator](){return ' + serialized + '}}';
+    } else {
+      serialized = '{[Symbol.iterator]:function(){return ' + serialized + '}}';
+    }
+    return this.serializeDictionary(ctx, node.i, node.d, serialized);
+  }
+
+  static serialize(
+    ctx: SerializationContext,
+    node: SerovalNode,
+  ): string {
+    switch (node.t) {
+      case SerovalNodeType.Primitive:
+        return String(node.s);
+      case SerovalNodeType.BigInt:
+        return node.s;
+      case SerovalNodeType.Reference:
+        return getRefParam(ctx, node.i);
+      case SerovalNodeType.Array:
+        return this.serializeArray(ctx, node);
+      case SerovalNodeType.Object:
+        return assignRef(ctx, node.i, this.serializeObject(ctx, node.i, node.d));
+      case SerovalNodeType.NullConstructor:
+        return this.serializeNullConstructor(ctx, node);
+      case SerovalNodeType.Date:
+        return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
+      case SerovalNodeType.RegExp:
+        return assignRef(ctx, node.i, node.s);
+      case SerovalNodeType.Set:
+        return this.serializeSet(ctx, node);
+      case SerovalNodeType.Map:
+        return this.serializeMap(ctx, node);
+      case SerovalNodeType.BigIntTypedArray:
+      case SerovalNodeType.TypedArray:
+        return this.serializeTypedArray(ctx, node);
+      case SerovalNodeType.AggregateError:
+        return this.serializeAggregateError(ctx, node);
+      case SerovalNodeType.Error:
+        return this.serializeError(ctx, node);
+      case SerovalNodeType.Iterable:
+        return this.serializeIterable(ctx, node);
+      case SerovalNodeType.Promise:
+        return this.serializePromise(ctx, node);
+      default:
+        throw new Error('Unsupported type');
+    }
   }
 }