seroval 1.3.1 → 1.4.0

package/src/core/context/serializer.ts

@@ -3,19 +3,25 @@ import {
   CONSTANT_STRING,
   ERROR_CONSTRUCTOR_STRING,
   NIL,
-  SYMBOL_STRING,
   SerovalNodeType,
   SerovalObjectFlags,
+  SYMBOL_STRING,
 } from '../constants';
+import {
+  SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR,
+  SERIALIZED_ITERATOR_CONSTRUCTOR,
+} from '../constructors';
 import {
   SerovalMissingPluginError,
   SerovalSerializationError,
   SerovalUnsupportedNodeError,
 } from '../errors';
 import { createEffectfulFunction, createFunction } from '../function-string';
-import { REFERENCES_KEY } from '../keys';
-import type { Plugin, PluginAccessOptions, SerovalMode } from '../plugin';
-import { serializeSpecialReferenceValue } from '../special-reference';
+import { GLOBAL_CONTEXT_REFERENCES, REFERENCES_KEY } from '../keys';
+import type { PluginAccessOptions } from '../plugin';
+import { SerovalMode } from '../plugin';
+import { SPECIAL_REF_STRING } from '../special-reference';
+import { serializeString } from '../string';
 import type {
   SerovalAggregateErrorNode,
   SerovalArrayBufferNode,
@@ -45,14 +51,13 @@ import type {
   SerovalReferenceNode,
   SerovalRegExpNode,
   SerovalSetNode,
-  SerovalSpecialReferenceNode,
   SerovalStreamConstructorNode,
   SerovalStreamNextNode,
   SerovalStreamReturnNode,
   SerovalStreamThrowNode,
   SerovalTypedArrayNode,
-  SerovalWKSymbolNode,
 } from '../types';
+import getIdentifier from '../utils/get-identifier';
 import { isValidIdentifier } from '../utils/is-valid-identifier';
 
 const enum AssignmentType {
@@ -208,318 +213,377 @@ export interface BaseSerializerContextOptions extends PluginAccessOptions {
   markedRefs: number[] | Set<number>;
 }
 
-export default abstract class BaseSerializerContext
-  implements PluginAccessOptions
-{
-  /**
-   * @private
-   */
-  features: number;
+export interface BaseSerializerContext extends PluginAccessOptions {
+  readonly mode: SerovalMode;
 
-  /**
+  features: number;
+  /*
    * To check if an object is synchronously referencing itself
-   * @private
    */
-  stack: number[] = [];
-
+  stack: number[];
   /**
    * Array of object mutations
-   * @private
    */
-  flags: FlaggedObject[] = [];
-
+  flags: FlaggedObject[];
   /**
    * Array of assignments to be done (used for recursion)
-   * @private
    */
-  assignments: Assignment[] = [];
-
-  plugins?: Plugin<any, any>[] | undefined;
-
+  assignments: Assignment[];
   /**
    * Refs that are...referenced
-   * @private
    */
   marked: Set<number>;
+}
 
-  constructor(options: BaseSerializerContextOptions) {
-    this.plugins = options.plugins;
-    this.features = options.features;
-    this.marked = new Set(options.markedRefs);
-  }
+export interface CrossContextOptions {
+  scopeId?: string;
+}
 
-  abstract readonly mode: SerovalMode;
+export function createBaseSerializerContext(
+  mode: SerovalMode,
+  options: BaseSerializerContextOptions,
+): BaseSerializerContext {
+  return {
+    mode,
+    plugins: options.plugins,
+    features: options.features,
+    marked: new Set(options.markedRefs),
+    stack: [],
+    flags: [],
+    assignments: [],
+  };
+}
 
-  createFunction(parameters: string[], body: string): string {
-    return createFunction(this.features, parameters, body);
-  }
+export interface VanillaSerializerState {
+  valid: Map<number, number>;
+  vars: string[];
+}
 
-  createEffectfulFunction(parameters: string[], body: string): string {
-    return createEffectfulFunction(this.features, parameters, body);
-  }
+function createVanillaSerializerState(): VanillaSerializerState {
+  return {
+    valid: new Map(),
+    vars: [],
+  };
+}
 
-  /**
-   * A tiny function that tells if a reference
-   * is to be accessed. This is a requirement for
-   * deciding whether or not we should generate
-   * an identifier for the object
-   */
-  protected markRef(id: number): void {
-    this.marked.add(id);
-  }
+export interface VanillaSerializerContext {
+  mode: SerovalMode.Vanilla;
+  base: BaseSerializerContext;
+  state: VanillaSerializerState;
+  child: SerializePluginContext | undefined;
+}
 
-  protected isMarked(id: number): boolean {
-    return this.marked.has(id);
-  }
+export type VanillaSerializerContextOptions = BaseSerializerContextOptions;
 
-  /**
-   * Converts the ID of a reference into a identifier string
-   * that is used to refer to the object instance in the
-   * generated script.
-   */
-  abstract getRefParam(id: number): string;
-
-  protected pushObjectFlag(flag: SerovalObjectFlags, id: number): void {
-    if (flag !== SerovalObjectFlags.None) {
-      this.markRef(id);
-      this.flags.push({
-        type: flag,
-        value: this.getRefParam(id),
-      });
-    }
-  }
+export function createVanillaSerializerContext(
+  options: VanillaSerializerContextOptions,
+): VanillaSerializerContext {
+  return {
+    mode: SerovalMode.Vanilla,
+    base: createBaseSerializerContext(SerovalMode.Vanilla, options),
+    state: createVanillaSerializerState(),
+    child: undefined,
+  };
+}
 
-  private resolveFlags(): string | undefined {
-    let result = '';
-    for (let i = 0, current = this.flags, len = current.length; i < len; i++) {
-      const flag = current[i];
-      result += OBJECT_FLAG_CONSTRUCTOR[flag.type] + '(' + flag.value + '),';
-    }
-    return result;
-  }
+export interface CrossSerializerContext {
+  mode: SerovalMode.Cross;
+  base: BaseSerializerContext;
+  state: CrossContextOptions;
+  child: SerializePluginContext | undefined;
+}
 
-  protected resolvePatches(): string | undefined {
-    const assignments = resolveAssignments(this.assignments);
-    const flags = this.resolveFlags();
-    if (assignments) {
-      if (flags) {
-        return assignments + flags;
-      }
-      return assignments;
-    }
-    return flags;
+export interface CrossSerializerContextOptions
+  extends BaseSerializerContextOptions,
+    CrossContextOptions {
+  // empty
+}
+
+export function createCrossSerializerContext(
+  options: CrossSerializerContextOptions,
+): CrossSerializerContext {
+  return {
+    mode: SerovalMode.Cross,
+    base: createBaseSerializerContext(SerovalMode.Cross, options),
+    state: options,
+    child: undefined,
+  };
+}
+
+type SerializerContext = VanillaSerializerContext | CrossSerializerContext;
+
+export class SerializePluginContext {
+  constructor(private _p: SerializerContext) {}
+
+  serialize(node: SerovalNode) {
+    return serialize(this._p, node);
   }
+}
 
+/**
+ * Creates the reference param (identifier) from the given reference ID
+ * Calling this function means the value has been referenced somewhere
+ */
+function getVanillaRefParam(
+  state: VanillaSerializerState,
+  index: number,
+): string {
   /**
-   * Generates the inlined assignment for the reference
-   * This is different from the assignments array as this one
-   * signifies creation rather than mutation
+   * Creates a new reference ID from a given reference ID
+   * This new reference ID means that the reference itself
+   * has been referenced at least once, and is used to generate
+   * the variables
    */
-  protected createAssignment(source: string, value: string): void {
-    this.assignments.push({
-      t: AssignmentType.Index,
-      s: source,
-      k: NIL,
-      v: value,
-    });
+  let actualIndex = state.valid.get(index);
+  if (actualIndex == null) {
+    actualIndex = state.valid.size;
+    state.valid.set(index, actualIndex);
   }
-
-  protected createAddAssignment(ref: number, value: string): void {
-    this.assignments.push({
-      t: AssignmentType.Add,
-      s: this.getRefParam(ref),
-      k: NIL,
-      v: value,
-    });
+  let identifier = state.vars[actualIndex];
+  if (identifier == null) {
+    identifier = getIdentifier(actualIndex);
+    state.vars[actualIndex] = identifier;
   }
+  return identifier;
+}
 
-  protected createSetAssignment(ref: number, key: string, value: string): void {
-    this.assignments.push({
-      t: AssignmentType.Set,
-      s: this.getRefParam(ref),
-      k: key,
-      v: value,
-    });
-  }
+function getCrossRefParam(id: number): string {
+  return GLOBAL_CONTEXT_REFERENCES + '[' + id + ']';
+}
+
+/**
+ * Converts the ID of a reference into a identifier string
+ * that is used to refer to the object instance in the
+ * generated script.
+ */
+function getRefParam(ctx: SerializerContext, id: number): string {
+  return ctx.mode === SerovalMode.Vanilla
+    ? getVanillaRefParam(ctx.state, id)
+    : getCrossRefParam(id);
+}
+
+function markSerializerRef(ctx: BaseSerializerContext, id: number): void {
+  ctx.marked.add(id);
+}
+
+function isSerializerRefMarked(
+  ctx: BaseSerializerContext,
+  id: number,
+): boolean {
+  return ctx.marked.has(id);
+}
 
-  protected createDeleteAssignment(ref: number, key: string): void {
-    this.assignments.push({
-      t: AssignmentType.Delete,
-      s: this.getRefParam(ref),
-      k: key,
-      v: NIL,
+function pushObjectFlag(
+  ctx: SerializerContext,
+  flag: SerovalObjectFlags,
+  id: number,
+): void {
+  if (flag !== SerovalObjectFlags.None) {
+    markSerializerRef(ctx.base, id);
+    ctx.base.flags.push({
+      type: flag,
+      value: getRefParam(ctx, id),
     });
   }
+}
 
-  protected createArrayAssign(
-    ref: number,
-    index: number | string,
-    value: string,
-  ): void {
-    this.createAssignment(this.getRefParam(ref) + '[' + index + ']', value);
+function resolveFlags(ctx: BaseSerializerContext): string | undefined {
+  let result = '';
+  for (let i = 0, current = ctx.flags, len = current.length; i < len; i++) {
+    const flag = current[i];
+    result += OBJECT_FLAG_CONSTRUCTOR[flag.type] + '(' + flag.value + '),';
   }
+  return result;
+}
 
-  protected createObjectAssign(ref: number, key: string, value: string): void {
-    this.createAssignment(this.getRefParam(ref) + '.' + key, value);
+function resolvePatches(ctx: BaseSerializerContext): string | undefined {
+  const assignments = resolveAssignments(ctx.assignments);
+  const flags = resolveFlags(ctx);
+  if (assignments) {
+    if (flags) {
+      return assignments + flags;
+    }
+    return assignments;
   }
+  return flags;
+}
 
-  /**
-   * Checks if the value is in the stack. Stack here is a reference
-   * structure to know if a object is to be accessed in a TDZ.
-   */
-  isIndexedValueInStack(node: SerovalNode): boolean {
-    return (
-      node.t === SerovalNodeType.IndexedValue && this.stack.includes(node.i)
-    );
-  }
+/**
+ * Generates the inlined assignment for the reference
+ * This is different from the assignments array as this one
+ * signifies creation rather than mutation
+ */
+function createAssignment(
+  ctx: BaseSerializerContext,
+  source: string,
+  value: string,
+): void {
+  ctx.assignments.push({
+    t: AssignmentType.Index,
+    s: source,
+    k: NIL,
+    v: value,
+  });
+}
 
-  /**
-   * Produces an assignment expression. `id` generates a reference
-   * parameter (through `getRefParam`) and has the option to
-   * return the reference parameter directly or assign a value to
-   * it.
-   */
-  protected abstract assignIndexedValue(id: number, value: string): string;
+function createAddAssignment(
+  ctx: SerializerContext,
+  ref: number,
+  value: string,
+): void {
+  ctx.base.assignments.push({
+    t: AssignmentType.Add,
+    s: getRefParam(ctx, ref),
+    k: NIL,
+    v: value,
+  });
+}
 
-  protected serializeReference(node: SerovalReferenceNode): string {
-    return this.assignIndexedValue(
-      node.i,
-      REFERENCES_KEY + '.get("' + node.s + '")',
-    );
-  }
+function createSetAssignment(
+  ctx: SerializerContext,
+  ref: number,
+  key: string,
+  value: string,
+): void {
+  ctx.base.assignments.push({
+    t: AssignmentType.Set,
+    s: getRefParam(ctx, ref),
+    k: key,
+    v: value,
+  });
+}
 
-  protected serializeArrayItem(
-    id: number,
-    item: SerovalNode | undefined,
-    index: number,
-  ): string {
-    // Check if index is a hole
-    if (item) {
-      // Check if item is a parent
-      if (this.isIndexedValueInStack(item)) {
-        this.markRef(id);
-        this.createArrayAssign(
-          id,
-          index,
-          this.getRefParam((item as SerovalIndexedValueNode).i),
-        );
-        return '';
-      }
-      return this.serialize(item);
-    }
-    return '';
-  }
+function createDeleteAssignment(
+  ctx: SerializerContext,
+  ref: number,
+  key: string,
+): void {
+  ctx.base.assignments.push({
+    t: AssignmentType.Delete,
+    s: getRefParam(ctx, ref),
+    k: key,
+    v: NIL,
+  });
+}
 
-  protected serializeArray(node: SerovalArrayNode): string {
-    const id = node.i;
-    if (node.l) {
-      this.stack.push(id);
-      const list = node.a;
-      let values = this.serializeArrayItem(id, list[0], 0);
-      // This is different than Map and Set
-      // because we also need to serialize
-      // the holes of the Array
-      let isHoley = values === '';
-      for (let i = 1, len = node.l, item: string; i < len; i++) {
-        item = this.serializeArrayItem(id, list[i], i);
-        values += ',' + item;
-        isHoley = item === '';
-      }
-      this.stack.pop();
-      this.pushObjectFlag(node.o, node.i);
-      return this.assignIndexedValue(id, '[' + values + (isHoley ? ',]' : ']'));
-    }
-    return this.assignIndexedValue(id, '[]');
-  }
+function createArrayAssign(
+  ctx: SerializerContext,
+  ref: number,
+  index: number | string,
+  value: string,
+): void {
+  createAssignment(ctx.base, getRefParam(ctx, ref) + '[' + index + ']', value);
+}
 
-  protected serializeProperty(
-    source: SerovalNodeWithProperties,
-    key: SerovalObjectRecordKey,
-    val: SerovalNode,
-  ): string {
-    if (typeof key === 'string') {
-      const check = Number(key);
-      const isIdentifier =
-        // Test if key is a valid positive number or JS identifier
-        // so that we don't have to serialize the key and wrap with brackets
-        (check >= 0 &&
-          // It's also important to consider that if the key is
-          // indeed numeric, we need to make sure that when
-          // converted back into a string, it's still the same
-          // to the original key. This allows us to differentiate
-          // keys that has numeric formats but in a different
-          // format, which can cause unintentional key declaration
-          // Example: { 0x1: 1 } vs { '0x1': 1 }
-          check.toString() === key) ||
-        isValidIdentifier(key);
-      if (this.isIndexedValueInStack(val)) {
-        const refParam = this.getRefParam((val as SerovalIndexedValueNode).i);
-        this.markRef(source.i);
-        // Strict identifier check, make sure
-        // that it isn't numeric (except NaN)
-        if (isIdentifier && check !== check) {
-          this.createObjectAssign(source.i, key, refParam);
-        } else {
-          this.createArrayAssign(
-            source.i,
-            isIdentifier ? key : '"' + key + '"',
-            refParam,
-          );
-        }
-        return '';
-      }
-      return (isIdentifier ? key : '"' + key + '"') + ':' + this.serialize(val);
-    }
-    return '[' + this.serialize(key) + ']:' + this.serialize(val);
-  }
+function createObjectAssign(
+  ctx: SerializerContext,
+  ref: number,
+  key: string,
+  value: string,
+): void {
+  createAssignment(ctx.base, getRefParam(ctx, ref) + '.' + key, value);
+}
 
-  protected serializeProperties(
-    source: SerovalNodeWithProperties,
-    record: SerovalObjectRecordNode,
-  ): string {
-    const len = record.s;
-    if (len) {
-      const keys = record.k;
-      const values = record.v;
-      this.stack.push(source.i);
-      let result = this.serializeProperty(source, keys[0], values[0]);
-      for (let i = 1, item = result; i < len; i++) {
-        item = this.serializeProperty(source, keys[i], values[i]);
-        result += (item && result && ',') + item;
-      }
-      this.stack.pop();
-      return '{' + result + '}';
-    }
-    return '{}';
+/**
+ * Checks if the value is in the stack. Stack here is a reference
+ * structure to know if a object is to be accessed in a TDZ.
+ */
+function isIndexedValueInStack(
+  ctx: BaseSerializerContext,
+  node: SerovalNode,
+): boolean {
+  return node.t === SerovalNodeType.IndexedValue && ctx.stack.includes(node.i);
+}
+
+/**
+ * Produces an assignment expression. `id` generates a reference
+ * parameter (through `getRefParam`) and has the option to
+ * return the reference parameter directly or assign a value to
+ * it.
+ */
+function assignIndexedValue(
+  ctx: SerializerContext,
+  index: number,
+  value: string,
+): string {
+  if (
+    ctx.mode === SerovalMode.Vanilla &&
+    !isSerializerRefMarked(ctx.base, index)
+  ) {
+    return value;
   }
+  /**
+   * In cross-reference, we have to assume that
+   * every reference are going to be referenced
+   * in the future, and so we need to store
+   * all of it into the reference array.
+   *
+   * otherwise in vanilla, we only do this if it
+   * is actually referenced
+   */
+  return getRefParam(ctx, index) + '=' + value;
+}
 
-  protected serializeObject(node: SerovalObjectNode): string {
-    this.pushObjectFlag(node.o, node.i);
-    return this.assignIndexedValue(
-      node.i,
-      this.serializeProperties(node, node.p),
-    );
+function serializeReference(node: SerovalReferenceNode): string {
+  return REFERENCES_KEY + '.get("' + node.s + '")';
+}
+
+function serializeArrayItem(
+  ctx: SerializerContext,
+  id: number,
+  item: SerovalNode | undefined,
+  index: number,
+): string {
+  // Check if index is a hole
+  if (item) {
+    // Check if item is a parent
+    if (isIndexedValueInStack(ctx.base, item)) {
+      markSerializerRef(ctx.base, id);
+      createArrayAssign(
+        ctx,
+        id,
+        index,
+        getRefParam(ctx, (item as SerovalIndexedValueNode).i),
+      );
+      return '';
+    }
+    return serialize(ctx, item);
   }
+  return '';
+}
 
-  protected serializeWithObjectAssign(
-    source: SerovalNodeWithProperties,
-    value: SerovalObjectRecordNode,
-    serialized: string,
-  ): string {
-    const fields = this.serializeProperties(source, value);
-    if (fields !== '{}') {
-      return 'Object.assign(' + serialized + ',' + fields + ')';
+function serializeArray(
+  ctx: SerializerContext,
+  node: SerovalArrayNode,
+): string {
+  const id = node.i;
+  if (node.l) {
+    ctx.base.stack.push(id);
+    const list = node.a;
+    let values = serializeArrayItem(ctx, id, list[0], 0);
+    // This is different than Map and Set
+    // because we also need to serialize
+    // the holes of the Array
+    let isHoley = values === '';
+    for (let i = 1, len = node.l, item: string; i < len; i++) {
+      item = serializeArrayItem(ctx, id, list[i], i);
+      values += ',' + item;
+      isHoley = item === '';
     }
-    return serialized;
+    ctx.base.stack.pop();
+    pushObjectFlag(ctx, node.o, node.i);
+    return '[' + values + (isHoley ? ',]' : ']');
   }
+  return '[]';
+}
 
-  private serializeStringKeyAssignment(
-    source: SerovalNodeWithProperties,
-    mainAssignments: Assignment[],
-    key: string,
-    value: SerovalNode,
-  ): void {
-    const serialized = this.serialize(value);
+function serializeProperty(
+  ctx: SerializerContext,
+  source: SerovalNodeWithProperties,
+  key: SerovalObjectRecordKey,
+  val: SerovalNode,
+): string {
+  if (typeof key === 'string') {
     const check = Number(key);
     const isIdentifier =
       // Test if key is a valid positive number or JS identifier
@@ -534,647 +598,814 @@ export default abstract class BaseSerializerContext
         // Example: { 0x1: 1 } vs { '0x1': 1 }
         check.toString() === key) ||
       isValidIdentifier(key);
-    if (this.isIndexedValueInStack(value)) {
+    if (isIndexedValueInStack(ctx.base, val)) {
+      const refParam = getRefParam(ctx, (val as SerovalIndexedValueNode).i);
+      markSerializerRef(ctx.base, source.i);
       // Strict identifier check, make sure
       // that it isn't numeric (except NaN)
       if (isIdentifier && check !== check) {
-        this.createObjectAssign(source.i, key, serialized);
-      } else {
-        this.createArrayAssign(
-          source.i,
-          isIdentifier ? key : '"' + key + '"',
-          serialized,
-        );
-      }
-    } else {
-      const parentAssignment = this.assignments;
-      this.assignments = mainAssignments;
-      if (isIdentifier && check !== check) {
-        this.createObjectAssign(source.i, key, serialized);
+        createObjectAssign(ctx, source.i, key, refParam);
       } else {
-        this.createArrayAssign(
+        createArrayAssign(
+          ctx,
           source.i,
           isIdentifier ? key : '"' + key + '"',
-          serialized,
+          refParam,
         );
       }
-      this.assignments = parentAssignment;
+      return '';
     }
+    return (isIdentifier ? key : '"' + key + '"') + ':' + serialize(ctx, val);
   }
+  return '[' + serialize(ctx, key) + ']:' + serialize(ctx, val);
+}
 
-  protected serializeAssignment(
-    source: SerovalNodeWithProperties,
-    mainAssignments: Assignment[],
-    key: SerovalObjectRecordKey,
-    value: SerovalNode,
-  ): void {
-    if (typeof key === 'string') {
-      this.serializeStringKeyAssignment(source, mainAssignments, key, value);
-    } else {
-      const parent = this.stack;
-      this.stack = [];
-      const serialized = this.serialize(value);
-      this.stack = parent;
-      const parentAssignment = this.assignments;
-      this.assignments = mainAssignments;
-      this.createArrayAssign(source.i, this.serialize(key), serialized);
-      this.assignments = parentAssignment;
+function serializeProperties(
+  ctx: SerializerContext,
+  source: SerovalNodeWithProperties,
+  record: SerovalObjectRecordNode,
+): string {
+  const len = record.s;
+  if (len) {
+    const keys = record.k;
+    const values = record.v;
+    ctx.base.stack.push(source.i);
+    let result = serializeProperty(ctx, source, keys[0], values[0]);
+    for (let i = 1, item = result; i < len; i++) {
+      item = serializeProperty(ctx, source, keys[i], values[i]);
+      result += (item && result && ',') + item;
     }
+    ctx.base.stack.pop();
+    return '{' + result + '}';
   }
+  return '{}';
+}
 
-  protected serializeAssignments(
-    source: SerovalNodeWithProperties,
-    node: SerovalObjectRecordNode,
-  ): string | undefined {
-    const len = node.s;
-    if (len) {
-      const mainAssignments: Assignment[] = [];
-      const keys = node.k;
-      const values = node.v;
-      this.stack.push(source.i);
-      for (let i = 0; i < len; i++) {
-        this.serializeAssignment(source, mainAssignments, keys[i], values[i]);
-      }
-      this.stack.pop();
-      return resolveAssignments(mainAssignments);
-    }
-    return NIL;
+function serializeObject(
+  ctx: SerializerContext,
+  node: SerovalObjectNode,
+): string {
+  pushObjectFlag(ctx, node.o, node.i);
+  return serializeProperties(ctx, node, node.p);
+}
+
+function serializeWithObjectAssign(
+  ctx: SerializerContext,
+  source: SerovalNodeWithProperties,
+  value: SerovalObjectRecordNode,
+  serialized: string,
+): string {
+  const fields = serializeProperties(ctx, source, value);
+  if (fields !== '{}') {
+    return 'Object.assign(' + serialized + ',' + fields + ')';
   }
+  return serialized;
+}
 
-  protected serializeDictionary(
-    node: SerovalNodeWithProperties,
-    init: string,
-  ): string {
-    if (node.p) {
-      if (this.features & Feature.ObjectAssign) {
-        init = this.serializeWithObjectAssign(node, node.p, init);
-      } else {
-        this.markRef(node.i);
-        const assignments = this.serializeAssignments(node, node.p);
-        if (assignments) {
-          return (
-            '(' +
-            this.assignIndexedValue(node.i, init) +
-            ',' +
-            assignments +
-            this.getRefParam(node.i) +
-            ')'
-          );
-        }
-      }
+function serializeStringKeyAssignment(
+  ctx: SerializerContext,
+  source: SerovalNodeWithProperties,
+  mainAssignments: Assignment[],
+  key: string,
+  value: SerovalNode,
+): void {
+  const base = ctx.base;
+  const serialized = serialize(ctx, value);
+  const check = Number(key);
+  const isIdentifier =
+    // Test if key is a valid positive number or JS identifier
+    // so that we don't have to serialize the key and wrap with brackets
+    (check >= 0 &&
+      // It's also important to consider that if the key is
+      // indeed numeric, we need to make sure that when
+      // converted back into a string, it's still the same
+      // to the original key. This allows us to differentiate
+      // keys that has numeric formats but in a different
+      // format, which can cause unintentional key declaration
+      // Example: { 0x1: 1 } vs { '0x1': 1 }
+      check.toString() === key) ||
+    isValidIdentifier(key);
+  if (isIndexedValueInStack(base, value)) {
+    // Strict identifier check, make sure
+    // that it isn't numeric (except NaN)
+    if (isIdentifier && check !== check) {
+      createObjectAssign(ctx, source.i, key, serialized);
+    } else {
+      createArrayAssign(
+        ctx,
+        source.i,
+        isIdentifier ? key : '"' + key + '"',
+        serialized,
+      );
+    }
+  } else {
+    const parentAssignment = base.assignments;
+    base.assignments = mainAssignments;
+    if (isIdentifier && check !== check) {
+      createObjectAssign(ctx, source.i, key, serialized);
+    } else {
+      createArrayAssign(
+        ctx,
+        source.i,
+        isIdentifier ? key : '"' + key + '"',
+        serialized,
+      );
     }
-    return this.assignIndexedValue(node.i, init);
+    base.assignments = parentAssignment;
   }
+}
 
-  protected serializeNullConstructor(node: SerovalNullConstructorNode): string {
-    this.pushObjectFlag(node.o, node.i);
-    return this.serializeDictionary(node, NULL_CONSTRUCTOR);
+function serializeAssignment(
+  ctx: SerializerContext,
+  source: SerovalNodeWithProperties,
+  mainAssignments: Assignment[],
+  key: SerovalObjectRecordKey,
+  value: SerovalNode,
+): void {
+  if (typeof key === 'string') {
+    serializeStringKeyAssignment(ctx, source, mainAssignments, key, value);
+  } else {
+    const base = ctx.base;
+    const parent = base.stack;
+    base.stack = [];
+    const serialized = serialize(ctx, value);
+    base.stack = parent;
+    const parentAssignment = base.assignments;
+    base.assignments = mainAssignments;
+    createArrayAssign(ctx, source.i, serialize(ctx, key), serialized);
+    base.assignments = parentAssignment;
   }
+}
 
-  protected serializeDate(node: SerovalDateNode): string {
-    return this.assignIndexedValue(node.i, 'new Date("' + node.s + '")');
+function serializeAssignments(
+  ctx: SerializerContext,
+  source: SerovalNodeWithProperties,
+  node: SerovalObjectRecordNode,
+): string | undefined {
+  const len = node.s;
+  if (len) {
+    const mainAssignments: Assignment[] = [];
+    const keys = node.k;
+    const values = node.v;
+    ctx.base.stack.push(source.i);
+    for (let i = 0; i < len; i++) {
+      serializeAssignment(ctx, source, mainAssignments, keys[i], values[i]);
+    }
+    ctx.base.stack.pop();
+    return resolveAssignments(mainAssignments);
   }
+  return NIL;
+}
 
-  protected serializeRegExp(node: SerovalRegExpNode): string {
-    return this.assignIndexedValue(node.i, '/' + node.c + '/' + node.m);
+function serializeDictionary(
+  ctx: SerializerContext,
+  node: SerovalNodeWithProperties,
+  init: string,
+): string {
+  if (node.p) {
+    const base = ctx.base;
+    if (base.features & Feature.ObjectAssign) {
+      init = serializeWithObjectAssign(ctx, node, node.p, init);
+    } else {
+      markSerializerRef(base, node.i);
+      const assignments = serializeAssignments(ctx, node, node.p);
+      if (assignments) {
+        return (
+          '(' +
+          assignIndexedValue(ctx, node.i, init) +
+          ',' +
+          assignments +
+          getRefParam(ctx, node.i) +
+          ')'
+        );
+      }
+    }
   }
+  return init;
+}
 
-  protected serializeSetItem(id: number, item: SerovalNode): string {
-    if (this.isIndexedValueInStack(item)) {
-      this.markRef(id);
-      this.createAddAssignment(
-        id,
-        this.getRefParam((item as SerovalIndexedValueNode).i),
-      );
-      return '';
-    }
-    return this.serialize(item);
+function serializeNullConstructor(
+  ctx: SerializerContext,
+  node: SerovalNullConstructorNode,
+): string {
+  pushObjectFlag(ctx, node.o, node.i);
+  return serializeDictionary(ctx, node, NULL_CONSTRUCTOR);
+}
+
+function serializeDate(node: SerovalDateNode): string {
+  return 'new Date("' + node.s + '")';
+}
+
+function serializeRegExp(node: SerovalRegExpNode): string {
+  return '/' + node.c + '/' + node.m;
+}
+
+function serializeSetItem(
+  ctx: SerializerContext,
+  id: number,
+  item: SerovalNode,
+): string {
+  const base = ctx.base;
+  if (isIndexedValueInStack(base, item)) {
+    markSerializerRef(base, id);
+    createAddAssignment(
+      ctx,
+      id,
+      getRefParam(ctx, (item as SerovalIndexedValueNode).i),
+    );
+    return '';
   }
+  return serialize(ctx, item);
+}
 
-  protected serializeSet(node: SerovalSetNode): string {
-    let serialized = SET_CONSTRUCTOR;
-    const size = node.l;
-    const id = node.i;
-    if (size) {
-      const items = node.a;
-      this.stack.push(id);
-      let result = this.serializeSetItem(id, items[0]);
-      for (let i = 1, item = result; i < size; i++) {
-        item = this.serializeSetItem(id, items[i]);
-        result += (item && result && ',') + item;
-      }
-      this.stack.pop();
-      if (result) {
-        serialized += '([' + result + '])';
-      }
+function serializeSet(ctx: SerializerContext, node: SerovalSetNode): string {
+  let serialized = SET_CONSTRUCTOR;
+  const size = node.l;
+  const id = node.i;
+  if (size) {
+    const items = node.a;
+    ctx.base.stack.push(id);
+    let result = serializeSetItem(ctx, id, items[0]);
+    for (let i = 1, item = result; i < size; i++) {
+      item = serializeSetItem(ctx, id, items[i]);
+      result += (item && result && ',') + item;
+    }
+    ctx.base.stack.pop();
+    if (result) {
+      serialized += '([' + result + '])';
     }
-    return this.assignIndexedValue(id, serialized);
   }
+  return serialized;
+}
 
-  protected serializeMapEntry(
-    id: number,
-    key: SerovalNode,
-    val: SerovalNode,
-    sentinel: string,
-  ): string {
-    if (this.isIndexedValueInStack(key)) {
-      // Create reference for the map instance
-      const keyRef = this.getRefParam((key as SerovalIndexedValueNode).i);
-      this.markRef(id);
-      // Check if value is a parent
-      if (this.isIndexedValueInStack(val)) {
-        const valueRef = this.getRefParam((val as SerovalIndexedValueNode).i);
-        // Register an assignment since
-        // both key and value are a parent of this
-        // Map instance
-        this.createSetAssignment(id, keyRef, valueRef);
-        return '';
-      }
-      // 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
-      if (
-        val.t !== SerovalNodeType.IndexedValue &&
-        val.i != null &&
-        this.isMarked(val.i)
-      ) {
-        // We use a trick here using sequence (or comma) expressions
-        // basically we serialize the intended object in place WITHOUT
-        // actually returning it, this is by returning a placeholder
-        // value that we will remove sometime after.
-        const serialized =
-          '(' + this.serialize(val) + ',[' + sentinel + ',' + sentinel + '])';
-        this.createSetAssignment(id, keyRef, this.getRefParam(val.i));
-        this.createDeleteAssignment(id, sentinel);
-        return serialized;
-      }
-      const parent = this.stack;
-      this.stack = [];
-      this.createSetAssignment(id, keyRef, this.serialize(val));
-      this.stack = parent;
+function serializeMapEntry(
+  ctx: SerializerContext,
+  id: number,
+  key: SerovalNode,
+  val: SerovalNode,
+  sentinel: string,
+): string {
+  const base = ctx.base;
+  if (isIndexedValueInStack(base, key)) {
+    // Create reference for the map instance
+    const keyRef = getRefParam(ctx, (key as SerovalIndexedValueNode).i);
+    markSerializerRef(base, id);
+    // Check if value is a parent
+    if (isIndexedValueInStack(base, val)) {
+      const valueRef = getRefParam(ctx, (val as SerovalIndexedValueNode).i);
+      // Register an assignment since
+      // both key and value are a parent of this
+      // Map instance
+      createSetAssignment(ctx, id, keyRef, valueRef);
       return '';
     }
-    if (this.isIndexedValueInStack(val)) {
-      // Create ref for the Map instance
-      const valueRef = this.getRefParam((val as SerovalIndexedValueNode).i);
-      this.markRef(id);
-      if (
-        key.t !== SerovalNodeType.IndexedValue &&
-        key.i != null &&
-        this.isMarked(key.i)
-      ) {
-        const serialized =
-          '(' + this.serialize(key) + ',[' + sentinel + ',' + sentinel + '])';
-        this.createSetAssignment(id, this.getRefParam(key.i), valueRef);
-        this.createDeleteAssignment(id, sentinel);
-        return serialized;
-      }
-      // Reset stack for the key serialization
-      const parent = this.stack;
-      this.stack = [];
-      this.createSetAssignment(id, this.serialize(key), valueRef);
-      this.stack = parent;
-      return '';
+    // 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
+    if (
+      val.t !== SerovalNodeType.IndexedValue &&
+      val.i != null &&
+      isSerializerRefMarked(base, val.i)
+    ) {
+      // We use a trick here using sequence (or comma) expressions
+      // basically we serialize the intended object in place WITHOUT
+      // actually returning it, this is by returning a placeholder
+      // value that we will remove sometime after.
+      const serialized =
+        '(' + serialize(ctx, val) + ',[' + sentinel + ',' + sentinel + '])';
+      createSetAssignment(ctx, id, keyRef, getRefParam(ctx, val.i));
+      createDeleteAssignment(ctx, id, sentinel);
+      return serialized;
     }
-
-    return '[' + this.serialize(key) + ',' + this.serialize(val) + ']';
+    const parent = base.stack;
+    base.stack = [];
+    createSetAssignment(ctx, id, keyRef, serialize(ctx, val));
+    base.stack = parent;
+    return '';
   }
-
-  protected serializeMap(node: SerovalMapNode): string {
-    let serialized = MAP_CONSTRUCTOR;
-    const size = node.e.s;
-    const id = node.i;
-    const sentinel = node.f;
-    const sentinelId = this.getRefParam(sentinel.i);
-    if (size) {
-      const keys = node.e.k;
-      const vals = node.e.v;
-      this.stack.push(id);
-      let result = this.serializeMapEntry(id, keys[0], vals[0], sentinelId);
-      for (let i = 1, item = result; i < size; i++) {
-        item = this.serializeMapEntry(id, keys[i], vals[i], sentinelId);
-        result += (item && result && ',') + item;
-      }
-      this.stack.pop();
-      // Check if there are any values
-      // so that the empty Map constructor
-      // can be used instead
-      if (result) {
-        serialized += '([' + result + '])';
-      }
-    }
-    if (sentinel.t === SerovalNodeType.SpecialReference) {
-      this.markRef(sentinel.i);
-      serialized = '(' + this.serialize(sentinel) + ',' + serialized + ')';
+  if (isIndexedValueInStack(base, val)) {
+    // Create ref for the Map instance
+    const valueRef = getRefParam(ctx, (val as SerovalIndexedValueNode).i);
+    markSerializerRef(base, id);
+    if (
+      key.t !== SerovalNodeType.IndexedValue &&
+      key.i != null &&
+      isSerializerRefMarked(base, key.i)
+    ) {
+      const serialized =
+        '(' + serialize(ctx, key) + ',[' + sentinel + ',' + sentinel + '])';
+      createSetAssignment(ctx, id, getRefParam(ctx, key.i), valueRef);
+      createDeleteAssignment(ctx, id, sentinel);
+      return serialized;
     }
-    return this.assignIndexedValue(id, serialized);
+    // Reset stack for the key serialization
+    const parent = base.stack;
+    base.stack = [];
+    createSetAssignment(ctx, id, serialize(ctx, key), valueRef);
+    base.stack = parent;
+    return '';
   }
 
-  protected serializeArrayBuffer(node: SerovalArrayBufferNode): string {
-    let result = 'new Uint8Array(';
-    const buffer = node.s;
-    const len = buffer.length;
-    if (len) {
-      result += '[' + buffer[0];
-      for (let i = 1; i < len; i++) {
-        result += ',' + buffer[i];
-      }
-      result += ']';
+  return '[' + serialize(ctx, key) + ',' + serialize(ctx, val) + ']';
+}
+
+function serializeMap(ctx: SerializerContext, node: SerovalMapNode): string {
+  let serialized = MAP_CONSTRUCTOR;
+  const size = node.e.s;
+  const id = node.i;
+  const sentinel = node.f;
+  const sentinelId = getRefParam(ctx, sentinel.i);
+  const base = ctx.base;
+  if (size) {
+    const keys = node.e.k;
+    const vals = node.e.v;
+    base.stack.push(id);
+    let result = serializeMapEntry(ctx, id, keys[0], vals[0], sentinelId);
+    for (let i = 1, item = result; i < size; i++) {
+      item = serializeMapEntry(ctx, id, keys[i], vals[i], sentinelId);
+      result += (item && result && ',') + item;
+    }
+    base.stack.pop();
+    // Check if there are any values
+    // so that the empty Map constructor
+    // can be used instead
+    if (result) {
+      serialized += '([' + result + '])';
     }
-    return this.assignIndexedValue(node.i, result + ').buffer');
   }
-
-  protected serializeTypedArray(
-    node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
-  ): string {
-    return this.assignIndexedValue(
-      node.i,
-      'new ' +
-        node.c +
-        '(' +
-        this.serialize(node.f) +
-        ',' +
-        node.b +
-        ',' +
-        node.l +
-        ')',
-    );
+  if (sentinel.t === SerovalNodeType.SpecialReference) {
+    markSerializerRef(base, sentinel.i);
+    serialized = '(' + serialize(ctx, sentinel) + ',' + serialized + ')';
   }
+  return serialized;
+}
 
-  protected serializeDataView(node: SerovalDataViewNode): string {
-    return this.assignIndexedValue(
-      node.i,
-      'new DataView(' +
-        this.serialize(node.f) +
-        ',' +
-        node.b +
-        ',' +
-        node.l +
-        ')',
-    );
-  }
+function serializeArrayBuffer(
+  ctx: SerializerContext,
+  node: SerovalArrayBufferNode,
+): string {
+  return getConstructor(ctx, node.f) + '(' + node.l + ',"' + node.s + '")';
+}
 
-  protected serializeAggregateError(node: SerovalAggregateErrorNode): string {
-    const id = node.i;
-    // `AggregateError` might've been extended
-    // either through class or custom properties
-    // Make sure to assign extra properties
-    this.stack.push(id);
-    const serialized = this.serializeDictionary(
-      node,
-      'new AggregateError([],"' + node.m + '")',
-    );
-    this.stack.pop();
-    return serialized;
-  }
+function serializeTypedArray(
+  ctx: SerializerContext,
+  node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
+): string {
+  return (
+    'new ' +
+    node.c +
+    '(' +
+    serialize(ctx, node.f) +
+    ',' +
+    node.b +
+    ',' +
+    node.l +
+    ')'
+  );
+}
 
-  protected serializeError(node: SerovalErrorNode): string {
-    return this.serializeDictionary(
-      node,
-      'new ' + ERROR_CONSTRUCTOR_STRING[node.s] + '("' + node.m + '")',
-    );
+function serializeDataView(
+  ctx: SerializerContext,
+  node: SerovalDataViewNode,
+): string {
+  return (
+    'new DataView(' + serialize(ctx, node.f) + ',' + node.b + ',' + node.l + ')'
+  );
+}
+
+function serializeAggregateError(
+  ctx: SerializerContext,
+  node: SerovalAggregateErrorNode,
+): string {
+  const id = node.i;
+  // `AggregateError` might've been extended
+  // either through class or custom properties
+  // Make sure to assign extra properties
+  ctx.base.stack.push(id);
+  const serialized = serializeDictionary(
+    ctx,
+    node,
+    'new AggregateError([],"' + node.m + '")',
+  );
+  ctx.base.stack.pop();
+  return serialized;
+}
+
+function serializeError(
+  ctx: SerializerContext,
+  node: SerovalErrorNode,
+): string {
+  return serializeDictionary(
+    ctx,
+    node,
+    'new ' + ERROR_CONSTRUCTOR_STRING[node.s] + '("' + node.m + '")',
+  );
+}
+
+function serializePromise(
+  ctx: SerializerContext,
+  node: SerovalPromiseNode,
+): string {
+  let serialized: string;
+  // Check if resolved value is a parent expression
+  const fulfilled = node.f;
+  const id = node.i;
+  const promiseConstructor = node.s ? PROMISE_RESOLVE : PROMISE_REJECT;
+  const base = ctx.base;
+  if (isIndexedValueInStack(base, fulfilled)) {
+    // A Promise trick, reference the value
+    // inside the `then` expression so that
+    // the Promise evaluates after the parent
+    // has initialized
+    const ref = getRefParam(ctx, (fulfilled as SerovalIndexedValueNode).i);
+    serialized =
+      promiseConstructor +
+      (node.s
+        ? '().then(' + createFunction([], ref) + ')'
+        : '().catch(' + createEffectfulFunction([], 'throw ' + ref) + ')');
+  } else {
+    base.stack.push(id);
+    const result = serialize(ctx, fulfilled);
+    base.stack.pop();
+    // just inline the value/reference here
+    serialized = promiseConstructor + '(' + result + ')';
   }
+  return serialized;
+}
 
-  protected serializePromise(node: SerovalPromiseNode): string {
-    let serialized: string;
-    // Check if resolved value is a parent expression
-    const fulfilled = node.f;
-    const id = node.i;
-    const promiseConstructor = node.s ? PROMISE_RESOLVE : PROMISE_REJECT;
-    if (this.isIndexedValueInStack(fulfilled)) {
-      // A Promise trick, reference the value
-      // inside the `then` expression so that
-      // the Promise evaluates after the parent
-      // has initialized
-      const ref = this.getRefParam((fulfilled as SerovalIndexedValueNode).i);
-      serialized =
-        promiseConstructor +
-        (node.s
-          ? '().then(' + this.createFunction([], ref) + ')'
-          : '().catch(' +
-            this.createEffectfulFunction([], 'throw ' + ref) +
-            ')');
-    } else {
-      this.stack.push(id);
-      const result = this.serialize(fulfilled);
-      this.stack.pop();
-      // just inline the value/reference here
-      serialized = promiseConstructor + '(' + result + ')';
-    }
-    return this.assignIndexedValue(id, serialized);
+function serializeBoxed(
+  ctx: SerializerContext,
+  node: SerovalBoxedNode,
+): string {
+  return 'Object(' + serialize(ctx, node.f) + ')';
+}
+
+function getConstructor(
+  ctx: SerializerContext,
+  node: SerovalNodeWithID,
+): string {
+  const current = serialize(ctx, node);
+  return node.t === SerovalNodeType.IndexedValue
+    ? current
+    : '(' + current + ')';
+}
+
+function serializePromiseConstructor(
+  ctx: SerializerContext,
+  node: SerovalPromiseConstructorNode,
+): string {
+  if (ctx.mode === SerovalMode.Vanilla) {
+    throw new SerovalUnsupportedNodeError(node);
   }
+  const resolver = assignIndexedValue(
+    ctx,
+    node.s,
+    getConstructor(ctx, node.f) + '()',
+  );
+  return '(' + resolver + ').p';
+}
 
-  protected serializeWellKnownSymbol(node: SerovalWKSymbolNode): string {
-    return this.assignIndexedValue(node.i, SYMBOL_STRING[node.s]);
+function serializePromiseResolve(
+  ctx: SerializerContext,
+  node: SerovalPromiseResolveNode,
+): string {
+  if (ctx.mode === SerovalMode.Vanilla) {
+    throw new SerovalUnsupportedNodeError(node);
   }
+  return (
+    getConstructor(ctx, node.a[0]) +
+    '(' +
+    getRefParam(ctx, node.i) +
+    ',' +
+    serialize(ctx, node.a[1]) +
+    ')'
+  );
+}
 
-  protected serializeBoxed(node: SerovalBoxedNode): string {
-    return this.assignIndexedValue(
-      node.i,
-      'Object(' + this.serialize(node.f) + ')',
-    );
+function serializePromiseReject(
+  ctx: SerializerContext,
+  node: SerovalPromiseRejectNode,
+): string {
+  if (ctx.mode === SerovalMode.Vanilla) {
+    throw new SerovalUnsupportedNodeError(node);
   }
+  return (
+    getConstructor(ctx, node.a[0]) +
+    '(' +
+    getRefParam(ctx, node.i) +
+    ',' +
+    serialize(ctx, node.a[1]) +
+    ')'
+  );
+}
 
-  protected serializePlugin(node: SerovalPluginNode): string {
-    const currentPlugins = this.plugins;
-    if (currentPlugins) {
-      for (let i = 0, len = currentPlugins.length; i < len; i++) {
-        const plugin = currentPlugins[i];
-        if (plugin.tag === node.c) {
-          return this.assignIndexedValue(
-            node.i,
-            plugin.serialize(node.s, this, {
-              id: node.i,
-            }),
-          );
+function serializePlugin(
+  ctx: SerializerContext,
+  node: SerovalPluginNode,
+): string {
+  const currentPlugins = ctx.base.plugins;
+  if (currentPlugins) {
+    for (let i = 0, len = currentPlugins.length; i < len; i++) {
+      const plugin = currentPlugins[i];
+      if (plugin.tag === node.c) {
+        if (ctx.child == null) {
+          ctx.child = new SerializePluginContext(ctx);
         }
+        return plugin.serialize(node.s, ctx.child, {
+          id: node.i,
+        });
       }
     }
-    throw new SerovalMissingPluginError(node.c);
   }
+  throw new SerovalMissingPluginError(node.c);
+}
 
-  private getConstructor(node: SerovalNodeWithID): string {
-    const current = this.serialize(node);
-    return current === this.getRefParam(node.i) ? current : '(' + current + ')';
+function serializeIteratorFactory(
+  ctx: SerializerContext,
+  node: SerovalIteratorFactoryNode,
+): string {
+  let result = '';
+  let initialized = false;
+  if (node.f.t !== SerovalNodeType.IndexedValue) {
+    markSerializerRef(ctx.base, node.f.i);
+    result = '(' + serialize(ctx, node.f) + ',';
+    initialized = true;
   }
-
-  protected serializePromiseConstructor(
-    node: SerovalPromiseConstructorNode,
-  ): string {
-    const resolver = this.assignIndexedValue(node.s, '{p:0,s:0,f:0}');
-    return this.assignIndexedValue(
-      node.i,
-      this.getConstructor(node.f) + '(' + resolver + ')',
-    );
+  result += assignIndexedValue(
+    ctx,
+    node.i,
+    '(' +
+      SERIALIZED_ITERATOR_CONSTRUCTOR +
+      ')(' +
+      getRefParam(ctx, node.f.i) +
+      ')',
+  );
+  if (initialized) {
+    result += ')';
   }
+  return result;
+}
 
-  protected serializePromiseResolve(node: SerovalPromiseResolveNode): string {
-    return (
-      this.getConstructor(node.a[0]) +
-      '(' +
-      this.getRefParam(node.i) +
-      ',' +
-      this.serialize(node.a[1]) +
-      ')'
-    );
-  }
+function serializeIteratorFactoryInstance(
+  ctx: SerializerContext,
+  node: SerovalIteratorFactoryInstanceNode,
+): string {
+  return getConstructor(ctx, node.a[0]) + '(' + serialize(ctx, node.a[1]) + ')';
+}
 
-  protected serializePromiseReject(node: SerovalPromiseRejectNode): string {
-    return (
-      this.getConstructor(node.a[0]) +
-      '(' +
-      this.getRefParam(node.i) +
-      ',' +
-      this.serialize(node.a[1]) +
-      ')'
-    );
-  }
+function serializeAsyncIteratorFactory(
+  ctx: SerializerContext,
+  node: SerovalAsyncIteratorFactoryNode,
+): string {
+  const promise = node.a[0];
+  const symbol = node.a[1];
+  const base = ctx.base;
 
-  protected serializeSpecialReference(
-    node: SerovalSpecialReferenceNode,
-  ): string {
-    return this.assignIndexedValue(
-      node.i,
-      serializeSpecialReferenceValue(this.features, node.s),
-    );
-  }
+  let result = '';
 
-  protected serializeIteratorFactory(node: SerovalIteratorFactoryNode): string {
-    let result = '';
-    let initialized = false;
-    if (node.f.t !== SerovalNodeType.IndexedValue) {
-      this.markRef(node.f.i);
-      result = '(' + this.serialize(node.f) + ',';
-      initialized = true;
-    }
-    result += this.assignIndexedValue(
-      node.i,
-      this.createFunction(
-        ['s'],
-        this.createFunction(
-          ['i', 'c', 'd', 't'],
-          '(i=0,t={[' +
-            this.getRefParam(node.f.i) +
-            ']:' +
-            this.createFunction([], 't') +
-            ',next:' +
-            this.createEffectfulFunction(
-              [],
-              'if(i>s.d)return{done:!0,value:void 0};if(d=s.v[c=i++],c===s.t)throw d;return{done:c===s.d,value:d}',
-            ) +
-            '})',
-        ),
-      ),
-    );
-    if (initialized) {
-      result += ')';
-    }
-    return result;
+  if (promise.t !== SerovalNodeType.IndexedValue) {
+    markSerializerRef(base, promise.i);
+    result += '(' + serialize(ctx, promise);
+  }
+  if (symbol.t !== SerovalNodeType.IndexedValue) {
+    markSerializerRef(base, symbol.i);
+    result += (result ? ',' : '(') + serialize(ctx, symbol);
+  }
+  if (result) {
+    result += ',';
   }
 
-  protected serializeIteratorFactoryInstance(
-    node: SerovalIteratorFactoryInstanceNode,
-  ): string {
-    return (
-      this.getConstructor(node.a[0]) + '(' + this.serialize(node.a[1]) + ')'
-    );
+  const iterator = assignIndexedValue(
+    ctx,
+    node.i,
+    '(' +
+      SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR +
+      ')(' +
+      getRefParam(ctx, symbol.i) +
+      ',' +
+      getRefParam(ctx, promise.i) +
+      ')',
+  );
+
+  if (result) {
+    return result + iterator + ')';
   }
 
-  protected serializeAsyncIteratorFactory(
-    node: SerovalAsyncIteratorFactoryNode,
-  ): string {
-    const promise = node.a[0];
-    const symbol = node.a[1];
+  return iterator;
+}
 
-    let result = '';
+function serializeAsyncIteratorFactoryInstance(
+  ctx: SerializerContext,
+  node: SerovalAsyncIteratorFactoryInstanceNode,
+): string {
+  return getConstructor(ctx, node.a[0]) + '(' + serialize(ctx, node.a[1]) + ')';
+}
 
-    if (promise.t !== SerovalNodeType.IndexedValue) {
-      this.markRef(promise.i);
-      result += '(' + this.serialize(promise);
-    }
-    if (symbol.t !== SerovalNodeType.IndexedValue) {
-      this.markRef(symbol.i);
-      result += (result ? ',' : '(') + this.serialize(symbol);
-    }
-    if (result) {
-      result += ',';
+function serializeStreamConstructor(
+  ctx: SerializerContext,
+  node: SerovalStreamConstructorNode,
+): string {
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    getConstructor(ctx, node.f) + '()',
+  );
+  const len = node.a.length;
+  if (len) {
+    let values = serialize(ctx, node.a[0]);
+    for (let i = 1; i < len; i++) {
+      values += ',' + serialize(ctx, node.a[i]);
     }
+    return '(' + result + ',' + values + ',' + getRefParam(ctx, node.i) + ')';
+  }
+  return result;
+}
 
-    const iterator = this.assignIndexedValue(
-      node.i,
-      this.createFunction(
-        ['s'],
-        this.createFunction(
-          ['b', 'c', 'p', 'd', 'e', 't', 'f'],
-          /**
-           * b = resolved values
-           * c = b size
-           * p = pending promises
-           * d = index where the resolved value stops
-           * e = if the last value is a throw
-           * t = placeholder variable
-           * f = finalize
-           */
-          '(b=[],c=0,p=[],d=-1,e=!1,f=' +
-            this.createEffectfulFunction(
-              ['i', 'l'],
-              'for(i=0,l=p.length;i<l;i++)p[i].s({done:!0,value:void 0})',
-            ) +
-            ',s.on({next:' +
-            this.createEffectfulFunction(
-              ['v', 't'],
-              'if(t=p.shift())t.s({done:!1,value:v});b.push(v)',
-            ) +
-            ',throw:' +
-            this.createEffectfulFunction(
-              ['v', 't'],
-              'if(t=p.shift())t.f(v);f(),d=b.length,e=!0,b.push(v)',
-            ) +
-            ',return:' +
-            this.createEffectfulFunction(
-              ['v', 't'],
-              'if(t=p.shift())t.s({done:!0,value:v});f(),d=b.length,b.push(v)',
-            ) +
-            '}),t={[' +
-            this.getRefParam(symbol.i) +
-            ']:' +
-            this.createFunction([], 't.p') +
-            ',next:' +
-            this.createEffectfulFunction(
-              ['i', 't', 'v'],
-              'if(d===-1){return((i=c++)>=b.length)?(' +
-                this.getRefParam(promise.i) +
-                '(t={p:0,s:0,f:0}),p.push(t),t.p):{done:!1,value:b[i]}}if(c>d)return{done:!0,value:void 0};if(v=b[i=c++],i!==d)return{done:!1,value:v};if(e)throw v;return{done:!0,value:v}',
-            ) +
-            '})',
-        ),
-      ),
-    );
+function serializeStreamNext(
+  ctx: SerializerContext,
+  node: SerovalStreamNextNode,
+): string {
+  return getRefParam(ctx, node.i) + '.next(' + serialize(ctx, node.f) + ')';
+}
 
-    if (result) {
-      return result + iterator + ')';
-    }
+function serializeStreamThrow(
+  ctx: SerializerContext,
+  node: SerovalStreamThrowNode,
+): string {
+  return getRefParam(ctx, node.i) + '.throw(' + serialize(ctx, node.f) + ')';
+}
 
-    return iterator;
-  }
+function serializeStreamReturn(
+  ctx: SerializerContext,
+  node: SerovalStreamReturnNode,
+): string {
+  return getRefParam(ctx, node.i) + '.return(' + serialize(ctx, node.f) + ')';
+}
 
-  protected serializeAsyncIteratorFactoryInstance(
-    node: SerovalAsyncIteratorFactoryInstanceNode,
-  ): string {
-    return (
-      this.getConstructor(node.a[0]) + '(' + this.serialize(node.a[1]) + ')'
-    );
+function serializeAssignable(
+  ctx: SerializerContext,
+  node: SerovalNode,
+): string {
+  switch (node.t) {
+    case SerovalNodeType.WKSymbol:
+      return SYMBOL_STRING[node.s];
+    case SerovalNodeType.Reference:
+      return serializeReference(node);
+    case SerovalNodeType.Array:
+      return serializeArray(ctx, node);
+    case SerovalNodeType.Object:
+      return serializeObject(ctx, node);
+    case SerovalNodeType.NullConstructor:
+      return serializeNullConstructor(ctx, node);
+    case SerovalNodeType.Date:
+      return serializeDate(node);
+    case SerovalNodeType.RegExp:
+      return serializeRegExp(node);
+    case SerovalNodeType.Set:
+      return serializeSet(ctx, node);
+    case SerovalNodeType.Map:
+      return serializeMap(ctx, node);
+    case SerovalNodeType.ArrayBuffer:
+      return serializeArrayBuffer(ctx, node);
+    case SerovalNodeType.BigIntTypedArray:
+    case SerovalNodeType.TypedArray:
+      return serializeTypedArray(ctx, node);
+    case SerovalNodeType.DataView:
+      return serializeDataView(ctx, node);
+    case SerovalNodeType.AggregateError:
+      return serializeAggregateError(ctx, node);
+    case SerovalNodeType.Error:
+      return serializeError(ctx, node);
+    case SerovalNodeType.Promise:
+      return serializePromise(ctx, node);
+    case SerovalNodeType.Boxed:
+      return serializeBoxed(ctx, node);
+    case SerovalNodeType.PromiseConstructor:
+      return serializePromiseConstructor(ctx, node);
+    case SerovalNodeType.Plugin:
+      return serializePlugin(ctx, node);
+    case SerovalNodeType.SpecialReference:
+      return SPECIAL_REF_STRING[node.s];
+    default:
+      throw new SerovalUnsupportedNodeError(node);
   }
+}
 
-  protected serializeStreamConstructor(
-    node: SerovalStreamConstructorNode,
-  ): string {
-    const result = this.assignIndexedValue(
-      node.i,
-      this.getConstructor(node.f) + '()',
-    );
-    const len = node.a.length;
-    if (len) {
-      let values = this.serialize(node.a[0]);
-      for (let i = 1; i < len; i++) {
-        values += ',' + this.serialize(node.a[i]);
-      }
-      return '(' + result + ',' + values + ',' + this.getRefParam(node.i) + ')';
-    }
-    return result;
+function serialize(ctx: SerializerContext, node: SerovalNode): string {
+  switch (node.t) {
+    case SerovalNodeType.Constant:
+      return CONSTANT_STRING[node.s];
+    case SerovalNodeType.Number:
+      return '' + node.s;
+    case SerovalNodeType.String:
+      return '"' + node.s + '"';
+    case SerovalNodeType.BigInt:
+      return node.s + 'n';
+    case SerovalNodeType.IndexedValue:
+      return getRefParam(ctx, node.i);
+    case SerovalNodeType.PromiseSuccess:
+      return serializePromiseResolve(ctx, node);
+    case SerovalNodeType.PromiseFailure:
+      return serializePromiseReject(ctx, node);
+    case SerovalNodeType.IteratorFactory:
+      return serializeIteratorFactory(ctx, node);
+    case SerovalNodeType.IteratorFactoryInstance:
+      return serializeIteratorFactoryInstance(ctx, node);
+    case SerovalNodeType.AsyncIteratorFactory:
+      return serializeAsyncIteratorFactory(ctx, node);
+    case SerovalNodeType.AsyncIteratorFactoryInstance:
+      return serializeAsyncIteratorFactoryInstance(ctx, node);
+    case SerovalNodeType.StreamConstructor:
+      return serializeStreamConstructor(ctx, node);
+    case SerovalNodeType.StreamNext:
+      return serializeStreamNext(ctx, node);
+    case SerovalNodeType.StreamThrow:
+      return serializeStreamThrow(ctx, node);
+    case SerovalNodeType.StreamReturn:
+      return serializeStreamReturn(ctx, node);
+    default:
+      return assignIndexedValue(ctx, node.i, serializeAssignable(ctx, node));
   }
+}
 
-  protected serializeStreamNext(node: SerovalStreamNextNode): string {
-    return this.getRefParam(node.i) + '.next(' + this.serialize(node.f) + ')';
+export function serializeRoot(
+  ctx: SerializerContext,
+  node: SerovalNode,
+): string {
+  try {
+    return serialize(ctx, node);
+  } catch (error) {
+    throw error instanceof SerovalSerializationError
+      ? error
+      : new SerovalSerializationError(error);
   }
+}
 
-  protected serializeStreamThrow(node: SerovalStreamThrowNode): string {
-    return this.getRefParam(node.i) + '.throw(' + this.serialize(node.f) + ')';
+export function serializeTopVanilla(
+  ctx: VanillaSerializerContext,
+  tree: SerovalNode,
+): string {
+  const result = serialize(ctx, tree);
+  // Shared references detected
+  if (tree.i != null && ctx.state.vars.length) {
+    const patches = resolvePatches(ctx.base);
+    let body = result;
+    if (patches) {
+      // Get (or create) a ref from the source
+      const index = getRefParam(ctx, tree.i);
+      body = result + ',' + patches + index;
+      if (!result.startsWith(index + '=')) {
+        body = index + '=' + body;
+      }
+      body = '(' + body + ')';
+    }
+    return '(' + createFunction(ctx.state.vars, body) + ')()';
   }
-
-  protected serializeStreamReturn(node: SerovalStreamReturnNode): string {
-    return this.getRefParam(node.i) + '.return(' + this.serialize(node.f) + ')';
+  if (tree.t === SerovalNodeType.Object) {
+    return '(' + result + ')';
   }
+  return result;
+}
 
-  serialize(node: SerovalNode): string {
-    try {
-      switch (node.t) {
-        case SerovalNodeType.Constant:
-          return CONSTANT_STRING[node.s];
-        case SerovalNodeType.Number:
-          return '' + node.s;
-        case SerovalNodeType.String:
-          return '"' + node.s + '"';
-        case SerovalNodeType.BigInt:
-          return node.s + 'n';
-        case SerovalNodeType.IndexedValue:
-          return this.getRefParam(node.i);
-        case SerovalNodeType.Reference:
-          return this.serializeReference(node);
-        case SerovalNodeType.Array:
-          return this.serializeArray(node);
-        case SerovalNodeType.Object:
-          return this.serializeObject(node);
-        case SerovalNodeType.NullConstructor:
-          return this.serializeNullConstructor(node);
-        case SerovalNodeType.Date:
-          return this.serializeDate(node);
-        case SerovalNodeType.RegExp:
-          return this.serializeRegExp(node);
-        case SerovalNodeType.Set:
-          return this.serializeSet(node);
-        case SerovalNodeType.Map:
-          return this.serializeMap(node);
-        case SerovalNodeType.ArrayBuffer:
-          return this.serializeArrayBuffer(node);
-        case SerovalNodeType.BigIntTypedArray:
-        case SerovalNodeType.TypedArray:
-          return this.serializeTypedArray(node);
-        case SerovalNodeType.DataView:
-          return this.serializeDataView(node);
-        case SerovalNodeType.AggregateError:
-          return this.serializeAggregateError(node);
-        case SerovalNodeType.Error:
-          return this.serializeError(node);
-        case SerovalNodeType.Promise:
-          return this.serializePromise(node);
-        case SerovalNodeType.WKSymbol:
-          return this.serializeWellKnownSymbol(node);
-        case SerovalNodeType.Boxed:
-          return this.serializeBoxed(node);
-        case SerovalNodeType.PromiseConstructor:
-          return this.serializePromiseConstructor(node);
-        case SerovalNodeType.PromiseSuccess:
-          return this.serializePromiseResolve(node);
-        case SerovalNodeType.PromiseFailure:
-          return this.serializePromiseReject(node);
-        case SerovalNodeType.Plugin:
-          return this.serializePlugin(node);
-        case SerovalNodeType.SpecialReference:
-          return this.serializeSpecialReference(node);
-        case SerovalNodeType.IteratorFactory:
-          return this.serializeIteratorFactory(node);
-        case SerovalNodeType.IteratorFactoryInstance:
-          return this.serializeIteratorFactoryInstance(node);
-        case SerovalNodeType.AsyncIteratorFactory:
-          return this.serializeAsyncIteratorFactory(node);
-        case SerovalNodeType.AsyncIteratorFactoryInstance:
-          return this.serializeAsyncIteratorFactoryInstance(node);
-        case SerovalNodeType.StreamConstructor:
-          return this.serializeStreamConstructor(node);
-        case SerovalNodeType.StreamNext:
-          return this.serializeStreamNext(node);
-        case SerovalNodeType.StreamThrow:
-          return this.serializeStreamThrow(node);
-        case SerovalNodeType.StreamReturn:
-          return this.serializeStreamReturn(node);
-        default:
-          throw new SerovalUnsupportedNodeError(node);
-      }
-    } catch (error) {
-      throw new SerovalSerializationError(error);
+export function serializeTopCross(
+  ctx: CrossSerializerContext,
+  tree: SerovalNode,
+): string {
+  // Get the serialized result
+  const result = serialize(ctx, tree);
+  // If the node is a non-reference, return
+  // the result immediately
+  const id = tree.i;
+  if (id == null) {
+    return result;
+  }
+  // Get the patches
+  const patches = resolvePatches(ctx.base);
+  // Get the variable that represents the root
+  const ref = getRefParam(ctx, id);
+  const scopeId = ctx.state.scopeId;
+  // Parameters needed for scoping
+  const params = scopeId == null ? '' : GLOBAL_CONTEXT_REFERENCES;
+  // If there are patches, append it after the result
+  const body = patches ? '(' + result + ',' + patches + ref + ')' : result;
+  // If there are no params, there's no need to generate a function
+  if (params === '') {
+    if (tree.t === SerovalNodeType.Object && !patches) {
+      return '(' + body + ')';
     }
+    return body;
   }
+  // Get the arguments for the IIFE
+  const args =
+    scopeId == null
+      ? '()'
+      : '(' +
+        GLOBAL_CONTEXT_REFERENCES +
+        '["' +
+        serializeString(scopeId) +
+        '"])';
+  // Create the IIFE
+  return '(' + createFunction([params], body) + ')' + args;
 }