seroval 0.4.0-alpha.8 → 0.4.0-alpha.9

package/dist/cjs/development/index.cjs

@@ -427,14 +427,24 @@ function getIterableOptions(obj) {
   return void 0;
 }
 function isReferenceInStack(ctx, node) {
-  return node[0] === 2 /* Reference */ && ctx.stack.includes(node[1]);
+  return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
 }
 function generateRef(ctx, current) {
   const ref = ctx.refs.has(current);
   if (ref) {
     const refID = ctx.refs.get(current) || 0;
     markRef(ctx, refID);
-    return [2 /* Reference */, refID];
+    return {
+      t: 2 /* Reference */,
+      i: refID,
+      a: void 0,
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      d: void 0,
+      n: void 0
+    };
   }
   const id = ctx.refs.size;
   ctx.refs.set(current, id);
@@ -443,18 +453,58 @@ function generateRef(ctx, current) {
 function generateSemiPrimitiveValue(ctx, current, id) {
   if (typeof current === "bigint") {
     assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
-    return [1 /* BigInt */, `${current}n`];
+    return {
+      t: 1 /* BigInt */,
+      i: void 0,
+      a: void 0,
+      s: `${current}n`,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      d: void 0,
+      n: void 0
+    };
   }
   if (constructorCheck(current, Date)) {
-    return [3 /* Date */, current.toISOString(), id];
+    return {
+      t: 3 /* Date */,
+      i: id,
+      a: void 0,
+      s: current.toISOString(),
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      d: void 0,
+      n: void 0
+    };
   }
   if (constructorCheck(current, RegExp)) {
-    return [4 /* RegExp */, String(current), id];
+    return {
+      t: 4 /* RegExp */,
+      i: id,
+      a: void 0,
+      s: String(current),
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      d: void 0,
+      n: void 0
+    };
   }
   if (constructorCheck(current, Int8Array) || constructorCheck(current, Int16Array) || constructorCheck(current, Int32Array) || constructorCheck(current, Uint8Array) || constructorCheck(current, Uint16Array) || constructorCheck(current, Uint32Array) || constructorCheck(current, Uint8ClampedArray) || constructorCheck(current, Float32Array) || constructorCheck(current, Float64Array)) {
     const constructor = current.constructor.name;
     assert(ctx.features & 1024 /* TypedArray */, `Unsupported value type "${constructor}"`);
-    return [14 /* TypedArray */, [constructor, current.toString(), current.byteOffset], id];
+    return {
+      t: 14 /* TypedArray */,
+      i: id,
+      a: void 0,
+      s: current.toString(),
+      l: current.byteOffset,
+      m: void 0,
+      c: constructor,
+      d: void 0,
+      n: void 0
+    };
   }
   if (constructorCheck(current, BigInt64Array) || constructorCheck(current, BigUint64Array)) {
     const constructor = current.constructor.name;
@@ -468,11 +518,17 @@ function generateSemiPrimitiveValue(ctx, current, id) {
       result += `${current[i]}n,`;
     }
     result += `"${current[cap]}"`;
-    return [
-      15 /* BigIntTypedArray */,
-      [constructor, result, current.byteOffset],
-      id
-    ];
+    return {
+      t: 14 /* TypedArray */,
+      i: id,
+      a: void 0,
+      s: result,
+      l: current.byteOffset,
+      m: void 0,
+      c: constructor,
+      d: void 0,
+      n: void 0
+    };
   }
   return void 0;
 }
@@ -529,7 +585,11 @@ async function serializePropertiesAsync(ctx, properties) {
     keyNodes[nodesSize + i] = deferredKeys[i];
     valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, size];
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
 }
 async function generateSetNode(ctx, current, id) {
   assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
@@ -548,7 +608,17 @@ async function generateSetNode(ctx, current, id) {
   for (let i = 0; i < deferredSize; i++) {
     nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
   }
-  return [5 /* Set */, nodes, id];
+  return {
+    t: 5 /* Set */,
+    i: id,
+    a: nodes,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
 }
 async function generateMapNode(ctx, current, id) {
   assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
@@ -574,7 +644,17 @@ async function generateMapNode(ctx, current, id) {
     keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
     valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
   }
-  return [6 /* Map */, [keyNodes, valueNodes, len], id];
+  return {
+    t: 6 /* Map */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: { k: keyNodes, v: valueNodes, s: len },
+    n: void 0
+  };
 }
 async function generateNodeList(ctx, current) {
   const size = current.length;
@@ -597,42 +677,81 @@ async function generateNodeList(ctx, current) {
   return nodes;
 }
 async function generateArrayNode(ctx, current, id) {
-  return [7 /* Array */, await generateNodeList(ctx, current), id];
+  return {
+    t: 7 /* Array */,
+    i: id,
+    a: await generateNodeList(ctx, current),
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
 }
 async function generateAggregateErrorNode(ctx, current, id) {
   const options = getErrorOptions(current);
   const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
-  const errorsNode = await generateTreeAsync(ctx, current.errors);
-  return [
-    12 /* AggregateError */,
-    [current.message, optionsNode, errorsNode],
-    id
-  ];
+  return {
+    t: 12 /* AggregateError */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: current.message,
+    c: void 0,
+    d: optionsNode,
+    n: await generateTreeAsync(ctx, current.errors)
+  };
 }
 async function generateErrorNode(ctx, current, id) {
   const options = getErrorOptions(current);
   const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
-  return [
-    11 /* Error */,
-    [getErrorConstructor(current), current.message, optionsNode],
-    id
-  ];
+  return {
+    t: 11 /* Error */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: current.message,
+    c: getErrorConstructor(current),
+    d: optionsNode,
+    n: void 0
+  };
 }
 async function generateIterableNode(ctx, current, id) {
   assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
-  return [13 /* Iterable */, [
+  return {
+    t: 13 /* Iterable */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
     // Parse options first before the items
-    options ? await serializePropertiesAsync(ctx, options) : void 0,
-    await generateNodeList(ctx, Array.from(current))
-  ], id];
+    d: options ? await serializePropertiesAsync(ctx, options) : void 0,
+    a: await generateNodeList(ctx, Array.from(current)),
+    n: void 0
+  };
 }
 async function generateTreeAsync(ctx, current) {
   if (isPrimitive(current)) {
-    return [0 /* Primitive */, serializePrimitive(current)];
+    return {
+      t: 0 /* Primitive */,
+      i: void 0,
+      s: serializePrimitive(current),
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      // Parse options first before the items
+      d: void 0,
+      a: void 0,
+      n: void 0
+    };
   }
   const id = generateRef(ctx, current);
-  if (Array.isArray(id)) {
+  if (typeof id !== "number") {
     return id;
   }
   const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
@@ -641,11 +760,18 @@ async function generateTreeAsync(ctx, current) {
   }
   if (isPromise(current)) {
     assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
-    return current.then(async (value) => [
-      10 /* Promise */,
-      await generateTreeAsync(ctx, value),
-      id
-    ]);
+    return current.then(async (value) => ({
+      t: 10 /* Promise */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      // Parse options first before the items
+      d: void 0,
+      a: void 0,
+      n: await generateTreeAsync(ctx, value)
+    }));
   }
   if (constructorCheck(current, Set)) {
     return generateSetNode(ctx, current, id);
@@ -667,17 +793,24 @@ async function generateTreeAsync(ctx, current) {
   }
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
-    return [
-      empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      await serializePropertiesAsync(ctx, current),
-      id
-    ];
+    return {
+      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      // Parse options first before the items
+      d: await serializePropertiesAsync(ctx, current),
+      a: void 0,
+      n: void 0
+    };
   }
   throw new Error("Unsupported value");
 }
 async function parseAsync(ctx, current) {
   const result = await generateTreeAsync(ctx, current);
-  return [result, createRef(ctx, current), result[0] === 8 /* Object */];
+  return [result, createRef(ctx, current), result.t === 8 /* Object */];
 }
 
 // src/tree/serialize.ts
@@ -785,15 +918,15 @@ 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, [keys, values, size]) {
+function serializeAssignments(ctx, targetRef, node) {
   ctx.stack.push(targetRef);
   const mainAssignments = [];
-  for (let i = 0; i < size; i++) {
+  for (let i = 0; i < node.s; i++) {
     const parentStack = ctx.stack;
     ctx.stack = [];
-    const refParam = serializeTree(ctx, values[i]);
+    const refParam = serializeTree(ctx, node.v[i]);
     ctx.stack = parentStack;
-    const key = keys[i];
+    const key = node.k[i];
     const check = Number(key);
     const parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
@@ -808,19 +941,19 @@ function serializeAssignments(ctx, targetRef, [keys, values, size]) {
   ctx.stack.pop();
   return resolveAssignments(mainAssignments);
 }
-function serializeObject(ctx, sourceID, [keys, values, size]) {
-  if (size === 0) {
+function serializeObject(ctx, sourceID, node) {
+  if (node.s === 0) {
     return "{}";
   }
   let result = "";
   ctx.stack.push(sourceID);
-  for (let i = 0; i < size; i++) {
-    const key = keys[i];
-    const val = values[i];
+  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[1]);
+      const refParam = getRefParam(ctx, val.i);
       if (isIdentifier && Number.isNaN(check)) {
         createObjectAssign(ctx, sourceID, key, refParam);
       } else {
@@ -833,35 +966,35 @@ function serializeObject(ctx, sourceID, [keys, values, size]) {
   ctx.stack.pop();
   return `{${result.substring(0, result.length - 1)}}`;
 }
-function serializePromise(ctx, value, id) {
+function serializePromise(ctx, node) {
   let serialized;
-  if (isReferenceInStack(ctx, value)) {
-    serialized = `Promise.resolve().then(()=>${getRefParam(ctx, value[1])})`;
+  if (isReferenceInStack(ctx, node.n)) {
+    serialized = `Promise.resolve().then(()=>${getRefParam(ctx, node.n.i)})`;
   } else {
-    ctx.stack.push(id);
-    const result = serializeTree(ctx, value);
+    ctx.stack.push(node.i);
+    const result = serializeTree(ctx, node.n);
     ctx.stack.pop();
     serialized = `Promise.resolve(${result})`;
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeTypedArray(ctx, constructor, init, byteOffset, id) {
-  let args = `[${init}]`;
-  if (byteOffset !== 0) {
-    args += `,${byteOffset}`;
+function serializeTypedArray(ctx, node) {
+  let args = `[${node.s}]`;
+  if (node.l !== 0) {
+    args += `,${node.l}`;
   }
-  return assignRef(ctx, id, `new ${constructor}(${args})`);
+  return assignRef(ctx, node.i, `new ${node.c}(${args})`);
 }
-function serializeSet(ctx, value, id) {
+function serializeSet(ctx, node) {
   let serialized = "new Set";
-  const size = value.length;
+  const size = node.a.length;
   if (size) {
     let result = "";
-    ctx.stack.push(id);
+    ctx.stack.push(node.i);
     for (let i = 0; i < size; i++) {
-      const item = value[i];
+      const item = node.a[i];
       if (isReferenceInStack(ctx, item)) {
-        createSetAdd(ctx, id, getRefParam(ctx, item[1]));
+        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
       } else {
         result += `${serializeTree(ctx, item)},`;
       }
@@ -871,32 +1004,32 @@ function serializeSet(ctx, value, id) {
       serialized += `([${result.substring(0, result.length - 1)}])`;
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeMap(ctx, keys, values, size, id) {
+function serializeMap(ctx, node) {
   let serialized = "new Map";
-  if (size) {
+  if (node.d.s) {
     let result = "";
-    ctx.stack.push(id);
-    for (let i = 0; i < size; i++) {
-      const key = keys[i];
-      const val = values[i];
+    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[1]);
+        const keyRef = getRefParam(ctx, key.i);
         if (isReferenceInStack(ctx, val)) {
-          const valueRef = getRefParam(ctx, val[1]);
-          createMapSet(ctx, id, keyRef, valueRef);
+          const valueRef = getRefParam(ctx, val.i);
+          createMapSet(ctx, node.i, keyRef, valueRef);
         } else {
           const parent = ctx.stack;
           ctx.stack = [];
-          createMapSet(ctx, id, keyRef, serializeTree(ctx, val));
+          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
           ctx.stack = parent;
         }
       } else if (isReferenceInStack(ctx, val)) {
-        const valueRef = getRefParam(ctx, val[1]);
+        const valueRef = getRefParam(ctx, val.i);
         const parent = ctx.stack;
         ctx.stack = [];
-        createMapSet(ctx, id, serializeTree(ctx, key), valueRef);
+        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
         ctx.stack = parent;
       } else {
         result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
@@ -907,16 +1040,16 @@ function serializeMap(ctx, keys, values, size, id) {
       serialized += `([${result.substring(0, result.length - 1)}])`;
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeNodeList(ctx, value, id) {
-  const size = value.length;
+function serializeNodeList(ctx, node) {
+  const size = node.a.length;
   let values = "";
   for (let i = 0; i < size; i++) {
-    const item = value[i];
+    const item = node.a[i];
     if (item) {
       if (isReferenceInStack(ctx, item)) {
-        createArrayAssign(ctx, id, i, getRefParam(ctx, item[1]));
+        createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
         values += ",";
       } else {
         values += serializeTree(ctx, item);
@@ -930,11 +1063,11 @@ function serializeNodeList(ctx, value, id) {
   }
   return `[${values}]`;
 }
-function serializeArray(ctx, value, id) {
-  ctx.stack.push(id);
-  const result = serializeNodeList(ctx, value, id);
+function serializeArray(ctx, node) {
+  ctx.stack.push(node.i);
+  const result = serializeNodeList(ctx, node);
   ctx.stack.pop();
-  return assignRef(ctx, id, result);
+  return assignRef(ctx, node.i, result);
 }
 function serializeWithObjectAssign(ctx, value, id, serialized) {
   const fields = serializeObject(ctx, id, value);
@@ -943,44 +1076,44 @@ function serializeWithObjectAssign(ctx, value, id, serialized) {
   }
   return serialized;
 }
-function serializeAggregateError(ctx, message, options, errors, id) {
-  ctx.stack.push(id);
-  let serialized = `new AggregateError(${serializeTree(ctx, errors)},${quote(message)})`;
+function serializeAggregateError(ctx, node) {
+  ctx.stack.push(node.i);
+  let serialized = `new AggregateError(${serializeTree(ctx, node.n)},${quote(node.m)})`;
   ctx.stack.pop();
-  if (options) {
+  if (node.d) {
     if (ctx.features & 64 /* ObjectAssign */) {
-      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
+      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
     } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
+      markRef(ctx, node.i);
+      const assignments = serializeAssignments(ctx, node.i, node.d);
       if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+        const ref = getRefParam(ctx, node.i);
+        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
       }
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeError(ctx, constructor, message, options, id) {
-  let serialized = `new ${constructor}(${quote(message)})`;
-  if (options) {
+function serializeError(ctx, node) {
+  let serialized = `new ${node.c}(${quote(node.m)})`;
+  if (node.d) {
     if (ctx.features & 64 /* ObjectAssign */) {
-      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
+      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
     } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
+      markRef(ctx, node.i);
+      const assignments = serializeAssignments(ctx, node.i, node.d);
       if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+        const ref = getRefParam(ctx, node.i);
+        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
       }
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeIterable(ctx, options, items, id) {
+function serializeIterable(ctx, node) {
   const parent = ctx.stack;
   ctx.stack = [];
-  const values = serializeNodeList(ctx, items, id);
+  const values = serializeNodeList(ctx, node);
   ctx.stack = parent;
   let serialized;
   if (ctx.features & 2 /* ArrayPrototypeValues */) {
@@ -995,67 +1128,67 @@ function serializeIterable(ctx, options, items, id) {
   } else {
     serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
   }
-  if (options) {
+  if (node.d) {
     if (ctx.features & 64 /* ObjectAssign */) {
-      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
+      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
     } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
+      markRef(ctx, node.i);
+      const assignments = serializeAssignments(ctx, node.i, node.d);
       if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+        const ref = getRefParam(ctx, node.i);
+        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
       }
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeNullConstructor(ctx, value, id) {
+function serializeNullConstructor(ctx, node) {
   let serialized = "Object.create(null)";
   if (ctx.features & 64 /* ObjectAssign */) {
-    serialized = serializeWithObjectAssign(ctx, value, id, serialized);
+    serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
   } else {
-    markRef(ctx, id);
-    const assignments = serializeAssignments(ctx, id, value);
+    markRef(ctx, node.i);
+    const assignments = serializeAssignments(ctx, node.i, node.d);
     if (assignments) {
-      const ref = getRefParam(ctx, id);
-      return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+      const ref = getRefParam(ctx, node.i);
+      return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeTree(ctx, [type, value, id]) {
-  switch (type) {
+function serializeTree(ctx, node) {
+  switch (node.t) {
     case 0 /* Primitive */:
-      return String(value);
+      return String(node.s);
     case 2 /* Reference */:
-      return getRefParam(ctx, value);
+      return getRefParam(ctx, node.i);
     case 10 /* Promise */:
-      return serializePromise(ctx, value, id);
+      return serializePromise(ctx, node);
     case 1 /* BigInt */:
-      return value;
+      return node.s;
     case 3 /* Date */:
-      return assignRef(ctx, id, `new Date("${value}")`);
+      return assignRef(ctx, node.i, `new Date("${node.s}")`);
     case 4 /* RegExp */:
-      return assignRef(ctx, id, value);
+      return assignRef(ctx, node.i, node.s);
     case 15 /* BigIntTypedArray */:
     case 14 /* TypedArray */:
-      return serializeTypedArray(ctx, value[0], value[1], value[2], id);
+      return serializeTypedArray(ctx, node);
     case 5 /* Set */:
-      return serializeSet(ctx, value, id);
+      return serializeSet(ctx, node);
     case 6 /* Map */:
-      return serializeMap(ctx, value[0], value[1], value[2], id);
+      return serializeMap(ctx, node);
     case 7 /* Array */:
-      return serializeArray(ctx, value, id);
+      return serializeArray(ctx, node);
     case 12 /* AggregateError */:
-      return serializeAggregateError(ctx, value[0], value[1], value[2], id);
+      return serializeAggregateError(ctx, node);
     case 11 /* Error */:
-      return serializeError(ctx, value[0], value[1], value[2], id);
+      return serializeError(ctx, node);
     case 13 /* Iterable */:
-      return serializeIterable(ctx, value[0], value[1], id);
+      return serializeIterable(ctx, node);
     case 9 /* NullConstructor */:
-      return serializeNullConstructor(ctx, value, id);
+      return serializeNullConstructor(ctx, node);
     case 8 /* Object */:
-      return assignRef(ctx, id, serializeObject(ctx, id, value));
+      return assignRef(ctx, node.i, serializeObject(ctx, node.i, node.d));
     default:
       throw new Error("Unsupported type");
   }
@@ -1086,7 +1219,11 @@ function serializePropertiesSync(ctx, properties) {
     keyNodes[nodesSize + i] = deferredKeys[i];
     valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, size];
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
 }
 function generateSetNode2(ctx, current, id) {
   assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
@@ -1105,7 +1242,17 @@ function generateSetNode2(ctx, current, id) {
   for (let i = 0; i < deferredSize; i++) {
     nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
   }
-  return [5 /* Set */, nodes, id];
+  return {
+    t: 5 /* Set */,
+    i: id,
+    a: nodes,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
 }
 function generateMapNode2(ctx, current, id) {
   assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
@@ -1131,7 +1278,17 @@ function generateMapNode2(ctx, current, id) {
     keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
     valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
   }
-  return [6 /* Map */, [keyNodes, valueNodes, len], id];
+  return {
+    t: 6 /* Map */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: { k: keyNodes, v: valueNodes, s: len },
+    n: void 0
+  };
 }
 function generateNodeList2(ctx, current) {
   const size = current.length;
@@ -1154,38 +1311,81 @@ function generateNodeList2(ctx, current) {
   return nodes;
 }
 function generateArrayNode2(ctx, current, id) {
-  return [7 /* Array */, generateNodeList2(ctx, current), id];
+  return {
+    t: 7 /* Array */,
+    i: id,
+    a: generateNodeList2(ctx, current),
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
 }
 function generateAggregateErrorNode2(ctx, current, id) {
   const options = getErrorOptions(current);
   const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
-  const errorsNode = generateTreeSync(ctx, current.errors);
-  return [12 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
+  return {
+    t: 12 /* AggregateError */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: current.message,
+    c: void 0,
+    d: optionsNode,
+    n: generateTreeSync(ctx, current.errors)
+  };
 }
 function generateErrorNode2(ctx, current, id) {
   const options = getErrorOptions(current);
   const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
-  return [
-    11 /* Error */,
-    [getErrorConstructor(current), current.message, optionsNode],
-    id
-  ];
+  return {
+    t: 11 /* Error */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: current.message,
+    c: getErrorConstructor(current),
+    d: optionsNode,
+    n: void 0
+  };
 }
 function generateIterableNode2(ctx, current, id) {
   assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
-  return [13 /* Iterable */, [
+  return {
+    t: 13 /* Iterable */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
     // Parse options first before the items
-    options ? serializePropertiesSync(ctx, options) : void 0,
-    generateNodeList2(ctx, Array.from(current))
-  ], id];
+    d: options ? serializePropertiesSync(ctx, options) : void 0,
+    a: generateNodeList2(ctx, Array.from(current)),
+    n: void 0
+  };
 }
 function generateTreeSync(ctx, current) {
   if (isPrimitive(current)) {
-    return [0 /* Primitive */, serializePrimitive(current)];
+    return {
+      t: 0 /* Primitive */,
+      i: void 0,
+      s: serializePrimitive(current),
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      // Parse options first before the items
+      d: void 0,
+      a: void 0,
+      n: void 0
+    };
   }
   const id = generateRef(ctx, current);
-  if (Array.isArray(id)) {
+  if (typeof id !== "number") {
     return id;
   }
   const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
@@ -1212,17 +1412,24 @@ function generateTreeSync(ctx, current) {
   }
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
-    return [
-      empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      serializePropertiesSync(ctx, current),
-      id
-    ];
+    return {
+      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      // Parse options first before the items
+      d: serializePropertiesSync(ctx, current),
+      a: void 0,
+      n: void 0
+    };
   }
   throw new Error("Unsupported value");
 }
 function parseSync(ctx, current) {
   const result = generateTreeSync(ctx, current);
-  return [result, createRef(ctx, current), result[0] === 8 /* Object */];
+  return [result, createRef(ctx, current), result.t === 8 /* Object */];
 }
 
 // src/index.ts