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

package/dist/cjs/development/index.cjs

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,10 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 
 // src/index.ts
 var src_exports = {};
@@ -218,8 +213,9 @@ var platforms = [
   "samsung"
 ];
 function getPlatform(target) {
+  let platform;
   for (let i = 0, len = platforms.length; i < len; i++) {
-    const platform = target.substring(0, platforms[i].length);
+    platform = target.substring(0, platforms[i].length);
     if (platform === platforms[i]) {
       return platform;
     }
@@ -245,11 +241,14 @@ function getTargetVersions(targets) {
 function parseTargets(targets) {
   const parsed = getTargetVersions(targets);
   let flags = 0;
+  let base;
+  let flag;
+  let baseVersion;
   for (const key of Object.keys(VERSION_TABLE)) {
-    const base = VERSION_TABLE[key];
-    let flag = true;
+    base = VERSION_TABLE[key];
+    flag = true;
     for (const [platform, version] of parsed) {
-      const baseVersion = base[platform];
+      baseVersion = base[platform];
       flag = flag && !!baseVersion && compareVersion(baseVersion, version) <= 0;
     }
     if (flag) {
@@ -280,35 +279,27 @@ function getIdentifier(index) {
 var DEFAULT_OPTIONS = {
   target: "es2023"
 };
-var ParserContext = class {
-  constructor(options = {}) {
-    __publicField(this, "refs", /* @__PURE__ */ new Map());
-    __publicField(this, "markedRefs", {});
-    __publicField(this, "features");
-    const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
-    this.features = parseTargets(result.target);
-  }
-};
-var SerializationContext = class {
-  constructor(options) {
-    __publicField(this, "stack", []);
-    // Map tree refs to actual refs
-    __publicField(this, "validRefs", []);
-    __publicField(this, "refSize", 0);
-    // Variables
-    __publicField(this, "vars", []);
-    // Array of assignments to be done (used for recursion)
-    __publicField(this, "assignments", []);
-    // Supported features
-    __publicField(this, "features");
-    // Refs that are...referenced
-    __publicField(this, "markedRefs");
-    this.features = options.features;
-    this.markedRefs = options.markedRefs;
-  }
-};
+function createParserContext(options = {}) {
+  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+  return {
+    markedRefs: /* @__PURE__ */ new Set(),
+    refs: /* @__PURE__ */ new Map(),
+    features: parseTargets(result.target)
+  };
+}
+function createSerializationContext(options) {
+  return {
+    stack: [],
+    vars: [],
+    assignments: [],
+    validRefs: [],
+    refSize: 0,
+    features: options.features,
+    markedRefs: new Set(options.markedRefs)
+  };
+}
 function markRef(ctx, current) {
-  ctx.markedRefs[current] = 1;
+  ctx.markedRefs.add(current);
 }
 function createValidRef(ctx, index) {
   const current = ctx.validRefs[index];
@@ -387,201 +378,123 @@ function quote(str) {
   } else {
     result += str.slice(lastPos);
   }
-  return `"${result}"`;
+  return '"' + result + '"';
 }
 
-// src/tree/types.ts
-var SerovalObjectRecordNode = class {
-  constructor(k, v, s) {
-    __publicField(this, "k");
-    __publicField(this, "v");
-    __publicField(this, "s");
-    this.k = k;
-    this.v = v;
-    this.s = s;
-  }
-};
-var SerovalMapRecordNode = class {
-  constructor(k, v, s) {
-    __publicField(this, "k");
-    __publicField(this, "v");
-    __publicField(this, "s");
-    this.k = k;
-    this.v = v;
-    this.s = s;
-  }
-};
-var SerovalPrimitiveNode = class {
-  constructor(current) {
-    __publicField(this, "t", 0 /* Primitive */);
-    __publicField(this, "s");
-    this.s = current;
-  }
-};
-var SerovalReferenceNode = class {
-  constructor(id) {
-    __publicField(this, "t", 2 /* Reference */);
-    __publicField(this, "i");
-    this.i = id;
-  }
-};
-var SerovalBigIntNode = class {
-  constructor(current) {
-    __publicField(this, "t", 1 /* BigInt */);
-    __publicField(this, "s");
-    this.s = `${current}n`;
-  }
-};
-var SerovalDateNode = class {
-  constructor(id, current) {
-    __publicField(this, "t", 3 /* Date */);
-    __publicField(this, "i");
-    __publicField(this, "s");
-    this.i = id;
-    this.s = current.toISOString();
-  }
-};
-var SerovalRegExpNode = class {
-  constructor(id, current) {
-    __publicField(this, "t", 4 /* RegExp */);
-    __publicField(this, "i");
-    __publicField(this, "s");
-    this.i = id;
-    this.s = String(current);
-  }
-};
-var SerovalTypedArrayNode = class {
-  constructor(id, current) {
-    __publicField(this, "t", 14 /* TypedArray */);
-    __publicField(this, "i");
-    __publicField(this, "s");
-    __publicField(this, "l");
-    __publicField(this, "c");
-    this.i = id;
-    this.s = current.toString();
-    this.l = current.byteOffset;
-    this.c = current.constructor.name;
-  }
-};
-var SerovalBigIntTypedArrayNode = class {
-  constructor(id, current) {
-    __publicField(this, "t", 15 /* BigIntTypedArray */);
-    __publicField(this, "i");
-    __publicField(this, "s");
-    __publicField(this, "l");
-    __publicField(this, "c");
-    let result = "";
-    const cap = current.length - 1;
-    for (let i = 0; i < cap; i++) {
-      result += `${current[i]}n,`;
-    }
-    result += `"${current[cap]}"`;
-    this.i = id;
-    this.s = result;
-    this.l = current.byteOffset;
-    this.c = current.constructor.name;
-  }
-};
-var SerovalSetNode = class {
-  constructor(id, a) {
-    __publicField(this, "t", 5 /* Set */);
-    __publicField(this, "i");
-    __publicField(this, "a");
-    this.i = id;
-    this.a = a;
-  }
-};
-var SerovalMapNode = class {
-  constructor(id, d) {
-    __publicField(this, "t", 6 /* Map */);
-    __publicField(this, "i");
-    __publicField(this, "d");
-    this.i = id;
-    this.d = d;
-  }
-};
-var SerovalArrayNode = class {
-  constructor(id, a) {
-    __publicField(this, "t", 7 /* Array */);
-    __publicField(this, "i");
-    __publicField(this, "a");
-    this.i = id;
-    this.a = a;
-  }
-};
-var SerovalObjectNode = class {
-  constructor(id, d) {
-    __publicField(this, "t", 8 /* Object */);
-    __publicField(this, "i");
-    __publicField(this, "d");
-    this.i = id;
-    this.d = d;
-  }
-};
-var SerovalNullConstructorNode = class {
-  constructor(id, d) {
-    __publicField(this, "t", 9 /* NullConstructor */);
-    __publicField(this, "i");
-    __publicField(this, "d");
-    this.i = id;
-    this.d = d;
-  }
-};
-var SerovalPromiseNode = class {
-  constructor(id, n) {
-    __publicField(this, "t", 10 /* Promise */);
-    __publicField(this, "i");
-    __publicField(this, "n");
-    this.i = id;
-    this.n = n;
-  }
-};
-var SerovalErrorNode = class {
-  constructor(id, c, m, d) {
-    __publicField(this, "t", 11 /* Error */);
-    __publicField(this, "i");
-    __publicField(this, "c");
-    __publicField(this, "m");
-    __publicField(this, "d");
-    this.i = id;
-    this.c = c;
-    this.m = m;
-    this.d = d;
-  }
-};
-var SerovalAggregateErrorNode = class {
-  constructor(id, m, d, n) {
-    __publicField(this, "t", 12 /* AggregateError */);
-    __publicField(this, "i");
-    __publicField(this, "m");
-    __publicField(this, "d");
-    __publicField(this, "n");
-    this.i = id;
-    this.m = m;
-    this.d = d;
-    this.n = n;
-  }
-};
-var SerovalIterableNode = class {
-  constructor(id, d, a) {
-    __publicField(this, "t", 13 /* Iterable */);
-    __publicField(this, "i");
-    __publicField(this, "d");
-    __publicField(this, "a");
-    this.i = id;
-    this.d = d;
-    this.a = a;
-  }
-};
-
 // src/tree/primitives.ts
-var TRUE_NODE = new SerovalPrimitiveNode("!0");
-var FALSE_NODE = new SerovalPrimitiveNode("!1");
-var UNDEFINED_NODE = new SerovalPrimitiveNode("void 0");
-var NULL_NODE = new SerovalPrimitiveNode(null);
-var NEG_ZERO_NODE = new SerovalPrimitiveNode("-0");
-var INFINITY_NODE = new SerovalPrimitiveNode("1/0");
-var NEG_INFINITY_NODE = new SerovalPrimitiveNode("-1/0");
+function createPrimitiveNode(value) {
+  return {
+    t: 0 /* Primitive */,
+    i: void 0,
+    s: value,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+var TRUE_NODE = createPrimitiveNode("!0");
+var FALSE_NODE = createPrimitiveNode("!1");
+var UNDEFINED_NODE = createPrimitiveNode("void 0");
+var NULL_NODE = createPrimitiveNode(null);
+var NEG_ZERO_NODE = createPrimitiveNode("-0");
+var INFINITY_NODE = createPrimitiveNode("1/0");
+var NEG_INFINITY_NODE = createPrimitiveNode("-1/0");
+function createBigIntNode(ctx, current) {
+  assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+  return {
+    t: 1 /* BigInt */,
+    i: void 0,
+    s: current.toString() + "n",
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+function createReferenceNode(id) {
+  return {
+    t: 2 /* Reference */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+function createDateNode(id, current) {
+  return {
+    t: 3 /* Date */,
+    i: id,
+    s: current.toISOString(),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    n: void 0,
+    a: void 0
+  };
+}
+function createRegExpNode(id, current) {
+  return {
+    t: 4 /* RegExp */,
+    i: id,
+    s: String(current),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+function createTypedArrayNode(ctx, id, current) {
+  const constructor = current.constructor.name;
+  assert(ctx.features & 1024 /* TypedArray */, `Unsupported value type "${constructor}"`);
+  return {
+    t: 14 /* TypedArray */,
+    i: id,
+    s: current.toString(),
+    l: current.byteOffset,
+    c: constructor,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+function createBigIntTypedArrayNode(ctx, id, current) {
+  const constructor = current.constructor.name;
+  assert(
+    ctx.features & 2048 /* BigIntTypedArray */,
+    `Unsupported value type "${constructor}"`
+  );
+  let result = "";
+  for (let i = 0, len = current.length; i < len; i++) {
+    if (i !== 0) {
+      result += ",";
+    }
+    result += current[i].toString() + "n";
+  }
+  return {
+    t: 15 /* BigIntTypedArray */,
+    i: id,
+    s: result,
+    l: current.byteOffset,
+    c: constructor,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
 
 // src/tree/shared.ts
 function getErrorConstructor(error) {
@@ -633,9 +546,6 @@ function getIterableOptions(obj) {
   }
   return void 0;
 }
-function isReferenceInStack(ctx, node) {
-  return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
-}
 function isIterable(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -666,11 +576,7 @@ function isIterable(value) {
 
 // src/tree/async.ts
 var AsyncParser = class {
-  constructor(ctx) {
-    __publicField(this, "ctx");
-    this.ctx = ctx;
-  }
-  async generateNodeList(current) {
+  static async generateNodeList(ctx, current) {
     const size = current.length;
     const nodes = new Array(size);
     const deferred = new Array(size);
@@ -681,22 +587,32 @@ var AsyncParser = class {
         if (isIterable(item)) {
           deferred[i] = item;
         } else {
-          nodes[i] = await this.parse(item);
+          nodes[i] = await this.parse(ctx, item);
         }
       }
     }
     for (let i = 0; i < size; i++) {
       if (i in deferred) {
-        nodes[i] = await this.parse(deferred[i]);
+        nodes[i] = await this.parse(ctx, deferred[i]);
       }
     }
     return nodes;
   }
-  async generateArrayNode(id, current) {
-    return new SerovalArrayNode(id, await this.generateNodeList(current));
+  static async generateArrayNode(ctx, id, current) {
+    return {
+      t: 7 /* Array */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      d: void 0,
+      a: await this.generateNodeList(ctx, current),
+      n: void 0
+    };
   }
-  async generateMapNode(id, current) {
-    assert(this.ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+  static async generateMapNode(ctx, id, current) {
+    assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
     const len = current.size;
     const keyNodes = new Array(len);
     const valueNodes = new Array(len);
@@ -710,19 +626,29 @@ var AsyncParser = class {
         deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes[nodeSize] = await this.parse(key);
-        valueNodes[nodeSize] = await this.parse(value);
+        keyNodes[nodeSize] = await this.parse(ctx, key);
+        valueNodes[nodeSize] = await this.parse(ctx, value);
         nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodeSize + i] = await this.parse(deferredKey[i]);
-      valueNodes[nodeSize + i] = await this.parse(deferredValue[i]);
+      keyNodes[nodeSize + i] = await this.parse(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = await this.parse(ctx, deferredValue[i]);
     }
-    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
+    return {
+      t: 6 /* Map */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      d: { k: keyNodes, v: valueNodes, s: len },
+      a: void 0,
+      n: void 0
+    };
   }
-  async generateSetNode(id, current) {
-    assert(this.ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+  static async generateSetNode(ctx, id, current) {
+    assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
     const len = current.size;
     const nodes = new Array(len);
     const deferred = new Array(len);
@@ -732,15 +658,25 @@ var AsyncParser = class {
       if (isIterable(item)) {
         deferred[deferredSize++] = item;
       } else {
-        nodes[nodeSize++] = await this.parse(item);
+        nodes[nodeSize++] = await this.parse(ctx, item);
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      nodes[nodeSize + i] = await this.parse(deferred[i]);
+      nodes[nodeSize + i] = await this.parse(ctx, deferred[i]);
     }
-    return new SerovalSetNode(id, nodes);
+    return {
+      t: 5 /* Set */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      d: void 0,
+      a: nodes,
+      n: void 0
+    };
   }
-  async generateProperties(properties) {
+  static async generateProperties(ctx, properties) {
     const keys = Object.keys(properties);
     const size = keys.length;
     const keyNodes = new Array(size);
@@ -758,98 +694,139 @@ var AsyncParser = class {
         deferredSize++;
       } else {
         keyNodes[nodesSize] = key;
-        valueNodes[nodesSize] = await this.parse(item);
+        valueNodes[nodesSize] = await this.parse(ctx, item);
         nodesSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
       keyNodes[nodesSize + i] = deferredKeys[i];
-      valueNodes[nodesSize + i] = await this.parse(deferredValues[i]);
+      valueNodes[nodesSize + i] = await this.parse(ctx, deferredValues[i]);
     }
-    return new SerovalObjectRecordNode(keyNodes, valueNodes, size);
+    return {
+      k: keyNodes,
+      v: valueNodes,
+      s: size
+    };
   }
-  async generateIterableNode(id, current) {
-    assert(this.ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  static async generateIterableNode(ctx, id, current) {
+    assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return new SerovalIterableNode(
-      id,
+    return {
+      t: 13 /* Iterable */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
       // Parse options first before the items
-      options ? await this.generateProperties(options) : void 0,
-      await this.generateNodeList(Array.from(current))
-    );
+      d: options ? await this.generateProperties(ctx, options) : void 0,
+      a: await this.generateNodeList(ctx, Array.from(current)),
+      n: void 0
+    };
   }
-  async generatePromiseNode(id, current) {
-    assert(this.ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
-    return current.then(async (value) => new SerovalPromiseNode(id, await this.parse(value)));
+  static async generatePromiseNode(ctx, id, current) {
+    assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
+    return current.then(async (value) => ({
+      t: 10 /* Promise */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      // Parse options first before the items
+      d: void 0,
+      a: void 0,
+      n: await this.parse(ctx, value)
+    }));
   }
-  async generateObjectNode(id, current, empty) {
+  static async generateObjectNode(ctx, id, current, empty) {
     if (Symbol.iterator in current) {
-      return this.generateIterableNode(id, current);
+      return this.generateIterableNode(ctx, id, current);
     }
     if ("then" in current && typeof current.then === "function") {
-      return this.generatePromiseNode(id, current);
-    }
-    const properties = await this.generateProperties(current);
-    if (empty) {
-      return new SerovalNullConstructorNode(id, properties);
+      return this.generatePromiseNode(ctx, id, current);
     }
-    return new SerovalObjectNode(id, properties);
+    return {
+      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      d: await this.generateProperties(ctx, current),
+      a: void 0,
+      n: void 0
+    };
   }
-  async generateAggregateErrorNode(id, current) {
+  static async generateAggregateErrorNode(ctx, id, current) {
     const options = getErrorOptions(current);
-    const optionsNode = options ? await this.generateProperties(options) : void 0;
-    return new SerovalAggregateErrorNode(
-      id,
-      current.message,
-      optionsNode,
-      await this.parse(current.errors)
-    );
-  }
-  async generateErrorNode(id, current) {
+    const optionsNode = options ? await this.generateProperties(ctx, options) : void 0;
+    return {
+      t: 12 /* AggregateError */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: current.message,
+      d: optionsNode,
+      a: void 0,
+      n: await this.parse(ctx, current.errors)
+    };
+  }
+  static async generateErrorNode(ctx, id, current) {
     const options = getErrorOptions(current);
-    const optionsNode = options ? await this.generateProperties(options) : void 0;
-    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
+    const optionsNode = options ? await this.generateProperties(ctx, options) : void 0;
+    return {
+      t: 11 /* Error */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: getErrorConstructor(current),
+      m: current.message,
+      d: optionsNode,
+      a: void 0,
+      n: void 0
+    };
   }
-  async parse(current) {
+  static async parse(ctx, current) {
     switch (typeof current) {
       case "boolean":
         return current ? TRUE_NODE : FALSE_NODE;
       case "undefined":
         return UNDEFINED_NODE;
       case "string":
-        return new SerovalPrimitiveNode(quote(current));
+        return createPrimitiveNode(quote(current));
       case "number":
         if (Object.is(current, -0)) {
           return NEG_ZERO_NODE;
         }
         if (Object.is(current, Infinity)) {
-          return INFINITY_NODE;
+          return createPrimitiveNode("1/0");
         }
         if (Object.is(current, -Infinity)) {
-          return NEG_INFINITY_NODE;
+          return createPrimitiveNode("-1/0");
         }
-        return new SerovalPrimitiveNode(current);
+        return createPrimitiveNode(current);
       case "bigint":
-        assert(this.ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
-        return new SerovalBigIntNode(current);
+        return createBigIntNode(ctx, current);
       case "object": {
         if (!current) {
           return NULL_NODE;
         }
-        const id = createRef(this.ctx, current, true);
-        if (this.ctx.markedRefs[id]) {
-          return new SerovalReferenceNode(id);
+        const id = createRef(ctx, current, true);
+        if (ctx.markedRefs.has(id)) {
+          return createReferenceNode(id);
         }
         if (Array.isArray(current)) {
-          return this.generateArrayNode(id, current);
+          return this.generateArrayNode(ctx, id, current);
         }
         switch (current.constructor) {
           case Date:
-            return new SerovalDateNode(id, current);
+            return createDateNode(id, current);
           case RegExp:
-            return new SerovalRegExpNode(id, current);
+            return createRegExpNode(id, current);
           case Promise:
-            return this.generatePromiseNode(id, current);
+            return this.generatePromiseNode(ctx, id, current);
           case Int8Array:
           case Int16Array:
           case Int32Array:
@@ -859,28 +836,41 @@ var AsyncParser = class {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            assert(this.ctx.features & 1024 /* TypedArray */, `Unsupported value type "${current.constructor.name}"`);
-            return new SerovalTypedArrayNode(id, current);
+            return createTypedArrayNode(ctx, id, current);
           case BigInt64Array:
           case BigUint64Array:
-            assert(
-              this.ctx.features & 2048 /* BigIntTypedArray */,
-              `Unsupported value type "${current.constructor.name}"`
-            );
-            return new SerovalBigIntTypedArrayNode(id, current);
+            return createBigIntTypedArrayNode(ctx, id, current);
           case Map:
-            return this.generateMapNode(id, current);
+            return this.generateMapNode(
+              ctx,
+              id,
+              current
+            );
           case Set:
-            return this.generateSetNode(id, current);
+            return this.generateSetNode(
+              ctx,
+              id,
+              current
+            );
           case Object:
-            return this.generateObjectNode(id, current, false);
+            return this.generateObjectNode(
+              ctx,
+              id,
+              current,
+              false
+            );
           case void 0:
-            return this.generateObjectNode(id, current, true);
+            return this.generateObjectNode(
+              ctx,
+              id,
+              current,
+              true
+            );
           case AggregateError:
-            if (this.ctx.features & 1 /* AggregateError */) {
-              return this.generateAggregateErrorNode(id, current);
+            if (ctx.features & 1 /* AggregateError */) {
+              return this.generateAggregateErrorNode(ctx, id, current);
             }
-            return this.generateErrorNode(id, current);
+            return this.generateErrorNode(ctx, id, current);
           case Error:
           case EvalError:
           case RangeError:
@@ -888,24 +878,24 @@ var AsyncParser = class {
           case SyntaxError:
           case TypeError:
           case URIError:
-            return this.generateErrorNode(id, current);
+            return this.generateErrorNode(ctx, id, current);
           default:
             break;
         }
-        if (current instanceof AggregateError && this.ctx.features & 1 /* AggregateError */) {
-          return this.generateAggregateErrorNode(id, current);
+        if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+          return this.generateAggregateErrorNode(ctx, id, current);
         }
         if (current instanceof Error) {
-          return this.generateErrorNode(id, current);
+          return this.generateErrorNode(ctx, id, current);
         }
         if (current instanceof Promise) {
-          return this.generatePromiseNode(id, current);
+          return this.generatePromiseNode(ctx, id, current);
         }
         if (Symbol.iterator in current) {
-          return this.generateIterableNode(id, current);
+          return this.generateIterableNode(ctx, id, current);
         }
         if ("then" in current && typeof current.then === "function") {
-          return this.generatePromiseNode(id, current);
+          return this.generatePromiseNode(ctx, id, current);
         }
         throw new Error("Unsupported type");
       }
@@ -915,20 +905,20 @@ var AsyncParser = class {
   }
 };
 async function parseAsync(ctx, current) {
-  const result = await new AsyncParser(ctx).parse(current);
+  const result = await AsyncParser.parse(ctx, current);
   const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
   return [result, createRef(ctx, current, false), isObject];
 }
 
 // src/tree/serialize.ts
 function getAssignmentExpression(assignment) {
-  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 "";
   }
@@ -937,27 +927,30 @@ function mergeAssignments(assignments) {
   const newAssignments = [];
   let current = assignments[0];
   let prev = current;
+  let item;
   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) {
         current = {
-          type: "index",
-          source: item.source,
-          value: getAssignmentExpression(current)
+          t: "index",
+          s: item.s,
+          k: void 0,
+          v: getAssignmentExpression(current)
         };
-      } else if (item.type === "map" && item.source === prev.source) {
+      } else if (item.t === "map" && item.s === prev.s) {
         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) {
         current = {
-          type: "set",
-          source: getAssignmentExpression(current),
-          value: item.value
+          t: "set",
+          s: getAssignmentExpression(current),
+          k: void 0,
+          v: item.v
         };
       } else {
         newAssignments.push(current);
@@ -977,7 +970,7 @@ function resolveAssignments(assignments) {
     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;
   }
@@ -986,328 +979,338 @@ function resolveAssignments(assignments) {
 function resolvePatches(ctx) {
   return resolveAssignments(ctx.assignments);
 }
-function assignRef(ctx, index, value) {
-  if (ctx.markedRefs[index]) {
-    return `${getRefParam(ctx, index)}=${value}`;
-  }
-  return value;
-}
 function createAssignment(ctx, source, value) {
   ctx.assignments.push({
-    type: "index",
-    source,
-    value
+    t: "index",
+    s: source,
+    k: void 0,
+    v: value
   });
 }
 function createSetAdd(ctx, ref, value) {
   markRef(ctx, ref);
   ctx.assignments.push({
-    type: "set",
-    source: getRefParam(ctx, ref),
-    value
+    t: "set",
+    s: getRefParam(ctx, ref),
+    k: void 0,
+    v: value
   });
 }
 function createMapSet(ctx, ref, key, value) {
   markRef(ctx, ref);
   ctx.assignments.push({
-    type: "map",
-    source: getRefParam(ctx, ref),
-    key,
-    value
+    t: "map",
+    s: getRefParam(ctx, ref),
+    k: key,
+    v: value
   });
 }
 function createArrayAssign(ctx, ref, index, value) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
+  createAssignment(ctx, getRefParam(ctx, ref) + "[" + index.toString() + "]", value);
 }
 function createObjectAssign(ctx, ref, key, value) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
+  createAssignment(ctx, getRefParam(ctx, ref) + "." + key, value);
 }
-var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
-function serializeAssignments(ctx, targetRef, node) {
-  ctx.stack.push(targetRef);
-  const mainAssignments = [];
-  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;
-    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;
+function assignRef(ctx, index, value) {
+  if (ctx.markedRefs.has(index)) {
+    return getRefParam(ctx, index) + "=" + value;
   }
-  ctx.stack.pop();
-  return resolveAssignments(mainAssignments);
+  return value;
 }
-function serializeObject(ctx, sourceID, node) {
-  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);
-    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);
+function isReferenceInStack(ctx, node) {
+  return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
+}
+var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
+var SerovalSerializer = class {
+  static serializeNodeList(ctx, node) {
+    const size = node.a.length;
+    let values = "";
+    let item;
+    let isHoley = false;
+    for (let i = 0; i < size; i++) {
+      if (i !== 0) {
+        values += ",";
+      }
+      item = node.a[i];
+      if (item) {
+        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, node) {
-  let serialized;
-  if (isReferenceInStack(ctx, node.n)) {
-    serialized = `Promise.resolve().then(()=>${getRefParam(ctx, node.n.i)})`;
-  } else {
+  static serializeArray(ctx, node) {
     ctx.stack.push(node.i);
-    const result = serializeTree(ctx, node.n);
+    const result = this.serializeNodeList(ctx, node);
     ctx.stack.pop();
-    serialized = `Promise.resolve(${result})`;
+    return assignRef(ctx, node.i, result);
   }
-  return assignRef(ctx, node.i, serialized);
-}
-function serializeTypedArray(ctx, node) {
-  let args = `[${node.s}]`;
-  if (node.l !== 0) {
-    args += `,${node.l}`;
-  }
-  return assignRef(ctx, node.i, `new ${node.c}(${args})`);
-}
-function serializeSet(ctx, node) {
-  let serialized = "new Set";
-  const size = node.a.length;
-  if (size) {
+  static serializeObject(ctx, sourceID, node) {
+    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;
+    let val;
+    let check;
+    let isIdentifier;
+    let refParam;
+    let hasPrev = false;
+    for (let i = 0; i < node.s; i++) {
+      key = node.k[i];
+      val = node.v[i];
+      check = Number(key);
+      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 {
-        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 + "}";
   }
-  return assignRef(ctx, node.i, serialized);
-}
-function serializeMap(ctx, node) {
-  let serialized = "new Map";
-  if (node.d.s) {
-    let result = "";
-    ctx.stack.push(node.i);
-    for (let i = 0; i < node.d.s; i++) {
-      const key = node.d.k[i];
-      const val = node.d.v[i];
-      if (isReferenceInStack(ctx, key)) {
-        const keyRef = getRefParam(ctx, key.i);
-        if (isReferenceInStack(ctx, val)) {
-          const valueRef = getRefParam(ctx, val.i);
-          createMapSet(ctx, node.i, keyRef, valueRef);
-        } else {
-          const parent = ctx.stack;
-          ctx.stack = [];
-          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
-          ctx.stack = parent;
-        }
-      } else if (isReferenceInStack(ctx, val)) {
-        const valueRef = getRefParam(ctx, val.i);
-        const parent = ctx.stack;
-        ctx.stack = [];
-        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
-        ctx.stack = parent;
+  static serializeWithObjectAssign(ctx, value, id, serialized) {
+    const fields = this.serializeObject(ctx, id, value);
+    if (fields !== "{}") {
+      return "Object.assign(" + serialized + "," + fields + ")";
+    }
+    return serialized;
+  }
+  static serializeAssignments(ctx, sourceID, node) {
+    ctx.stack.push(sourceID);
+    const mainAssignments = [];
+    let parentStack;
+    let refParam;
+    let key;
+    let check;
+    let parentAssignment;
+    let isIdentifier;
+    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;
+      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();
-    if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
-    }
+    return resolveAssignments(mainAssignments);
   }
-  return assignRef(ctx, node.i, serialized);
-}
-function serializeNodeList(ctx, node) {
-  const size = node.a.length;
-  let values = "";
-  for (let i = 0; i < size; i++) {
-    const item = node.a[i];
-    if (item) {
-      if (isReferenceInStack(ctx, item)) {
-        createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
-        values += ",";
+  static serializeDictionary(ctx, i, d, init) {
+    if (d) {
+      if (ctx.features & 64 /* 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 {
-      values += ",";
     }
-  }
-  return `[${values}]`;
-}
-function serializeArray(ctx, node) {
-  ctx.stack.push(node.i);
-  const result = serializeNodeList(ctx, node);
-  ctx.stack.pop();
-  return assignRef(ctx, node.i, result);
-}
-function serializeWithObjectAssign(ctx, value, id, serialized) {
-  const fields = serializeObject(ctx, id, value);
-  if (fields !== "{}") {
-    return `Object.assign(${serialized},${fields})`;
-  }
-  return serialized;
-}
-function serializeAggregateError(ctx, node) {
-  ctx.stack.push(node.i);
-  let serialized = `new AggregateError(${serializeTree(ctx, node.n)},${quote(node.m)})`;
-  ctx.stack.pop();
-  if (node.d) {
-    if (ctx.features & 64 /* 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})`;
+    return assignRef(ctx, i, init);
+  }
+  static serializeNullConstructor(ctx, node) {
+    return this.serializeDictionary(ctx, node.i, node.d, "Object.create(null)");
+  }
+  static serializeSet(ctx, node) {
+    let serialized = "new Set";
+    const size = node.a.length;
+    if (size) {
+      let result = "";
+      ctx.stack.push(node.i);
+      let item;
+      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 {
+          if (hasPrev) {
+            result += ",";
+          }
+          result += this.serialize(ctx, item);
+          hasPrev = true;
+        }
+      }
+      ctx.stack.pop();
+      if (result) {
+        serialized += "([" + result + "])";
       }
     }
-  }
-  return assignRef(ctx, node.i, serialized);
-}
-function serializeError(ctx, node) {
-  let serialized = `new ${node.c}(${quote(node.m)})`;
-  if (node.d) {
-    if (ctx.features & 64 /* 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})`;
+    return assignRef(ctx, node.i, serialized);
+  }
+  static serializeMap(ctx, node) {
+    let serialized = "new Map";
+    if (node.d.s) {
+      let result = "";
+      ctx.stack.push(node.i);
+      let key;
+      let val;
+      let keyRef;
+      let valueRef;
+      let parent;
+      let hasPrev = false;
+      for (let i = 0; i < node.d.s; i++) {
+        key = node.d.k[i];
+        val = node.d.v[i];
+        if (isReferenceInStack(ctx, key)) {
+          keyRef = getRefParam(ctx, key.i);
+          if (isReferenceInStack(ctx, val)) {
+            valueRef = getRefParam(ctx, val.i);
+            createMapSet(ctx, node.i, keyRef, valueRef);
+          } else {
+            parent = ctx.stack;
+            ctx.stack = [];
+            createMapSet(ctx, node.i, keyRef, this.serialize(ctx, val));
+            ctx.stack = parent;
+          }
+        } else if (isReferenceInStack(ctx, val)) {
+          valueRef = getRefParam(ctx, val.i);
+          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();
+      if (result) {
+        serialized += "([" + result + "])";
       }
     }
+    return assignRef(ctx, node.i, serialized);
   }
-  return assignRef(ctx, node.i, serialized);
-}
-function serializeIterable(ctx, node) {
-  const parent = ctx.stack;
-  ctx.stack = [];
-  const values = serializeNodeList(ctx, node);
-  ctx.stack = parent;
-  let serialized;
-  if (ctx.features & 2 /* ArrayPrototypeValues */) {
-    serialized = `${values}.values()`;
-  } else {
-    serialized = `${values}[Symbol.iterator]()`;
+  static serializeAggregateError(ctx, node) {
+    ctx.stack.push(node.i);
+    const serialized = "new AggregateError(" + this.serialize(ctx, node.n) + "," + quote(node.m) + ")";
+    ctx.stack.pop();
+    return this.serializeDictionary(ctx, node.i, node.d, serialized);
   }
-  if (ctx.features & 4 /* ArrowFunction */) {
-    serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-  } else if (ctx.features & 32 /* MethodShorthand */) {
-    serialized = `{[Symbol.iterator](){return ${serialized}}}`;
-  } else {
-    serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
+  static serializeError(ctx, node) {
+    const serialized = "new " + node.c + "(" + quote(node.m) + ")";
+    return this.serializeDictionary(ctx, node.i, node.d, serialized);
   }
-  if (node.d) {
-    if (ctx.features & 64 /* ObjectAssign */) {
-      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
+  static serializePromise(ctx, node) {
+    let serialized;
+    if (isReferenceInStack(ctx, node.n)) {
+      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();
+      serialized = "Promise.resolve(" + result + ")";
     }
+    return assignRef(ctx, node.i, serialized);
   }
-  return assignRef(ctx, node.i, serialized);
-}
-function serializeNullConstructor(ctx, node) {
-  let serialized = "Object.create(null)";
-  if (ctx.features & 64 /* 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, node) {
+    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);
-}
-function serializeTree(ctx, node) {
-  switch (node.t) {
-    case 0 /* Primitive */:
-      return String(node.s);
-    case 2 /* Reference */:
-      return getRefParam(ctx, node.i);
-    case 10 /* Promise */:
-      return serializePromise(ctx, node);
-    case 1 /* BigInt */:
-      return node.s;
-    case 3 /* Date */:
-      return assignRef(ctx, node.i, `new Date("${node.s}")`);
-    case 4 /* RegExp */:
-      return assignRef(ctx, node.i, node.s);
-    case 15 /* BigIntTypedArray */:
-    case 14 /* TypedArray */:
-      return serializeTypedArray(ctx, node);
-    case 5 /* Set */:
-      return serializeSet(ctx, node);
-    case 6 /* Map */:
-      return serializeMap(ctx, node);
-    case 7 /* Array */:
-      return serializeArray(ctx, node);
-    case 12 /* AggregateError */:
-      return serializeAggregateError(ctx, node);
-    case 11 /* Error */:
-      return serializeError(ctx, node);
-    case 13 /* Iterable */:
-      return serializeIterable(ctx, node);
-    case 9 /* NullConstructor */:
-      return serializeNullConstructor(ctx, node);
-    case 8 /* Object */:
-      return assignRef(ctx, node.i, serializeObject(ctx, node.i, node.d));
-    default:
-      throw new Error("Unsupported type");
+  static serializeIterable(ctx, node) {
+    const parent = ctx.stack;
+    ctx.stack = [];
+    const values = this.serializeNodeList(ctx, node);
+    ctx.stack = parent;
+    let serialized = values;
+    if (ctx.features & 2 /* ArrayPrototypeValues */) {
+      serialized += ".values()";
+    } else {
+      serialized += "[Symbol.iterator]()";
+    }
+    if (ctx.features & 4 /* ArrowFunction */) {
+      serialized = "{[Symbol.iterator]:()=>" + serialized + "}";
+    } else if (ctx.features & 32 /* 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, node) {
+    switch (node.t) {
+      case 0 /* Primitive */:
+        return String(node.s);
+      case 1 /* BigInt */:
+        return node.s;
+      case 2 /* Reference */:
+        return getRefParam(ctx, node.i);
+      case 7 /* Array */:
+        return this.serializeArray(ctx, node);
+      case 8 /* Object */:
+        return assignRef(ctx, node.i, this.serializeObject(ctx, node.i, node.d));
+      case 9 /* NullConstructor */:
+        return this.serializeNullConstructor(ctx, node);
+      case 3 /* Date */:
+        return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
+      case 4 /* RegExp */:
+        return assignRef(ctx, node.i, node.s);
+      case 5 /* Set */:
+        return this.serializeSet(ctx, node);
+      case 6 /* Map */:
+        return this.serializeMap(ctx, node);
+      case 15 /* BigIntTypedArray */:
+      case 14 /* TypedArray */:
+        return this.serializeTypedArray(ctx, node);
+      case 12 /* AggregateError */:
+        return this.serializeAggregateError(ctx, node);
+      case 11 /* Error */:
+        return this.serializeError(ctx, node);
+      case 13 /* Iterable */:
+        return this.serializeIterable(ctx, node);
+      case 10 /* Promise */:
+        return this.serializePromise(ctx, node);
+      default:
+        throw new Error("Unsupported type");
+    }
   }
-}
+};
 
 // src/tree/sync.ts
 var SyncParser = class {
-  constructor(ctx) {
-    __publicField(this, "ctx");
-    this.ctx = ctx;
-  }
-  generateNodeList(current) {
+  static generateNodeList(ctx, current) {
     const size = current.length;
     const nodes = new Array(size);
     const deferred = new Array(size);
@@ -1318,22 +1321,32 @@ var SyncParser = class {
         if (isIterable(item)) {
           deferred[i] = item;
         } else {
-          nodes[i] = this.parse(item);
+          nodes[i] = this.parse(ctx, item);
         }
       }
     }
     for (let i = 0; i < size; i++) {
       if (i in deferred) {
-        nodes[i] = this.parse(deferred[i]);
+        nodes[i] = this.parse(ctx, deferred[i]);
       }
     }
     return nodes;
   }
-  generateArrayNode(id, current) {
-    return new SerovalArrayNode(id, this.generateNodeList(current));
+  static generateArrayNode(ctx, id, current) {
+    return {
+      t: 7 /* Array */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      d: void 0,
+      a: this.generateNodeList(ctx, current),
+      n: void 0
+    };
   }
-  generateMapNode(id, current) {
-    assert(this.ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+  static generateMapNode(ctx, id, current) {
+    assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
     const len = current.size;
     const keyNodes = new Array(len);
     const valueNodes = new Array(len);
@@ -1347,19 +1360,29 @@ var SyncParser = class {
         deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes[nodeSize] = this.parse(key);
-        valueNodes[nodeSize] = this.parse(value);
+        keyNodes[nodeSize] = this.parse(ctx, key);
+        valueNodes[nodeSize] = this.parse(ctx, value);
         nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodeSize + i] = this.parse(deferredKey[i]);
-      valueNodes[nodeSize + i] = this.parse(deferredValue[i]);
+      keyNodes[nodeSize + i] = this.parse(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = this.parse(ctx, deferredValue[i]);
     }
-    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
+    return {
+      t: 6 /* Map */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      d: { k: keyNodes, v: valueNodes, s: len },
+      a: void 0,
+      n: void 0
+    };
   }
-  generateSetNode(id, current) {
-    assert(this.ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+  static generateSetNode(ctx, id, current) {
+    assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
     const len = current.size;
     const nodes = new Array(len);
     const deferred = new Array(len);
@@ -1369,15 +1392,25 @@ var SyncParser = class {
       if (isIterable(item)) {
         deferred[deferredSize++] = item;
       } else {
-        nodes[nodeSize++] = this.parse(item);
+        nodes[nodeSize++] = this.parse(ctx, item);
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      nodes[nodeSize + i] = this.parse(deferred[i]);
+      nodes[nodeSize + i] = this.parse(ctx, deferred[i]);
     }
-    return new SerovalSetNode(id, nodes);
+    return {
+      t: 5 /* Set */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      d: void 0,
+      a: nodes,
+      n: void 0
+    };
   }
-  generateProperties(properties) {
+  static generateProperties(ctx, properties) {
     const keys = Object.keys(properties);
     const size = keys.length;
     const keyNodes = new Array(size);
@@ -1395,13 +1428,13 @@ var SyncParser = class {
         deferredSize++;
       } else {
         keyNodes[nodesSize] = key;
-        valueNodes[nodesSize] = this.parse(item);
+        valueNodes[nodesSize] = this.parse(ctx, item);
         nodesSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
       keyNodes[nodesSize + i] = deferredKeys[i];
-      valueNodes[nodesSize + i] = this.parse(deferredValues[i]);
+      valueNodes[nodesSize + i] = this.parse(ctx, deferredValues[i]);
     }
     return {
       k: keyNodes,
@@ -1409,78 +1442,105 @@ var SyncParser = class {
       s: size
     };
   }
-  generateIterableNode(id, current) {
-    assert(this.ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  static generateIterableNode(ctx, id, current) {
+    assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return new SerovalIterableNode(
-      id,
+    return {
+      t: 13 /* Iterable */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
       // Parse options first before the items
-      options ? this.generateProperties(options) : void 0,
-      this.generateNodeList(Array.from(current))
-    );
+      d: options ? this.generateProperties(ctx, options) : void 0,
+      a: this.generateNodeList(ctx, Array.from(current)),
+      n: void 0
+    };
   }
-  generateObjectNode(id, current, empty) {
+  static generateObjectNode(ctx, id, current, empty) {
     if (Symbol.iterator in current) {
-      return this.generateIterableNode(id, current);
+      return this.generateIterableNode(ctx, id, current);
     }
-    if (empty) {
-      return new SerovalNullConstructorNode(id, this.generateProperties(current));
-    }
-    return new SerovalObjectNode(id, this.generateProperties(current));
+    return {
+      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      d: this.generateProperties(ctx, current),
+      a: void 0,
+      n: void 0
+    };
   }
-  generateAggregateErrorNode(id, current) {
+  static generateAggregateErrorNode(ctx, id, current) {
     const options = getErrorOptions(current);
-    const optionsNode = options ? this.generateProperties(options) : void 0;
-    return new SerovalAggregateErrorNode(
-      id,
-      current.message,
-      optionsNode,
-      this.parse(current.errors)
-    );
-  }
-  generateErrorNode(id, current) {
+    const optionsNode = options ? this.generateProperties(ctx, options) : void 0;
+    return {
+      t: 12 /* AggregateError */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: current.message,
+      d: optionsNode,
+      a: void 0,
+      n: this.parse(ctx, current.errors)
+    };
+  }
+  static generateErrorNode(ctx, id, current) {
     const options = getErrorOptions(current);
-    const optionsNode = options ? this.generateProperties(options) : void 0;
-    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
+    const optionsNode = options ? this.generateProperties(ctx, options) : void 0;
+    return {
+      t: 11 /* Error */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: getErrorConstructor(current),
+      m: current.message,
+      d: optionsNode,
+      a: void 0,
+      n: void 0
+    };
   }
-  parse(current) {
+  static parse(ctx, current) {
     switch (typeof current) {
       case "boolean":
         return current ? TRUE_NODE : FALSE_NODE;
       case "undefined":
         return UNDEFINED_NODE;
       case "string":
-        return new SerovalPrimitiveNode(quote(current));
+        return createPrimitiveNode(quote(current));
       case "number":
         if (Object.is(current, -0)) {
           return NEG_ZERO_NODE;
         }
         if (Object.is(current, Infinity)) {
-          return INFINITY_NODE;
+          return createPrimitiveNode("1/0");
         }
         if (Object.is(current, -Infinity)) {
-          return NEG_INFINITY_NODE;
+          return createPrimitiveNode("-1/0");
         }
-        return new SerovalPrimitiveNode(current);
+        return createPrimitiveNode(current);
       case "bigint":
-        assert(this.ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
-        return new SerovalBigIntNode(current);
+        return createBigIntNode(ctx, current);
       case "object": {
         if (!current) {
           return NULL_NODE;
         }
-        const id = createRef(this.ctx, current, true);
-        if (this.ctx.markedRefs[id]) {
-          return new SerovalReferenceNode(id);
+        const id = createRef(ctx, current, true);
+        if (ctx.markedRefs.has(id)) {
+          return createReferenceNode(id);
         }
         if (Array.isArray(current)) {
-          return this.generateArrayNode(id, current);
+          return this.generateArrayNode(ctx, id, current);
         }
         switch (current.constructor) {
           case Date:
-            return new SerovalDateNode(id, current);
+            return createDateNode(id, current);
           case RegExp:
-            return new SerovalRegExpNode(id, current);
+            return createRegExpNode(id, current);
           case Int8Array:
           case Int16Array:
           case Int32Array:
@@ -1490,28 +1550,23 @@ var SyncParser = class {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            assert(this.ctx.features & 1024 /* TypedArray */, `Unsupported value type "${current.constructor.name}"`);
-            return new SerovalTypedArrayNode(id, current);
+            return createTypedArrayNode(ctx, id, current);
           case BigInt64Array:
           case BigUint64Array:
-            assert(
-              this.ctx.features & 2048 /* BigIntTypedArray */,
-              `Unsupported value type "${current.constructor.name}"`
-            );
-            return new SerovalBigIntTypedArrayNode(id, current);
+            return createBigIntTypedArrayNode(ctx, id, current);
           case Map:
-            return this.generateMapNode(id, current);
+            return this.generateMapNode(ctx, id, current);
           case Set:
-            return this.generateSetNode(id, current);
+            return this.generateSetNode(ctx, id, current);
           case Object:
-            return this.generateObjectNode(id, current, false);
+            return this.generateObjectNode(ctx, id, current, false);
           case void 0:
-            return this.generateObjectNode(id, current, true);
+            return this.generateObjectNode(ctx, id, current, true);
           case AggregateError:
-            if (this.ctx.features & 1 /* AggregateError */) {
-              return this.generateAggregateErrorNode(id, current);
+            if (ctx.features & 1 /* AggregateError */) {
+              return this.generateAggregateErrorNode(ctx, id, current);
             }
-            return this.generateErrorNode(id, current);
+            return this.generateErrorNode(ctx, id, current);
           case Error:
           case EvalError:
           case RangeError:
@@ -1519,18 +1574,18 @@ var SyncParser = class {
           case SyntaxError:
           case TypeError:
           case URIError:
-            return this.generateErrorNode(id, current);
+            return this.generateErrorNode(ctx, id, current);
           default:
             break;
         }
-        if (current instanceof AggregateError && this.ctx.features & 1 /* AggregateError */) {
-          return this.generateAggregateErrorNode(id, current);
+        if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+          return this.generateAggregateErrorNode(ctx, id, current);
         }
         if (current instanceof Error) {
-          return this.generateErrorNode(id, current);
+          return this.generateErrorNode(ctx, id, current);
         }
         if (Symbol.iterator in current) {
-          return this.generateIterableNode(id, current);
+          return this.generateIterableNode(ctx, id, current);
         }
         throw new Error("Unsupported type");
       }
@@ -1540,7 +1595,7 @@ var SyncParser = class {
   }
 };
 function parseSync(ctx, current) {
-  const result = new SyncParser(ctx).parse(current);
+  const result = SyncParser.parse(ctx, current);
   const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
   return [result, createRef(ctx, current, false), isObject];
 }
@@ -1552,71 +1607,70 @@ function finalize(ctx, rootID, isObject, result) {
     let body = result;
     if (patches) {
       const index = getRefParam(ctx, rootID);
-      if (result.startsWith(`${index}=`)) {
-        body = `${result},${patches}${index}`;
-      } else {
-        body = `${index}=${result},${patches}${index}`;
+      body = result + "," + patches + index;
+      if (!result.startsWith(index + "=")) {
+        body = index + "=" + body;
       }
     }
     let params = ctx.vars.length > 1 ? ctx.vars.join(",") : ctx.vars[0];
     if (ctx.features & 4 /* ArrowFunction */) {
-      params = ctx.vars.length > 1 || ctx.vars.length === 0 ? `(${params})` : params;
-      return `(${params}=>(${body}))()`;
+      params = ctx.vars.length > 1 || ctx.vars.length === 0 ? "(" + params + ")" : params;
+      return "(" + params + "=>(" + body + "))()";
     }
-    return `(function(${params}){return ${body}})()`;
+    return "(function(" + params + "){return " + body + "})()";
   }
   if (isObject) {
-    return `(${result})`;
+    return "(" + result + ")";
   }
   return result;
 }
 function serialize(source, options) {
-  const ctx = new ParserContext(options);
+  const ctx = createParserContext(options);
   const [tree, rootID, isObject] = parseSync(ctx, source);
-  const serial = new SerializationContext(ctx);
-  const result = serializeTree(serial, tree);
+  const serial = createSerializationContext(ctx);
+  const result = SerovalSerializer.serialize(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
 async function serializeAsync(source, options) {
-  const ctx = new ParserContext(options);
+  const ctx = createParserContext(options);
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
-  const serial = new SerializationContext(ctx);
-  const result = serializeTree(serial, tree);
+  const serial = createSerializationContext(ctx);
+  const result = SerovalSerializer.serialize(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
 function deserialize(source) {
   return (0, eval)(source);
 }
 function toJSON(source, options) {
-  const ctx = new ParserContext(options);
+  const ctx = createParserContext(options);
   const [tree, root, isObject] = parseSync(ctx, source);
-  return JSON.stringify([
-    tree,
-    root,
-    isObject,
-    ctx.features,
-    ctx.markedRefs
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(ctx.markedRefs)
+  });
 }
 async function toJSONAsync(source, options) {
-  const ctx = new ParserContext(options);
+  const ctx = createParserContext(options);
   const [tree, root, isObject] = await parseAsync(ctx, source);
-  return JSON.stringify([
-    tree,
-    root,
-    isObject,
-    ctx.features,
-    ctx.markedRefs
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(ctx.markedRefs)
+  });
 }
 function compileJSON(source) {
   const parsed = JSON.parse(source);
-  const serial = new SerializationContext({
-    features: parsed[3],
-    markedRefs: parsed[4]
+  const serial = createSerializationContext({
+    features: parsed.f,
+    markedRefs: parsed.m
   });
-  const result = serializeTree(serial, parsed[0]);
-  return finalize(serial, parsed[1], parsed[2], result);
+  const result = SerovalSerializer.serialize(serial, parsed.t);
+  return finalize(serial, parsed.r, parsed.i, result);
 }
 function fromJSON(source) {
   return deserialize(compileJSON(source));