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

package/dist/esm/development/index.mjs

@@ -249,35 +249,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];
@@ -359,198 +351,119 @@ function quote(str) {
   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}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 = "";
+  const cap = current.length - 1;
+  for (let i = 0; i < cap; i++) {
+    result += `${current[i]}n,`;
+  }
+  result += `"${current[cap]}"`;
+  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) {
@@ -602,9 +515,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;
@@ -662,7 +572,17 @@ var AsyncParser = class {
     return nodes;
   }
   async generateArrayNode(id, current) {
-    return new SerovalArrayNode(id, await this.generateNodeList(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(current),
+      n: void 0
+    };
   }
   async generateMapNode(id, current) {
     assert(this.ctx.features & 16 /* Map */, 'Unsupported type "Map"');
@@ -688,7 +608,17 @@ var AsyncParser = class {
       keyNodes[nodeSize + i] = await this.parse(deferredKey[i]);
       valueNodes[nodeSize + i] = await this.parse(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"');
@@ -707,7 +637,17 @@ var AsyncParser = class {
     for (let i = 0; i < deferredSize; i++) {
       nodes[nodeSize + i] = await this.parse(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) {
     const keys = Object.keys(properties);
@@ -735,21 +675,42 @@ var AsyncParser = class {
       keyNodes[nodesSize + i] = deferredKeys[i];
       valueNodes[nodesSize + i] = await this.parse(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"');
     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(options) : void 0,
+      a: await this.generateNodeList(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)));
+    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(value)
+    }));
   }
   async generateObjectNode(id, current, empty) {
     if (Symbol.iterator in current) {
@@ -758,26 +719,47 @@ var AsyncParser = class {
     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 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(current),
+      a: void 0,
+      n: void 0
+    };
   }
   async generateAggregateErrorNode(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)
-    );
+    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(current.errors)
+    };
   }
   async generateErrorNode(id, current) {
     const options = getErrorOptions(current);
     const optionsNode = options ? await this.generateProperties(options) : void 0;
-    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
+    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) {
     switch (typeof current) {
@@ -786,37 +768,36 @@ var AsyncParser = class {
       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(this.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);
+        if (this.ctx.markedRefs.has(id)) {
+          return createReferenceNode(id);
         }
         if (Array.isArray(current)) {
           return this.generateArrayNode(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);
           case Int8Array:
@@ -828,15 +809,10 @@ 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(this.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(this.ctx, id, current);
           case Map:
             return this.generateMapNode(id, current);
           case Set:
@@ -891,13 +867,13 @@ async function parseAsync(ctx, current) {
 
 // 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 "";
   }
@@ -908,25 +884,27 @@ function mergeAssignments(assignments) {
   let prev = current;
   for (let i = 1, len = assignments.length; i < len; i++) {
     const item = assignments[i];
-    if (item.type === prev.type) {
-      if (item.type === "index" && item.value === prev.value) {
+    if (item.t === prev.t) {
+      if (item.t === "index" && item.v === prev.v) {
         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);
@@ -955,34 +933,30 @@ 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) {
@@ -994,281 +968,296 @@ function createObjectAssign(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;
-  }
-  ctx.stack.pop();
-  return resolveAssignments(mainAssignments);
-}
-function serializeObject(ctx, sourceID, node) {
-  if (node.s === 0) {
-    return "{}";
+var SerovalSerializer = class {
+  constructor(ctx) {
+    __publicField(this, "ctx");
+    this.ctx = ctx;
   }
-  let result = "";
-  ctx.stack.push(sourceID);
-  for (let i = 0; i < node.s; i++) {
-    const key = node.k[i];
-    const val = node.v[i];
-    const check = Number(key);
-    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-    if (isReferenceInStack(ctx, val)) {
-      const refParam = getRefParam(ctx, val.i);
-      if (isIdentifier && Number.isNaN(check)) {
-        createObjectAssign(ctx, sourceID, key, refParam);
-      } else {
-        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
-      }
-    } else {
-      result += `${isIdentifier ? key : quote(key)}:${serializeTree(ctx, val)},`;
+  assignRef(index, value) {
+    if (this.ctx.markedRefs.has(index)) {
+      return `${getRefParam(this.ctx, index)}=${value}`;
     }
+    return value;
   }
-  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 {
-    ctx.stack.push(node.i);
-    const result = serializeTree(ctx, node.n);
-    ctx.stack.pop();
-    serialized = `Promise.resolve(${result})`;
+  isReferenceInStack(node) {
+    return node.t === 2 /* Reference */ && this.ctx.stack.includes(node.i);
   }
-  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) {
-    let result = "";
-    ctx.stack.push(node.i);
+  serializeNodeList(node) {
+    const size = node.a.length;
+    let values = "";
     for (let i = 0; i < size; i++) {
       const item = node.a[i];
-      if (isReferenceInStack(ctx, item)) {
-        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
+      if (item) {
+        if (this.isReferenceInStack(item)) {
+          createArrayAssign(this.ctx, node.i, i, getRefParam(this.ctx, item.i));
+          values += ",";
+        } else {
+          values += this.serialize(item);
+          if (i < size - 1) {
+            values += ",";
+          }
+        }
       } else {
-        result += `${serializeTree(ctx, item)},`;
+        values += ",";
       }
     }
-    ctx.stack.pop();
-    if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
-    }
+    return `[${values}]`;
   }
-  return assignRef(ctx, node.i, serialized);
-}
-function serializeMap(ctx, node) {
-  let serialized = "new Map";
-  if (node.d.s) {
+  serializeArray(node) {
+    this.ctx.stack.push(node.i);
+    const result = this.serializeNodeList(node);
+    this.ctx.stack.pop();
+    return this.assignRef(node.i, result);
+  }
+  serializeObject(sourceID, node) {
+    if (node.s === 0) {
+      return "{}";
+    }
     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);
+    this.ctx.stack.push(sourceID);
+    for (let i = 0; i < node.s; i++) {
+      const key = node.k[i];
+      const val = node.v[i];
+      const check = Number(key);
+      const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+      if (this.isReferenceInStack(val)) {
+        const refParam = getRefParam(this.ctx, val.i);
+        if (isIdentifier && Number.isNaN(check)) {
+          createObjectAssign(this.ctx, sourceID, key, refParam);
         } else {
-          const parent = ctx.stack;
-          ctx.stack = [];
-          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
-          ctx.stack = parent;
+          createArrayAssign(this.ctx, sourceID, isIdentifier ? key : quote(key), refParam);
         }
-      } else if (isReferenceInStack(ctx, val)) {
-        const valueRef = getRefParam(ctx, val.i);
-        const parent = ctx.stack;
-        ctx.stack = [];
-        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
-        ctx.stack = parent;
       } else {
-        result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
+        result += `${isIdentifier ? key : quote(key)}:${this.serialize(val)},`;
       }
     }
-    ctx.stack.pop();
-    if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
-    }
+    this.ctx.stack.pop();
+    return `{${result.substring(0, result.length - 1)}}`;
   }
-  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 += ",";
+  serializeWithObjectAssign(value, id, serialized) {
+    const fields = this.serializeObject(id, value);
+    if (fields !== "{}") {
+      return `Object.assign(${serialized},${fields})`;
+    }
+    return serialized;
+  }
+  serializeAssignments(sourceID, node) {
+    this.ctx.stack.push(sourceID);
+    const mainAssignments = [];
+    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);
+      if (isIdentifier && Number.isNaN(check)) {
+        createObjectAssign(this.ctx, sourceID, key, refParam);
       } else {
-        values += serializeTree(ctx, item);
-        if (i < size - 1) {
-          values += ",";
-        }
+        createArrayAssign(this.ctx, sourceID, isIdentifier ? key : quote(key), refParam);
       }
-    } else {
-      values += ",";
+      this.ctx.assignments = parentAssignment;
     }
+    this.ctx.stack.pop();
+    return resolveAssignments(mainAssignments);
   }
-  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);
+  serializeNullConstructor(node) {
+    let serialized = "Object.create(null)";
+    if (this.ctx.features & 64 /* ObjectAssign */) {
+      serialized = this.serializeWithObjectAssign(node.d, node.i, serialized);
     } else {
-      markRef(ctx, node.i);
-      const assignments = serializeAssignments(ctx, node.i, node.d);
+      markRef(this.ctx, node.i);
+      const assignments = this.serializeAssignments(node.i, node.d);
       if (assignments) {
-        const ref = getRefParam(ctx, node.i);
-        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
+        const ref = getRefParam(this.ctx, node.i);
+        return `(${this.assignRef(node.i, serialized)},${assignments}${ref})`;
       }
     }
-  }
-  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 this.assignRef(node.i, serialized);
+  }
+  serializeSet(node) {
+    let serialized = "new Set";
+    const size = node.a.length;
+    if (size) {
+      let result = "";
+      this.ctx.stack.push(node.i);
+      for (let i = 0; i < size; i++) {
+        const item = node.a[i];
+        if (this.isReferenceInStack(item)) {
+          createSetAdd(this.ctx, node.i, getRefParam(this.ctx, item.i));
+        } else {
+          result += `${this.serialize(item)},`;
+        }
+      }
+      this.ctx.stack.pop();
+      if (result) {
+        serialized += `([${result.substring(0, result.length - 1)}])`;
+      }
+    }
+    return this.assignRef(node.i, serialized);
+  }
+  serializeMap(node) {
+    let serialized = "new Map";
+    if (node.d.s) {
+      let result = "";
+      this.ctx.stack.push(node.i);
+      for (let i = 0; i < node.d.s; i++) {
+        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);
+          } else {
+            const parent = this.ctx.stack;
+            this.ctx.stack = [];
+            createMapSet(this.ctx, node.i, keyRef, this.serialize(val));
+            this.ctx.stack = parent;
+          }
+        } else if (this.isReferenceInStack(val)) {
+          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 {
+          result += `[${this.serialize(key)},${this.serialize(val)}],`;
+        }
+      }
+      this.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})`;
+        }
       }
     }
+    return this.assignRef(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]()`;
+  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);
   }
-  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}}}`;
+  serializePromise(node) {
+    let serialized;
+    if (this.isReferenceInStack(node.n)) {
+      serialized = `Promise.resolve().then(()=>${getRefParam(this.ctx, node.n.i)})`;
+    } else {
+      this.ctx.stack.push(node.i);
+      const result = this.serialize(node.n);
+      this.ctx.stack.pop();
+      serialized = `Promise.resolve(${result})`;
+    }
+    return this.assignRef(node.i, serialized);
   }
-  if (node.d) {
-    if (ctx.features & 64 /* ObjectAssign */) {
-      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
+  serializeTypedArray(node) {
+    let args = `[${node.s}]`;
+    if (node.l !== 0) {
+      args += `,${node.l}`;
+    }
+    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()`;
     } else {
-      markRef(ctx, node.i);
-      const assignments = serializeAssignments(ctx, node.i, node.d);
-      if (assignments) {
-        const ref = getRefParam(ctx, node.i);
-        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
+      serialized = `${values}[Symbol.iterator]()`;
+    }
+    if (this.ctx.features & 4 /* ArrowFunction */) {
+      serialized = `{[Symbol.iterator]:()=>${serialized}}`;
+    } else if (this.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})`;
+        }
       }
     }
-  }
-  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})`;
+    return this.assignRef(node.i, serialized);
+  }
+  serialize(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);
+      case 7 /* Array */:
+        return this.serializeArray(node);
+      case 8 /* Object */:
+        return this.assignRef(node.i, this.serializeObject(node.i, node.d));
+      case 9 /* NullConstructor */:
+        return this.serializeNullConstructor(node);
+      case 3 /* Date */:
+        return this.assignRef(node.i, `new Date("${node.s}")`);
+      case 4 /* RegExp */:
+        return this.assignRef(node.i, node.s);
+      case 5 /* Set */:
+        return this.serializeSet(node);
+      case 6 /* Map */:
+        return this.serializeMap(node);
+      case 15 /* BigIntTypedArray */:
+      case 14 /* TypedArray */:
+        return this.serializeTypedArray(node);
+      case 12 /* AggregateError */:
+        return this.serializeAggregateError(node);
+      case 11 /* Error */:
+        return this.serializeError(node);
+      case 13 /* Iterable */:
+        return this.serializeIterable(node);
+      case 10 /* Promise */:
+        return this.serializePromise(node);
+      default:
+        throw new Error("Unsupported type");
     }
   }
-  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");
-  }
-}
+};
 
 // src/tree/sync.ts
 var SyncParser = class {
@@ -1299,7 +1288,17 @@ var SyncParser = class {
     return nodes;
   }
   generateArrayNode(id, current) {
-    return new SerovalArrayNode(id, this.generateNodeList(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(current),
+      n: void 0
+    };
   }
   generateMapNode(id, current) {
     assert(this.ctx.features & 16 /* Map */, 'Unsupported type "Map"');
@@ -1325,7 +1324,17 @@ var SyncParser = class {
       keyNodes[nodeSize + i] = this.parse(deferredKey[i]);
       valueNodes[nodeSize + i] = this.parse(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"');
@@ -1344,7 +1353,17 @@ var SyncParser = class {
     for (let i = 0; i < deferredSize; i++) {
       nodes[nodeSize + i] = this.parse(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) {
     const keys = Object.keys(properties);
@@ -1381,36 +1400,64 @@ var SyncParser = class {
   generateIterableNode(id, current) {
     assert(this.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(options) : void 0,
+      a: this.generateNodeList(Array.from(current)),
+      n: void 0
+    };
   }
   generateObjectNode(id, current, empty) {
     if (Symbol.iterator in current) {
       return this.generateIterableNode(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(current),
+      a: void 0,
+      n: void 0
+    };
   }
   generateAggregateErrorNode(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)
-    );
+    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(current.errors)
+    };
   }
   generateErrorNode(id, current) {
     const options = getErrorOptions(current);
     const optionsNode = options ? this.generateProperties(options) : void 0;
-    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
+    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) {
     switch (typeof current) {
@@ -1419,37 +1466,36 @@ var SyncParser = class {
       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(this.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);
+        if (this.ctx.markedRefs.has(id)) {
+          return createReferenceNode(id);
         }
         if (Array.isArray(current)) {
           return this.generateArrayNode(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:
@@ -1459,15 +1505,10 @@ 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(this.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(this.ctx, id, current);
           case Map:
             return this.generateMapNode(id, current);
           case Set:
@@ -1540,52 +1581,52 @@ function finalize(ctx, rootID, isObject, 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 = new SerovalSerializer(serial).serialize(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 = new SerovalSerializer(serial).serialize(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 = new SerovalSerializer(serial).serialize(parsed.t);
+  return finalize(serial, parsed.r, parsed.i, result);
 }
 function fromJSON(source) {
   return deserialize(compileJSON(source));