seroval 0.4.0-alpha.13 → 0.4.0-alpha.14

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