seroval 0.4.0-alpha.12 → 0.4.0-alpha.14

package/dist/cjs/development/index.cjs

@@ -283,7 +283,7 @@ var DEFAULT_OPTIONS = {
 function createParserContext(options = {}) {
   const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    markedRefs: {},
+    markedRefs: /* @__PURE__ */ new Set(),
     refs: /* @__PURE__ */ new Map(),
     features: parseTargets(result.target)
   };
@@ -296,11 +296,11 @@ function createSerializationContext(options) {
     validRefs: [],
     refSize: 0,
     features: options.features,
-    markedRefs: options.markedRefs
+    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];
@@ -389,8 +389,8 @@ function createPrimitiveNode(value) {
     i: void 0,
     s: value,
     l: void 0,
-    m: void 0,
     c: void 0,
+    m: void 0,
     d: void 0,
     a: void 0,
     n: void 0
@@ -408,12 +408,12 @@ function createBigIntNode(ctx, current) {
   return {
     t: 1 /* BigInt */,
     i: void 0,
-    a: void 0,
     s: `${current}n`,
     l: void 0,
-    m: void 0,
     c: void 0,
+    m: void 0,
     d: void 0,
+    a: void 0,
     n: void 0
   };
 }
@@ -421,12 +421,12 @@ function createReferenceNode(id) {
   return {
     t: 2 /* Reference */,
     i: id,
-    a: void 0,
     s: void 0,
     l: void 0,
-    m: void 0,
     c: void 0,
+    m: void 0,
     d: void 0,
+    a: void 0,
     n: void 0
   };
 }
@@ -434,25 +434,25 @@ function createDateNode(id, current) {
   return {
     t: 3 /* Date */,
     i: id,
-    a: void 0,
     s: current.toISOString(),
     l: void 0,
-    m: void 0,
     c: void 0,
+    m: void 0,
     d: void 0,
-    n: void 0
+    n: void 0,
+    a: void 0
   };
 }
 function createRegExpNode(id, current) {
   return {
     t: 4 /* RegExp */,
     i: id,
-    a: void 0,
     s: String(current),
     l: void 0,
-    m: void 0,
     c: void 0,
+    m: void 0,
     d: void 0,
+    a: void 0,
     n: void 0
   };
 }
@@ -462,12 +462,12 @@ function createTypedArrayNode(ctx, id, current) {
   return {
     t: 14 /* TypedArray */,
     i: id,
-    a: void 0,
     s: current.toString(),
     l: current.byteOffset,
-    m: void 0,
     c: constructor,
+    m: void 0,
     d: void 0,
+    a: void 0,
     n: void 0
   };
 }
@@ -486,12 +486,12 @@ function createBigIntTypedArrayNode(ctx, id, current) {
   return {
     t: 15 /* BigIntTypedArray */,
     i: id,
-    a: void 0,
     s: result,
     l: current.byteOffset,
-    m: void 0,
     c: constructor,
+    m: void 0,
     d: void 0,
+    a: void 0,
     n: void 0
   };
 }
@@ -546,9 +546,6 @@ function getIterableOptions(obj) {
   }
   return void 0;
 }
-function isReferenceInStack(ctx, node) {
-  return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
-}
 function isIterable(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -609,12 +606,12 @@ var AsyncParser = class {
     return {
       t: 7 /* Array */,
       i: id,
-      a: await this.generateNodeList(current),
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       d: void 0,
+      a: await this.generateNodeList(current),
       n: void 0
     };
   }
@@ -645,12 +642,12 @@ var AsyncParser = class {
     return {
       t: 6 /* Map */,
       i: id,
-      a: void 0,
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       d: { k: keyNodes, v: valueNodes, s: len },
+      a: void 0,
       n: void 0
     };
   }
@@ -674,12 +671,12 @@ var AsyncParser = class {
     return {
       t: 5 /* Set */,
       i: id,
-      a: nodes,
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       d: void 0,
+      a: nodes,
       n: void 0
     };
   }
@@ -723,8 +720,8 @@ var AsyncParser = class {
       i: id,
       s: void 0,
       l: void 0,
-      m: void 0,
       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)),
@@ -738,8 +735,8 @@ var AsyncParser = class {
       i: id,
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       // Parse options first before the items
       d: void 0,
       a: void 0,
@@ -758,8 +755,8 @@ var AsyncParser = class {
       i: id,
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       d: await this.generateProperties(current),
       a: void 0,
       n: void 0
@@ -771,12 +768,12 @@ var AsyncParser = class {
     return {
       t: 12 /* AggregateError */,
       i: id,
-      a: void 0,
       s: void 0,
       l: void 0,
-      m: current.message,
       c: void 0,
+      m: current.message,
       d: optionsNode,
+      a: void 0,
       n: await this.parse(current.errors)
     };
   }
@@ -786,12 +783,12 @@ var AsyncParser = class {
     return {
       t: 11 /* Error */,
       i: id,
-      a: void 0,
       s: void 0,
       l: void 0,
-      m: current.message,
       c: getErrorConstructor(current),
+      m: current.message,
       d: optionsNode,
+      a: void 0,
       n: void 0
     };
   }
@@ -821,7 +818,7 @@ var AsyncParser = class {
           return NULL_NODE;
         }
         const id = createRef(this.ctx, current, true);
-        if (this.ctx.markedRefs[id]) {
+        if (this.ctx.markedRefs.has(id)) {
           return createReferenceNode(id);
         }
         if (Array.isArray(current)) {
@@ -901,13 +898,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 "";
   }
@@ -918,25 +915,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);
@@ -965,34 +964,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) {
@@ -1004,281 +999,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})`;
-  }
-  return assignRef(ctx, node.i, serialized);
-}
-function serializeTypedArray(ctx, node) {
-  let args = `[${node.s}]`;
-  if (node.l !== 0) {
-    args += `,${node.l}`;
+  isReferenceInStack(node) {
+    return node.t === 2 /* Reference */ && this.ctx.stack.includes(node.i);
   }
-  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 {
@@ -1312,12 +1322,12 @@ var SyncParser = class {
     return {
       t: 7 /* Array */,
       i: id,
-      a: this.generateNodeList(current),
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       d: void 0,
+      a: this.generateNodeList(current),
       n: void 0
     };
   }
@@ -1348,12 +1358,12 @@ var SyncParser = class {
     return {
       t: 6 /* Map */,
       i: id,
-      a: void 0,
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       d: { k: keyNodes, v: valueNodes, s: len },
+      a: void 0,
       n: void 0
     };
   }
@@ -1377,12 +1387,12 @@ var SyncParser = class {
     return {
       t: 5 /* Set */,
       i: id,
-      a: nodes,
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       d: void 0,
+      a: nodes,
       n: void 0
     };
   }
@@ -1426,8 +1436,8 @@ var SyncParser = class {
       i: id,
       s: void 0,
       l: void 0,
-      m: void 0,
       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)),
@@ -1443,8 +1453,8 @@ var SyncParser = class {
       i: id,
       s: void 0,
       l: void 0,
-      m: void 0,
       c: void 0,
+      m: void 0,
       d: this.generateProperties(current),
       a: void 0,
       n: void 0
@@ -1456,12 +1466,12 @@ var SyncParser = class {
     return {
       t: 12 /* AggregateError */,
       i: id,
-      a: void 0,
       s: void 0,
       l: void 0,
-      m: current.message,
       c: void 0,
+      m: current.message,
       d: optionsNode,
+      a: void 0,
       n: this.parse(current.errors)
     };
   }
@@ -1471,12 +1481,12 @@ var SyncParser = class {
     return {
       t: 11 /* Error */,
       i: id,
-      a: void 0,
       s: void 0,
       l: void 0,
-      m: current.message,
       c: getErrorConstructor(current),
+      m: current.message,
       d: optionsNode,
+      a: void 0,
       n: void 0
     };
   }
@@ -1506,7 +1516,7 @@ var SyncParser = class {
           return NULL_NODE;
         }
         const id = createRef(this.ctx, current, true);
-        if (this.ctx.markedRefs[id]) {
+        if (this.ctx.markedRefs.has(id)) {
           return createReferenceNode(id);
         }
         if (Array.isArray(current)) {
@@ -1605,14 +1615,14 @@ function serialize(source, options) {
   const ctx = createParserContext(options);
   const [tree, rootID, isObject] = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
-  const result = serializeTree(serial, tree);
+  const result = new SerovalSerializer(serial).serialize(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 = serializeTree(serial, tree);
+  const result = new SerovalSerializer(serial).serialize(tree);
   return finalize(serial, rootID, isObject, result);
 }
 function deserialize(source) {
@@ -1621,33 +1631,33 @@ function deserialize(source) {
 function toJSON(source, 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 = 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 = createSerializationContext({
-    features: parsed[3],
-    markedRefs: parsed[4]
+    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));