seroval 0.4.0-alpha.14 → 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) {
@@ -379,7 +378,7 @@ function quote(str) {
   } else {
     result += str.slice(lastPos);
   }
-  return `"${result}"`;
+  return '"' + result + '"';
 }
 
 // src/tree/primitives.ts
@@ -408,7 +407,7 @@ function createBigIntNode(ctx, current) {
   return {
     t: 1 /* BigInt */,
     i: void 0,
-    s: `${current}n`,
+    s: current.toString() + "n",
     l: void 0,
     c: void 0,
     m: void 0,
@@ -478,11 +477,12 @@ function createBigIntTypedArrayNode(ctx, id, current) {
     `Unsupported value type "${constructor}"`
   );
   let result = "";
-  const cap = current.length - 1;
-  for (let i = 0; i < cap; i++) {
-    result += `${current[i]}n,`;
+  for (let i = 0, len = current.length; i < len; i++) {
+    if (i !== 0) {
+      result += ",";
+    }
+    result += current[i].toString() + "n";
   }
-  result += `"${current[cap]}"`;
   return {
     t: 15 /* BigIntTypedArray */,
     i: id,
@@ -576,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);
@@ -591,18 +587,18 @@ 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) {
+  static async generateArrayNode(ctx, id, current) {
     return {
       t: 7 /* Array */,
       i: id,
@@ -611,12 +607,12 @@ var AsyncParser = class {
       c: void 0,
       m: void 0,
       d: void 0,
-      a: await this.generateNodeList(current),
+      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);
@@ -630,14 +626,14 @@ 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 {
       t: 6 /* Map */,
@@ -651,8 +647,8 @@ var AsyncParser = class {
       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);
@@ -662,11 +658,11 @@ 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 {
       t: 5 /* Set */,
@@ -680,7 +676,7 @@ var AsyncParser = class {
       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);
@@ -698,13 +694,13 @@ 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 {
       k: keyNodes,
@@ -712,8 +708,8 @@ var AsyncParser = class {
       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 {
       t: 13 /* Iterable */,
@@ -723,13 +719,13 @@ var AsyncParser = class {
       c: void 0,
       m: void 0,
       // Parse options first before the items
-      d: options ? await this.generateProperties(options) : void 0,
-      a: 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"');
+  static async generatePromiseNode(ctx, id, current) {
+    assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
     return current.then(async (value) => ({
       t: 10 /* Promise */,
       i: id,
@@ -740,15 +736,15 @@ var AsyncParser = class {
       // Parse options first before the items
       d: void 0,
       a: void 0,
-      n: await this.parse(value)
+      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);
+      return this.generatePromiseNode(ctx, id, current);
     }
     return {
       t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
@@ -757,14 +753,14 @@ var AsyncParser = class {
       l: void 0,
       c: void 0,
       m: void 0,
-      d: await this.generateProperties(current),
+      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;
+    const optionsNode = options ? await this.generateProperties(ctx, options) : void 0;
     return {
       t: 12 /* AggregateError */,
       i: id,
@@ -774,12 +770,12 @@ var AsyncParser = class {
       m: current.message,
       d: optionsNode,
       a: void 0,
-      n: await this.parse(current.errors)
+      n: await this.parse(ctx, current.errors)
     };
   }
-  async generateErrorNode(id, current) {
+  static async generateErrorNode(ctx, id, current) {
     const options = getErrorOptions(current);
-    const optionsNode = options ? await this.generateProperties(options) : void 0;
+    const optionsNode = options ? await this.generateProperties(ctx, options) : void 0;
     return {
       t: 11 /* Error */,
       i: id,
@@ -792,7 +788,7 @@ var AsyncParser = class {
       n: void 0
     };
   }
-  async parse(current) {
+  static async parse(ctx, current) {
     switch (typeof current) {
       case "boolean":
         return current ? TRUE_NODE : FALSE_NODE;
@@ -812,17 +808,17 @@ var AsyncParser = class {
         }
         return createPrimitiveNode(current);
       case "bigint":
-        return createBigIntNode(this.ctx, current);
+        return createBigIntNode(ctx, current);
       case "object": {
         if (!current) {
           return NULL_NODE;
         }
-        const id = createRef(this.ctx, current, true);
-        if (this.ctx.markedRefs.has(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:
@@ -830,7 +826,7 @@ var AsyncParser = class {
           case RegExp:
             return createRegExpNode(id, current);
           case Promise:
-            return this.generatePromiseNode(id, current);
+            return this.generatePromiseNode(ctx, id, current);
           case Int8Array:
           case Int16Array:
           case Int32Array:
@@ -840,23 +836,41 @@ var AsyncParser = class {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            return createTypedArrayNode(this.ctx, id, current);
+            return createTypedArrayNode(ctx, id, current);
           case BigInt64Array:
           case BigUint64Array:
-            return createBigIntTypedArrayNode(this.ctx, 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:
@@ -864,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");
       }
@@ -891,7 +905,7 @@ 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];
 }
@@ -900,11 +914,11 @@ async function parseAsync(ctx, current) {
 function getAssignmentExpression(assignment) {
   switch (assignment.t) {
     case "index":
-      return `${assignment.s}=${assignment.v}`;
+      return assignment.s + "=" + assignment.v;
     case "map":
-      return `${assignment.s}.set(${assignment.k},${assignment.v})`;
+      return assignment.s + ".set(" + assignment.k + "," + assignment.v + ")";
     case "set":
-      return `${assignment.s}.add(${assignment.v})`;
+      return assignment.s + ".add(" + assignment.v + ")";
     default:
       return "";
   }
@@ -913,8 +927,9 @@ 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];
+    item = assignments[i];
     if (item.t === prev.t) {
       if (item.t === "index" && item.v === prev.v) {
         current = {
@@ -955,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;
   }
@@ -992,298 +1007,301 @@ function createMapSet(ctx, ref, key, 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);
+}
+function assignRef(ctx, index, value) {
+  if (ctx.markedRefs.has(index)) {
+    return getRefParam(ctx, index) + "=" + value;
+  }
+  return value;
+}
+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 {
-  constructor(ctx) {
-    __publicField(this, "ctx");
-    this.ctx = ctx;
-  }
-  assignRef(index, value) {
-    if (this.ctx.markedRefs.has(index)) {
-      return `${getRefParam(this.ctx, index)}=${value}`;
-    }
-    return value;
-  }
-  isReferenceInStack(node) {
-    return node.t === 2 /* Reference */ && this.ctx.stack.includes(node.i);
-  }
-  serializeNodeList(node) {
+  static serializeNodeList(ctx, node) {
     const size = node.a.length;
     let values = "";
+    let item;
+    let isHoley = false;
     for (let i = 0; i < size; i++) {
-      const item = node.a[i];
+      if (i !== 0) {
+        values += ",";
+      }
+      item = node.a[i];
       if (item) {
-        if (this.isReferenceInStack(item)) {
-          createArrayAssign(this.ctx, node.i, i, getRefParam(this.ctx, item.i));
-          values += ",";
+        if (isReferenceInStack(ctx, item)) {
+          createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
+          isHoley = true;
         } else {
-          values += this.serialize(item);
-          if (i < size - 1) {
-            values += ",";
-          }
+          values += this.serialize(ctx, item);
+          isHoley = false;
         }
       } else {
-        values += ",";
+        isHoley = true;
       }
     }
-    return `[${values}]`;
+    if (isHoley) {
+      values += ",";
+    }
+    return "[" + values + "]";
   }
-  serializeArray(node) {
-    this.ctx.stack.push(node.i);
-    const result = this.serializeNodeList(node);
-    this.ctx.stack.pop();
-    return this.assignRef(node.i, result);
+  static serializeArray(ctx, node) {
+    ctx.stack.push(node.i);
+    const result = this.serializeNodeList(ctx, node);
+    ctx.stack.pop();
+    return assignRef(ctx, node.i, result);
   }
-  serializeObject(sourceID, node) {
+  static serializeObject(ctx, sourceID, node) {
     if (node.s === 0) {
       return "{}";
     }
     let result = "";
-    this.ctx.stack.push(sourceID);
+    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++) {
-      const key = node.k[i];
-      const val = node.v[i];
-      const check = Number(key);
-      const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-      if (this.isReferenceInStack(val)) {
-        const refParam = getRefParam(this.ctx, val.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(this.ctx, sourceID, key, refParam);
+          createObjectAssign(ctx, sourceID, key, refParam);
         } else {
-          createArrayAssign(this.ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+          createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
         }
       } else {
-        result += `${isIdentifier ? key : quote(key)}:${this.serialize(val)},`;
+        if (hasPrev) {
+          result += ",";
+        }
+        result += isIdentifier ? key : quote(key);
+        result += ":" + this.serialize(ctx, val);
+        hasPrev = true;
       }
     }
-    this.ctx.stack.pop();
-    return `{${result.substring(0, result.length - 1)}}`;
+    ctx.stack.pop();
+    return "{" + result + "}";
   }
-  serializeWithObjectAssign(value, id, serialized) {
-    const fields = this.serializeObject(id, value);
+  static serializeWithObjectAssign(ctx, value, id, serialized) {
+    const fields = this.serializeObject(ctx, id, value);
     if (fields !== "{}") {
-      return `Object.assign(${serialized},${fields})`;
+      return "Object.assign(" + serialized + "," + fields + ")";
     }
     return serialized;
   }
-  serializeAssignments(sourceID, node) {
-    this.ctx.stack.push(sourceID);
+  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++) {
-      const parentStack = this.ctx.stack;
-      this.ctx.stack = [];
-      const refParam = this.serialize(node.v[i]);
-      this.ctx.stack = parentStack;
-      const key = node.k[i];
-      const check = Number(key);
-      const parentAssignment = this.ctx.assignments;
-      this.ctx.assignments = mainAssignments;
-      const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+      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(this.ctx, sourceID, key, refParam);
+        createObjectAssign(ctx, sourceID, key, refParam);
       } else {
-        createArrayAssign(this.ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
       }
-      this.ctx.assignments = parentAssignment;
+      ctx.assignments = parentAssignment;
     }
-    this.ctx.stack.pop();
+    ctx.stack.pop();
     return resolveAssignments(mainAssignments);
   }
-  serializeNullConstructor(node) {
-    let serialized = "Object.create(null)";
-    if (this.ctx.features & 64 /* ObjectAssign */) {
-      serialized = this.serializeWithObjectAssign(node.d, node.i, serialized);
-    } else {
-      markRef(this.ctx, node.i);
-      const assignments = this.serializeAssignments(node.i, node.d);
-      if (assignments) {
-        const ref = getRefParam(this.ctx, node.i);
-        return `(${this.assignRef(node.i, serialized)},${assignments}${ref})`;
+  static serializeDictionary(ctx, i, d, init) {
+    if (d) {
+      if (ctx.features & 64 /* ObjectAssign */) {
+        init = this.serializeWithObjectAssign(ctx, d, i, init);
+      } else {
+        markRef(ctx, i);
+        const assignments = this.serializeAssignments(ctx, i, d);
+        if (assignments) {
+          const ref = getRefParam(ctx, i);
+          return "(" + assignRef(ctx, i, init) + "," + assignments + ref + ")";
+        }
       }
     }
-    return this.assignRef(node.i, serialized);
+    return assignRef(ctx, i, init);
   }
-  serializeSet(node) {
+  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 = "";
-      this.ctx.stack.push(node.i);
+      ctx.stack.push(node.i);
+      let item;
+      let hasPrev = false;
       for (let i = 0; i < size; i++) {
-        const item = node.a[i];
-        if (this.isReferenceInStack(item)) {
-          createSetAdd(this.ctx, node.i, getRefParam(this.ctx, item.i));
+        item = node.a[i];
+        if (isReferenceInStack(ctx, item)) {
+          createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
         } else {
-          result += `${this.serialize(item)},`;
+          if (hasPrev) {
+            result += ",";
+          }
+          result += this.serialize(ctx, item);
+          hasPrev = true;
         }
       }
-      this.ctx.stack.pop();
+      ctx.stack.pop();
       if (result) {
-        serialized += `([${result.substring(0, result.length - 1)}])`;
+        serialized += "([" + result + "])";
       }
     }
-    return this.assignRef(node.i, serialized);
+    return assignRef(ctx, node.i, serialized);
   }
-  serializeMap(node) {
+  static serializeMap(ctx, node) {
     let serialized = "new Map";
     if (node.d.s) {
       let result = "";
-      this.ctx.stack.push(node.i);
+      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++) {
-        const key = node.d.k[i];
-        const val = node.d.v[i];
-        if (this.isReferenceInStack(key)) {
-          const keyRef = getRefParam(this.ctx, key.i);
-          if (this.isReferenceInStack(val)) {
-            const valueRef = getRefParam(this.ctx, val.i);
-            createMapSet(this.ctx, node.i, keyRef, valueRef);
+        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 {
-            const parent = this.ctx.stack;
-            this.ctx.stack = [];
-            createMapSet(this.ctx, node.i, keyRef, this.serialize(val));
-            this.ctx.stack = parent;
+            parent = ctx.stack;
+            ctx.stack = [];
+            createMapSet(ctx, node.i, keyRef, this.serialize(ctx, val));
+            ctx.stack = parent;
           }
-        } else if (this.isReferenceInStack(val)) {
-          const valueRef = getRefParam(this.ctx, val.i);
-          const parent = this.ctx.stack;
-          this.ctx.stack = [];
-          createMapSet(this.ctx, node.i, this.serialize(key), valueRef);
-          this.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 {
-          result += `[${this.serialize(key)},${this.serialize(val)}],`;
+          if (hasPrev) {
+            result += ",";
+          }
+          result += "[" + this.serialize(ctx, key) + "," + this.serialize(ctx, val) + "]";
+          hasPrev = true;
         }
       }
-      this.ctx.stack.pop();
+      ctx.stack.pop();
       if (result) {
-        serialized += `([${result.substring(0, result.length - 1)}])`;
-      }
-    }
-    return this.assignRef(node.i, serialized);
-  }
-  serializeAggregateError(node) {
-    this.ctx.stack.push(node.i);
-    let serialized = `new AggregateError(${this.serialize(node.n)},${quote(node.m)})`;
-    this.ctx.stack.pop();
-    if (node.d) {
-      if (this.ctx.features & 64 /* ObjectAssign */) {
-        serialized = this.serializeWithObjectAssign(node.d, node.i, serialized);
-      } else {
-        markRef(this.ctx, node.i);
-        const assignments = this.serializeAssignments(node.i, node.d);
-        if (assignments) {
-          const ref = getRefParam(this.ctx, node.i);
-          return `(${this.assignRef(node.i, serialized)},${assignments}${ref})`;
-        }
+        serialized += "([" + result + "])";
       }
     }
-    return this.assignRef(node.i, serialized);
+    return assignRef(ctx, node.i, serialized);
   }
-  serializeError(node) {
-    let serialized = `new ${node.c}(${quote(node.m)})`;
-    if (node.d) {
-      if (this.ctx.features & 64 /* ObjectAssign */) {
-        serialized = this.serializeWithObjectAssign(node.d, node.i, serialized);
-      } else {
-        markRef(this.ctx, node.i);
-        const assignments = this.serializeAssignments(node.i, node.d);
-        if (assignments) {
-          const ref = getRefParam(this.ctx, node.i);
-          return `(${this.assignRef(node.i, serialized)},${assignments}${ref})`;
-        }
-      }
-    }
-    return this.assignRef(node.i, serialized);
+  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);
+  }
+  static serializeError(ctx, node) {
+    const serialized = "new " + node.c + "(" + quote(node.m) + ")";
+    return this.serializeDictionary(ctx, node.i, node.d, serialized);
   }
-  serializePromise(node) {
+  static serializePromise(ctx, node) {
     let serialized;
-    if (this.isReferenceInStack(node.n)) {
-      serialized = `Promise.resolve().then(()=>${getRefParam(this.ctx, node.n.i)})`;
+    if (isReferenceInStack(ctx, node.n)) {
+      serialized = "Promise.resolve().then(()=>" + getRefParam(ctx, node.n.i) + ")";
     } else {
-      this.ctx.stack.push(node.i);
-      const result = this.serialize(node.n);
-      this.ctx.stack.pop();
-      serialized = `Promise.resolve(${result})`;
+      ctx.stack.push(node.i);
+      const result = this.serialize(ctx, node.n);
+      ctx.stack.pop();
+      serialized = "Promise.resolve(" + result + ")";
     }
-    return this.assignRef(node.i, serialized);
+    return assignRef(ctx, node.i, serialized);
   }
-  serializeTypedArray(node) {
-    let args = `[${node.s}]`;
+  static serializeTypedArray(ctx, node) {
+    let args = "[" + node.s + "]";
     if (node.l !== 0) {
-      args += `,${node.l}`;
+      args += "," + node.l.toString();
     }
-    return this.assignRef(node.i, `new ${node.c}(${args})`);
-  }
-  serializeIterable(node) {
-    const parent = this.ctx.stack;
-    this.ctx.stack = [];
-    const values = this.serializeNodeList(node);
-    this.ctx.stack = parent;
-    let serialized;
-    if (this.ctx.features & 2 /* ArrayPrototypeValues */) {
-      serialized = `${values}.values()`;
+    return assignRef(ctx, node.i, "new " + node.c + "(" + args + ")");
+  }
+  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 = `${values}[Symbol.iterator]()`;
+      serialized += "[Symbol.iterator]()";
     }
-    if (this.ctx.features & 4 /* ArrowFunction */) {
-      serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-    } else if (this.ctx.features & 32 /* MethodShorthand */) {
-      serialized = `{[Symbol.iterator](){return ${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}}}`;
-    }
-    if (node.d) {
-      if (this.ctx.features & 64 /* ObjectAssign */) {
-        serialized = this.serializeWithObjectAssign(node.d, node.i, serialized);
-      } else {
-        markRef(this.ctx, node.i);
-        const assignments = this.serializeAssignments(node.i, node.d);
-        if (assignments) {
-          const ref = getRefParam(this.ctx, node.i);
-          return `(${this.assignRef(node.i, serialized)},${assignments}${ref})`;
-        }
-      }
+      serialized = "{[Symbol.iterator]:function(){return " + serialized + "}}";
     }
-    return this.assignRef(node.i, serialized);
+    return this.serializeDictionary(ctx, node.i, node.d, serialized);
   }
-  serialize(node) {
+  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(this.ctx, node.i);
+        return getRefParam(ctx, node.i);
       case 7 /* Array */:
-        return this.serializeArray(node);
+        return this.serializeArray(ctx, node);
       case 8 /* Object */:
-        return this.assignRef(node.i, this.serializeObject(node.i, node.d));
+        return assignRef(ctx, node.i, this.serializeObject(ctx, node.i, node.d));
       case 9 /* NullConstructor */:
-        return this.serializeNullConstructor(node);
+        return this.serializeNullConstructor(ctx, node);
       case 3 /* Date */:
-        return this.assignRef(node.i, `new Date("${node.s}")`);
+        return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
       case 4 /* RegExp */:
-        return this.assignRef(node.i, node.s);
+        return assignRef(ctx, node.i, node.s);
       case 5 /* Set */:
-        return this.serializeSet(node);
+        return this.serializeSet(ctx, node);
       case 6 /* Map */:
-        return this.serializeMap(node);
+        return this.serializeMap(ctx, node);
       case 15 /* BigIntTypedArray */:
       case 14 /* TypedArray */:
-        return this.serializeTypedArray(node);
+        return this.serializeTypedArray(ctx, node);
       case 12 /* AggregateError */:
-        return this.serializeAggregateError(node);
+        return this.serializeAggregateError(ctx, node);
       case 11 /* Error */:
-        return this.serializeError(node);
+        return this.serializeError(ctx, node);
       case 13 /* Iterable */:
-        return this.serializeIterable(node);
+        return this.serializeIterable(ctx, node);
       case 10 /* Promise */:
-        return this.serializePromise(node);
+        return this.serializePromise(ctx, node);
       default:
         throw new Error("Unsupported type");
     }
@@ -1292,11 +1310,7 @@ var SerovalSerializer = class {
 
 // 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);
@@ -1307,18 +1321,18 @@ 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) {
+  static generateArrayNode(ctx, id, current) {
     return {
       t: 7 /* Array */,
       i: id,
@@ -1327,12 +1341,12 @@ var SyncParser = class {
       c: void 0,
       m: void 0,
       d: void 0,
-      a: this.generateNodeList(current),
+      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);
@@ -1346,14 +1360,14 @@ 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 {
       t: 6 /* Map */,
@@ -1367,8 +1381,8 @@ var SyncParser = class {
       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);
@@ -1378,11 +1392,11 @@ 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 {
       t: 5 /* Set */,
@@ -1396,7 +1410,7 @@ var SyncParser = class {
       n: void 0
     };
   }
-  generateProperties(properties) {
+  static generateProperties(ctx, properties) {
     const keys = Object.keys(properties);
     const size = keys.length;
     const keyNodes = new Array(size);
@@ -1414,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,
@@ -1428,8 +1442,8 @@ 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 {
       t: 13 /* Iterable */,
@@ -1439,14 +1453,14 @@ var SyncParser = class {
       c: void 0,
       m: void 0,
       // Parse options first before the items
-      d: options ? this.generateProperties(options) : void 0,
-      a: 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);
     }
     return {
       t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
@@ -1455,14 +1469,14 @@ var SyncParser = class {
       l: void 0,
       c: void 0,
       m: void 0,
-      d: this.generateProperties(current),
+      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;
+    const optionsNode = options ? this.generateProperties(ctx, options) : void 0;
     return {
       t: 12 /* AggregateError */,
       i: id,
@@ -1472,12 +1486,12 @@ var SyncParser = class {
       m: current.message,
       d: optionsNode,
       a: void 0,
-      n: this.parse(current.errors)
+      n: this.parse(ctx, current.errors)
     };
   }
-  generateErrorNode(id, current) {
+  static generateErrorNode(ctx, id, current) {
     const options = getErrorOptions(current);
-    const optionsNode = options ? this.generateProperties(options) : void 0;
+    const optionsNode = options ? this.generateProperties(ctx, options) : void 0;
     return {
       t: 11 /* Error */,
       i: id,
@@ -1490,7 +1504,7 @@ var SyncParser = class {
       n: void 0
     };
   }
-  parse(current) {
+  static parse(ctx, current) {
     switch (typeof current) {
       case "boolean":
         return current ? TRUE_NODE : FALSE_NODE;
@@ -1510,17 +1524,17 @@ var SyncParser = class {
         }
         return createPrimitiveNode(current);
       case "bigint":
-        return createBigIntNode(this.ctx, current);
+        return createBigIntNode(ctx, current);
       case "object": {
         if (!current) {
           return NULL_NODE;
         }
-        const id = createRef(this.ctx, current, true);
-        if (this.ctx.markedRefs.has(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:
@@ -1536,23 +1550,23 @@ var SyncParser = class {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            return createTypedArrayNode(this.ctx, id, current);
+            return createTypedArrayNode(ctx, id, current);
           case BigInt64Array:
           case BigUint64Array:
-            return createBigIntTypedArrayNode(this.ctx, 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:
@@ -1560,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");
       }
@@ -1581,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];
 }
@@ -1593,21 +1607,20 @@ 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;
 }
@@ -1615,14 +1628,14 @@ function serialize(source, options) {
   const ctx = createParserContext(options);
   const [tree, rootID, isObject] = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
-  const result = new SerovalSerializer(serial).serialize(tree);
+  const result = SerovalSerializer.serialize(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
 async function serializeAsync(source, options) {
   const ctx = createParserContext(options);
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
-  const result = new SerovalSerializer(serial).serialize(tree);
+  const result = SerovalSerializer.serialize(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
 function deserialize(source) {
@@ -1656,7 +1669,7 @@ function compileJSON(source) {
     features: parsed.f,
     markedRefs: parsed.m
   });
-  const result = new SerovalSerializer(serial).serialize(parsed.t);
+  const result = SerovalSerializer.serialize(serial, parsed.t);
   return finalize(serial, parsed.r, parsed.i, result);
 }
 function fromJSON(source) {