seroval 0.4.0-alpha.4 → 0.4.0-alpha.6

package/dist/esm/development/index.mjs

@@ -230,48 +230,6 @@ function parseTargets(targets) {
   return flags;
 }
 
-// src/quote.ts
-function quote(str) {
-  let result = "";
-  let lastPos = 0;
-  for (let i = 0, len = str.length; i < len; i++) {
-    let replacement;
-    switch (str[i]) {
-      case '"':
-        replacement = '\\"';
-        break;
-      case "\\":
-        replacement = "\\\\";
-        break;
-      case "<":
-        replacement = "\\x3C";
-        break;
-      case "\n":
-        replacement = "\\n";
-        break;
-      case "\r":
-        replacement = "\\r";
-        break;
-      case "\u2028":
-        replacement = "\\u2028";
-        break;
-      case "\u2029":
-        replacement = "\\u2029";
-        break;
-      default:
-        continue;
-    }
-    result += str.slice(lastPos, i) + replacement;
-    lastPos = i + 1;
-  }
-  if (lastPos === 0) {
-    result = str;
-  } else {
-    result += str.slice(lastPos);
-  }
-  return `"${result}"`;
-}
-
 // src/get-identifier.ts
 var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
 var REF_START_CHARS_LEN = REF_START_CHARS.length;
@@ -289,7 +247,7 @@ function getIdentifier(index) {
   return ref;
 }
 
-// src/tree.ts
+// src/context.ts
 var DEFAULT_OPTIONS = {
   target: "es2023"
 };
@@ -311,71 +269,6 @@ function createSerializationContext(options) {
     markedRefs: new Set(options.markedRefs)
   };
 }
-function getAssignmentExpression(assignment) {
-  switch (assignment.type) {
-    case "index":
-      return `${assignment.source}=${assignment.value}`;
-    case "map":
-      return `${assignment.source}.set(${assignment.key},${assignment.value})`;
-    case "set":
-      return `${assignment.source}.add(${assignment.value})`;
-    default:
-      return "";
-  }
-}
-function mergeAssignments(assignments) {
-  const newAssignments = [];
-  let current = assignments[0];
-  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) {
-        current = {
-          type: "index",
-          source: item.source,
-          value: getAssignmentExpression(current)
-        };
-      } else if (item.type === "map" && item.source === prev.source) {
-        current = {
-          type: "map",
-          source: getAssignmentExpression(current),
-          key: item.key,
-          value: item.value
-        };
-      } else if (item.type === "set" && item.source === prev.source) {
-        current = {
-          type: "set",
-          source: getAssignmentExpression(current),
-          value: item.value
-        };
-      } else {
-        newAssignments.push(current);
-        current = item;
-      }
-    } else {
-      newAssignments.push(current);
-      current = item;
-    }
-    prev = item;
-  }
-  newAssignments.push(current);
-  return newAssignments;
-}
-function resolveAssignments(assignments) {
-  if (assignments.length) {
-    let result = "";
-    const merged = mergeAssignments(assignments);
-    for (let i = 0, len = merged.length; i < len; i++) {
-      result += `${getAssignmentExpression(merged[i])},`;
-    }
-    return result;
-  }
-  return void 0;
-}
-function resolvePatches(ctx) {
-  return resolveAssignments(ctx.assignments);
-}
 function markRef(ctx, current) {
   ctx.markedRefs.add(current);
 }
@@ -397,12 +290,6 @@ function getRefParam(ctx, index) {
   ctx.vars[actualIndex] = result;
   return result;
 }
-function assignRef(ctx, index, value) {
-  if (ctx.markedRefs.has(index)) {
-    return `${getRefParam(ctx, index)}=${value}`;
-  }
-  return value;
-}
 function createRef(ctx, index) {
   const current = ctx.refs.get(index);
   if (current != null) {
@@ -412,39 +299,50 @@ function createRef(ctx, index) {
   ctx.refs.set(index, id);
   return id;
 }
-function createAssignment(ctx, source, value) {
-  ctx.assignments.push({
-    type: "index",
-    source,
-    value
-  });
-}
-function createSetAdd(ctx, ref, value) {
-  markRef(ctx, ref);
-  ctx.assignments.push({
-    type: "set",
-    source: getRefParam(ctx, ref),
-    value
-  });
-}
-function createMapSet(ctx, ref, key, value) {
-  markRef(ctx, ref);
-  ctx.assignments.push({
-    type: "map",
-    source: getRefParam(ctx, ref),
-    key,
-    value
-  });
-}
-function createArrayAssign(ctx, ref, index, value) {
-  markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
-}
-function createObjectAssign(ctx, ref, key, value, computed) {
-  markRef(ctx, ref);
-  const member = computed ? `[${key}]` : `.${key}`;
-  createAssignment(ctx, `${getRefParam(ctx, ref)}${member}`, value);
+
+// src/quote.ts
+function quote(str) {
+  let result = "";
+  let lastPos = 0;
+  for (let i = 0, len = str.length; i < len; i++) {
+    let replacement;
+    switch (str[i]) {
+      case '"':
+        replacement = '\\"';
+        break;
+      case "\\":
+        replacement = "\\\\";
+        break;
+      case "<":
+        replacement = "\\x3C";
+        break;
+      case "\n":
+        replacement = "\\n";
+        break;
+      case "\r":
+        replacement = "\\r";
+        break;
+      case "\u2028":
+        replacement = "\\u2028";
+        break;
+      case "\u2029":
+        replacement = "\\u2029";
+        break;
+      default:
+        continue;
+    }
+    result += str.slice(lastPos, i) + replacement;
+    lastPos = i + 1;
+  }
+  if (lastPos === 0) {
+    result = str;
+  } else {
+    result += str.slice(lastPos);
+  }
+  return `"${result}"`;
 }
+
+// src/tree/shared.ts
 function getErrorConstructor(error) {
   if (error instanceof EvalError) {
     return "EvalError";
@@ -519,46 +417,16 @@ function generateSemiPrimitiveValue(ctx, current, id) {
   if (constructorCheck(current, RegExp)) {
     return [4 /* RegExp */, String(current), id];
   }
-  if (constructorCheck(current, Int8Array)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Int8Array"');
-    return [14 /* TypedArray */, ["Int8Array", current.toString(), current.byteOffset], id];
-  }
-  if (constructorCheck(current, Int16Array)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Int16Array"');
-    return [14 /* TypedArray */, ["Int16Array", current.toString(), current.byteOffset], id];
-  }
-  if (constructorCheck(current, Int32Array)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Int32Array"');
-    return [14 /* TypedArray */, ["Int32Array", current.toString(), current.byteOffset], id];
-  }
-  if (constructorCheck(current, Uint8Array)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Uint8Array"');
-    return [14 /* TypedArray */, ["Uint8Array", current.toString(), current.byteOffset], id];
-  }
-  if (constructorCheck(current, Uint16Array)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Uint16Array"');
-    return [14 /* TypedArray */, ["Uint16Array", current.toString(), current.byteOffset], id];
-  }
-  if (constructorCheck(current, Uint32Array)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Uint32Array"');
-    return [14 /* TypedArray */, ["Uint32Array", current.toString(), current.byteOffset], id];
+  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];
   }
-  if (constructorCheck(current, Uint8ClampedArray)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Uint8ClampedArray"');
-    return [14 /* TypedArray */, ["Uint8ClampedArray", current.toString(), current.byteOffset], id];
-  }
-  if (constructorCheck(current, Float32Array)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Float32Array"');
-    return [14 /* TypedArray */, ["Float32Array", current.toString(), current.byteOffset], id];
-  }
-  if (constructorCheck(current, Float64Array)) {
-    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Float64Array"');
-    return [14 /* TypedArray */, ["Float64Array", current.toString(), current.byteOffset], id];
-  }
-  if (constructorCheck(current, BigInt64Array)) {
+  if (constructorCheck(current, BigInt64Array) || constructorCheck(current, BigUint64Array)) {
+    const constructor = current.constructor.name;
     assert(
       ctx.features & 2048 /* BigIntTypedArray */,
-      'Unsupported value type "BigInt64Array"'
+      `Unsupported value type "${constructor}"`
     );
     let result = "";
     const cap = current.length - 1;
@@ -568,195 +436,152 @@ function generateSemiPrimitiveValue(ctx, current, id) {
     result += `"${current[cap]}"`;
     return [
       15 /* BigIntTypedArray */,
-      ["BigInt64Array", result, current.byteOffset],
-      id
-    ];
-  }
-  if (constructorCheck(current, BigUint64Array)) {
-    assert(
-      ctx.features & 2048 /* BigIntTypedArray */,
-      'Unsupported value type "BigUint64Array"'
-    );
-    let result = "";
-    const cap = current.length - 1;
-    for (let i = 0; i < cap; i++) {
-      result += `"${current[i]}n",`;
-    }
-    result += `"${current[cap]}"`;
-    return [
-      15 /* BigIntTypedArray */,
-      ["BigInt64Array", result, current.byteOffset],
+      [constructor, result, current.byteOffset],
       id
     ];
   }
   return void 0;
 }
-function serializePropertiesSync(ctx, properties) {
+function serializePrimitive(value) {
+  if (value === true) {
+    return "!0";
+  }
+  if (value === false) {
+    return "!1";
+  }
+  if (value === void 0) {
+    return "void 0";
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return quote(value);
+  }
+  if (Object.is(value, -0)) {
+    return "-0";
+  }
+  if (Object.is(value, Infinity)) {
+    return "1/0";
+  }
+  if (Object.is(value, -Infinity)) {
+    return "-1/0";
+  }
+  return value;
+}
+
+// src/tree/async.ts
+async function generateDictionary(ctx, properties) {
   const keys = Object.keys(properties);
-  const size = keys.length;
-  const keyNodes = new Array(size);
-  const valueNodes = new Array(size);
-  const deferredKeys = new Array(size);
-  const deferredValues = new Array(size);
-  let deferredSize = 0;
-  let nodesSize = 0;
+  const nodes = {};
+  const deferred = {};
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key];
-      deferredSize++;
+      deferred[key] = properties[key];
+    } else {
+      nodes[key] = await generateTreeAsync(ctx, properties[key]);
+    }
+  }
+  for (const key of Object.keys(deferred)) {
+    nodes[key] = await generateTreeAsync(ctx, deferred[key]);
+  }
+  return nodes;
+}
+async function generateSetNode(ctx, current, id) {
+  assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+  const len = current.size;
+  const nodes = new Array(len);
+  const deferred = new Array(len);
+  let deferredSize = 0;
+  let nodeSize = 0;
+  for (const item of current.keys()) {
+    if (isIterable(item)) {
+      deferred[deferredSize++] = item;
     } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key]);
-      nodesSize++;
+      nodes[nodeSize++] = await generateTreeAsync(ctx, item);
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodesSize + i] = deferredKeys[i];
-    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
+    nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
   }
-  return [keyNodes, valueNodes, size];
+  return [5 /* Set */, nodes, id];
 }
-function generateTreeSync(ctx, current) {
-  if (isPrimitive(current)) {
-    return [0 /* Primitive */, serializePrimitive(current)];
+async function generateMapNode(ctx, current, id) {
+  assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+  const len = current.size;
+  const keyNodes = new Array(len);
+  const valueNodes = new Array(len);
+  const deferredKey = new Array(len);
+  const deferredValue = new Array(len);
+  let deferredSize = 0;
+  let nodeSize = 0;
+  for (const [key, value] of current.entries()) {
+    if (isIterable(key) || isIterable(value)) {
+      deferredKey[deferredSize] = key;
+      deferredValue[deferredSize] = value;
+      deferredSize++;
+    } else {
+      keyNodes[nodeSize] = await generateTreeAsync(ctx, key);
+      valueNodes[nodeSize] = await generateTreeAsync(ctx, value);
+      nodeSize++;
+    }
   }
-  const id = generateRef(ctx, current);
-  if (Array.isArray(id)) {
-    return id;
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
   }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
-  }
-  if (constructorCheck(current, Set)) {
-    assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
-    const len = current.size;
-    const nodes = new Array(len);
-    const deferred = new Array(len);
-    let deferredSize = 0;
-    let nodeSize = 0;
-    for (const item of current.keys()) {
-      if (isIterable(item)) {
-        deferred[deferredSize++] = item;
+  return [6 /* Map */, [keyNodes, valueNodes, len], id];
+}
+async function generateNodeList(ctx, current) {
+  const size = current.length;
+  const nodes = new Array(size);
+  const deferred = new Array(size);
+  for (let i = 0; i < size; i++) {
+    if (i in current) {
+      if (isIterable(current[i])) {
+        deferred[i] = current[i];
       } else {
-        nodes[nodeSize++] = generateTreeSync(ctx, item);
+        nodes[i] = await generateTreeAsync(ctx, current[i]);
       }
     }
-    for (let i = 0; i < deferredSize; i++) {
-      nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
-    }
-    return [5 /* Set */, nodes, id];
   }
-  if (constructorCheck(current, Map)) {
-    assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
-    const len = current.size;
-    const keyNodes = new Array(len);
-    const valueNodes = new Array(len);
-    const deferredKey = new Array(len);
-    const deferredValue = new Array(len);
-    let deferredSize = 0;
-    let nodeSize = 0;
-    for (const [key, value] of current.entries()) {
-      if (isIterable(key) || isIterable(value)) {
-        deferredKey[deferredSize] = key;
-        deferredValue[deferredSize] = value;
-        deferredSize++;
-      } else {
-        keyNodes[nodeSize] = generateTreeSync(ctx, key);
-        valueNodes[nodeSize] = generateTreeSync(ctx, value);
-        nodeSize++;
-      }
-    }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
-      valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
-    }
-    return [6 /* Map */, [keyNodes, valueNodes, len], id];
-  }
-  if (Array.isArray(current)) {
-    const size = current.length;
-    const nodes = new Array(size);
-    const deferred = new Array(size);
-    for (let i = 0; i < size; i++) {
-      if (i in current) {
-        if (isIterable(current[i])) {
-          deferred[i] = current[i];
-        } else {
-          nodes[i] = generateTreeSync(ctx, current[i]);
-        }
-      }
-    }
-    for (let i = 0; i < size; i++) {
-      if (i in deferred) {
-        nodes[i] = generateTreeSync(ctx, deferred[i]);
-      }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = await generateTreeAsync(ctx, deferred[i]);
     }
-    return [7 /* Array */, nodes, id];
   }
-  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-    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];
-  }
-  if (current instanceof Error) {
-    const options = getErrorOptions(current);
-    const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
-    return [
-      11 /* Error */,
-      [getErrorConstructor(current), current.message, optionsNode],
-      id
-    ];
-  }
-  if (isIterable(current)) {
-    assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
-    const options = getIterableOptions(current);
-    return [13 /* Iterable */, [
-      // Parse options first before the items
-      options ? serializePropertiesSync(ctx, options) : void 0,
-      generateTreeSync(ctx, Array.from(current))
-    ], id];
-  }
-  const empty = current.constructor == null;
-  if (current.constructor === Object || empty) {
-    return [
-      empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      serializePropertiesSync(ctx, current),
-      id
-    ];
-  }
-  throw new Error("Unsupported value");
+  return nodes;
 }
-function parseSync(ctx, current) {
-  const result = generateTreeSync(ctx, current);
-  return [result, createRef(ctx, current), result[0] === 8 /* Object */];
+async function generateArrayNode(ctx, current, id) {
+  return [7 /* Array */, await generateNodeList(ctx, current), id];
 }
-async function serializePropertiesAsync(ctx, properties) {
-  const keys = Object.keys(properties);
-  const size = keys.length;
-  const keyNodes = new Array(size);
-  const valueNodes = new Array(size);
-  const deferredKeys = new Array(size);
-  const deferredValues = new Array(size);
-  let deferredSize = 0;
-  let nodesSize = 0;
-  for (const key of keys) {
-    if (isIterable(properties[key])) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key];
-      deferredSize++;
-    } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key]);
-      nodesSize++;
-    }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodesSize + i] = deferredKeys[i];
-    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
-  }
-  return [keyNodes, valueNodes, size];
+async function generateAggregateErrorNode(ctx, current, id) {
+  const options = getErrorOptions(current);
+  const optionsNode = options ? await generateDictionary(ctx, options) : void 0;
+  const errorsNode = await generateTreeAsync(ctx, current.errors);
+  return [
+    12 /* AggregateError */,
+    [current.message, optionsNode, errorsNode],
+    id
+  ];
+}
+async function generateErrorNode(ctx, current, id) {
+  const options = getErrorOptions(current);
+  const optionsNode = options ? await generateDictionary(ctx, options) : void 0;
+  return [
+    11 /* Error */,
+    [getErrorConstructor(current), current.message, optionsNode],
+    id
+  ];
+}
+async function generateIterableNode(ctx, current, id) {
+  assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  const options = getIterableOptions(current);
+  return [13 /* Iterable */, [
+    // Parse options first before the items
+    options ? await generateDictionary(ctx, options) : void 0,
+    await generateNodeList(ctx, Array.from(current))
+  ], id];
 }
 async function generateTreeAsync(ctx, current) {
   if (isPrimitive(current)) {
@@ -779,99 +604,28 @@ async function generateTreeAsync(ctx, current) {
     ]);
   }
   if (constructorCheck(current, Set)) {
-    assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
-    const len = current.size;
-    const nodes = new Array(len);
-    const deferred = new Array(len);
-    let deferredSize = 0;
-    let nodeSize = 0;
-    for (const item of current.keys()) {
-      if (isIterable(item)) {
-        deferred[deferredSize++] = item;
-      } else {
-        nodes[nodeSize++] = await generateTreeAsync(ctx, item);
-      }
-    }
-    for (let i = 0; i < deferredSize; i++) {
-      nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
-    }
-    return [5 /* Set */, nodes, id];
+    return generateSetNode(ctx, current, id);
   }
   if (constructorCheck(current, Map)) {
-    assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
-    const len = current.size;
-    const keyNodes = new Array(len);
-    const valueNodes = new Array(len);
-    const deferredKey = new Array(len);
-    const deferredValue = new Array(len);
-    let deferredSize = 0;
-    let nodeSize = 0;
-    for (const [key, value] of current.entries()) {
-      if (isIterable(key) || isIterable(value)) {
-        deferredKey[deferredSize] = key;
-        deferredValue[deferredSize] = value;
-        deferredSize++;
-      } else {
-        keyNodes[nodeSize] = await generateTreeAsync(ctx, key);
-        valueNodes[nodeSize] = await generateTreeAsync(ctx, value);
-        nodeSize++;
-      }
-    }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
-      valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
-    }
-    return [6 /* Map */, [keyNodes, valueNodes, len], id];
+    return generateMapNode(ctx, current, id);
   }
   if (Array.isArray(current)) {
-    const size = current.length;
-    const nodes = new Array(size);
-    const deferred = new Array(size);
-    for (let i = 0; i < size; i++) {
-      const item = current[i];
-      if (i in current) {
-        if (isIterable(item)) {
-          deferred[i] = item;
-        } else {
-          nodes[i] = await generateTreeAsync(ctx, item);
-        }
-      }
-    }
-    for (let i = 0; i < size; i++) {
-      if (i in deferred) {
-        nodes[i] = await generateTreeAsync(ctx, deferred[i]);
-      }
-    }
-    return [7 /* Array */, nodes, id];
+    return generateArrayNode(ctx, current, id);
   }
   if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-    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 generateAggregateErrorNode(ctx, current, id);
   }
   if (current instanceof Error) {
-    const options = getErrorOptions(current);
-    const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
-    return [
-      11 /* Error */,
-      [getErrorConstructor(current), current.message, optionsNode],
-      id
-    ];
+    return generateErrorNode(ctx, current, id);
   }
   if (isIterable(current)) {
-    assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
-    const options = getIterableOptions(current);
-    return [13 /* Iterable */, [
-      options ? await serializePropertiesAsync(ctx, options) : void 0,
-      await generateTreeAsync(ctx, Array.from(current))
-    ], id];
+    return generateIterableNode(ctx, current, id);
   }
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
     return [
       empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      await serializePropertiesAsync(ctx, current),
+      await generateDictionary(ctx, current),
       id
     ];
   }
@@ -881,43 +635,121 @@ async function parseAsync(ctx, current) {
   const result = await generateTreeAsync(ctx, current);
   return [result, createRef(ctx, current), result[0] === 8 /* Object */];
 }
-function serializePrimitive(value) {
-  if (value === true) {
-    return "!0";
-  }
-  if (value === false) {
-    return "!1";
-  }
-  if (value === void 0) {
-    return "void 0";
-  }
-  if (value === null) {
-    return null;
-  }
-  if (typeof value === "string") {
-    return quote(value);
+
+// src/tree/serialize.ts
+function getAssignmentExpression(assignment) {
+  switch (assignment.type) {
+    case "index":
+      return `${assignment.source}=${assignment.value}`;
+    case "map":
+      return `${assignment.source}.set(${assignment.key},${assignment.value})`;
+    case "set":
+      return `${assignment.source}.add(${assignment.value})`;
+    default:
+      return "";
   }
-  if (Object.is(value, -0)) {
-    return "-0";
+}
+function mergeAssignments(assignments) {
+  const newAssignments = [];
+  let current = assignments[0];
+  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) {
+        current = {
+          type: "index",
+          source: item.source,
+          value: getAssignmentExpression(current)
+        };
+      } else if (item.type === "map" && item.source === prev.source) {
+        current = {
+          type: "map",
+          source: getAssignmentExpression(current),
+          key: item.key,
+          value: item.value
+        };
+      } else if (item.type === "set" && item.source === prev.source) {
+        current = {
+          type: "set",
+          source: getAssignmentExpression(current),
+          value: item.value
+        };
+      } else {
+        newAssignments.push(current);
+        current = item;
+      }
+    } else {
+      newAssignments.push(current);
+      current = item;
+    }
+    prev = item;
   }
-  if (Object.is(value, Infinity)) {
-    return "1/0";
+  newAssignments.push(current);
+  return newAssignments;
+}
+function resolveAssignments(assignments) {
+  if (assignments.length) {
+    let result = "";
+    const merged = mergeAssignments(assignments);
+    for (let i = 0, len = merged.length; i < len; i++) {
+      result += `${getAssignmentExpression(merged[i])},`;
+    }
+    return result;
   }
-  if (Object.is(value, -Infinity)) {
-    return "-1/0";
+  return void 0;
+}
+function resolvePatches(ctx) {
+  return resolveAssignments(ctx.assignments);
+}
+function assignRef(ctx, index, value) {
+  if (ctx.markedRefs.has(index)) {
+    return `${getRefParam(ctx, index)}=${value}`;
   }
   return value;
 }
+function createAssignment(ctx, source, value) {
+  ctx.assignments.push({
+    type: "index",
+    source,
+    value
+  });
+}
+function createSetAdd(ctx, ref, value) {
+  markRef(ctx, ref);
+  ctx.assignments.push({
+    type: "set",
+    source: getRefParam(ctx, ref),
+    value
+  });
+}
+function createMapSet(ctx, ref, key, value) {
+  markRef(ctx, ref);
+  ctx.assignments.push({
+    type: "map",
+    source: getRefParam(ctx, ref),
+    key,
+    value
+  });
+}
+function createArrayAssign(ctx, ref, index, value) {
+  markRef(ctx, ref);
+  createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
+}
+function createObjectAssign(ctx, ref, key, value, computed) {
+  markRef(ctx, ref);
+  const member = computed ? `[${key}]` : `.${key}`;
+  createAssignment(ctx, `${getRefParam(ctx, ref)}${member}`, value);
+}
 var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
-function serializeAssignments(ctx, targetRef, [keys, values, size]) {
+function serializeAssignments(ctx, targetRef, record) {
   ctx.stack.push(targetRef);
   const mainAssignments = [];
-  for (let i = 0; i < size; i++) {
+  for (const key of Object.keys(record)) {
     const parentStack = ctx.stack;
     ctx.stack = [];
-    const refParam = serializeTree(ctx, values[i]);
+    const refParam = serializeTree(ctx, record[key]);
     ctx.stack = parentStack;
-    const key = keys[i];
     const check = Number(key);
     const parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
@@ -934,12 +766,11 @@ function serializeAssignments(ctx, targetRef, [keys, values, size]) {
   ctx.stack.pop();
   return resolveAssignments(mainAssignments);
 }
-function serializeObject(ctx, sourceID, [keys, values, size]) {
+function serializeDictionary(ctx, sourceID, record) {
   let result = "";
   ctx.stack.push(sourceID);
-  for (let i = 0; i < size; i++) {
-    const key = keys[i];
-    const val = values[i];
+  for (const key of Object.keys(record)) {
+    const val = record[key];
     const check = Number(key);
     const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
     const validKey = isIdentifier ? key : quote(key);
@@ -959,212 +790,388 @@ function serializeObject(ctx, sourceID, [keys, values, size]) {
   ctx.stack.pop();
   return `{${result.substring(0, result.length - 1)}}`;
 }
-function serializeTree(ctx, [type, value, id]) {
-  switch (type) {
-    case 0 /* Primitive */:
-      return String(value);
-    case 2 /* Reference */:
-      return getRefParam(ctx, value);
-    case 10 /* Promise */: {
-      let serialized;
-      if (isReferenceInStack(ctx, value)) {
-        serialized = `Promise.resolve().then(()=>${getRefParam(ctx, value[1])})`;
+function serializePromise(ctx, value, id) {
+  let serialized;
+  if (isReferenceInStack(ctx, value)) {
+    serialized = `Promise.resolve().then(()=>${getRefParam(ctx, value[1])})`;
+  } else {
+    ctx.stack.push(id);
+    const result = serializeTree(ctx, value);
+    ctx.stack.pop();
+    serialized = `Promise.resolve(${result})`;
+  }
+  return assignRef(ctx, id, serialized);
+}
+function serializeTypedArray(ctx, constructor, init, byteOffset, id) {
+  let args = `[${init}]`;
+  if (byteOffset !== 0) {
+    args += `,${byteOffset}`;
+  }
+  return assignRef(ctx, id, `new ${constructor}(${args})`);
+}
+function serializeSet(ctx, value, id) {
+  let serialized = "new Set";
+  const size = value.length;
+  if (size) {
+    let result = "";
+    ctx.stack.push(id);
+    for (let i = 0; i < size; i++) {
+      const item = value[i];
+      if (isReferenceInStack(ctx, item)) {
+        createSetAdd(ctx, id, getRefParam(ctx, item[1]));
       } else {
-        ctx.stack.push(id);
-        const result = serializeTree(ctx, value);
-        ctx.stack.pop();
-        serialized = `Promise.resolve(${result})`;
+        result += `${serializeTree(ctx, item)},`;
       }
-      return assignRef(ctx, id, serialized);
     }
-    case 1 /* BigInt */:
-      return value;
-    case 3 /* Date */:
-      return assignRef(ctx, id, `new Date("${value}")`);
-    case 4 /* RegExp */:
-      return assignRef(ctx, id, value);
-    case 15 /* BigIntTypedArray */:
-    case 14 /* TypedArray */: {
-      let args = `[${value[1]}]`;
-      if (value[2] !== 0) {
-        args += `,${value[2]}`;
-      }
-      return assignRef(ctx, id, `new ${value[0]}(${args})`);
+    ctx.stack.pop();
+    if (result) {
+      serialized += `([${result.substring(0, result.length - 1)}])`;
     }
-    case 5 /* Set */: {
-      let serialized = "new Set";
-      const size = value.length;
-      if (size) {
-        let result = "";
-        ctx.stack.push(id);
-        for (let i = 0; i < size; i++) {
-          const item = value[i];
-          if (isReferenceInStack(ctx, item)) {
-            createSetAdd(ctx, id, getRefParam(ctx, item[1]));
-          } else {
-            result += `${serializeTree(ctx, item)},`;
-          }
-        }
-        ctx.stack.pop();
-        if (result) {
-          serialized += `([${result.substring(0, result.length - 1)}])`;
+  }
+  return assignRef(ctx, id, serialized);
+}
+function serializeMap(ctx, keys, values, size, id) {
+  let serialized = "new Map";
+  if (size) {
+    let result = "";
+    ctx.stack.push(id);
+    for (let i = 0; i < size; i++) {
+      const key = keys[i];
+      const val = values[i];
+      if (isReferenceInStack(ctx, key)) {
+        const keyRef = getRefParam(ctx, key[1]);
+        if (isReferenceInStack(ctx, val)) {
+          const valueRef = getRefParam(ctx, val[1]);
+          createMapSet(ctx, id, keyRef, valueRef);
+        } else {
+          const parent = ctx.stack;
+          ctx.stack = [];
+          createMapSet(ctx, id, keyRef, serializeTree(ctx, val));
+          ctx.stack = parent;
         }
+      } else if (isReferenceInStack(ctx, val)) {
+        const valueRef = getRefParam(ctx, val[1]);
+        const parent = ctx.stack;
+        ctx.stack = [];
+        createMapSet(ctx, id, serializeTree(ctx, key), valueRef);
+        ctx.stack = parent;
+      } else {
+        result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
       }
-      return assignRef(ctx, id, serialized);
     }
-    case 6 /* Map */: {
-      let serialized = "new Map";
-      const size = value[2];
-      if (size) {
-        let result = "";
-        ctx.stack.push(id);
-        for (let i = 0; i < size; i++) {
-          const key = value[0][i];
-          const val = value[1][i];
-          if (isReferenceInStack(ctx, key)) {
-            const keyRef = getRefParam(ctx, key[1]);
-            if (isReferenceInStack(ctx, val)) {
-              const valueRef = getRefParam(ctx, val[1]);
-              createMapSet(ctx, id, keyRef, valueRef);
-            } else {
-              const parent = ctx.stack;
-              ctx.stack = [];
-              createMapSet(ctx, id, keyRef, serializeTree(ctx, val));
-              ctx.stack = parent;
-            }
-          } else if (isReferenceInStack(ctx, val)) {
-            const valueRef = getRefParam(ctx, val[1]);
-            const parent = ctx.stack;
-            ctx.stack = [];
-            createMapSet(ctx, id, serializeTree(ctx, key), valueRef);
-            ctx.stack = parent;
-          } else {
-            result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
-          }
-        }
-        ctx.stack.pop();
-        if (result) {
-          serialized += `([${result.substring(0, result.length - 1)}])`;
-        }
-      }
-      return assignRef(ctx, id, serialized);
+    ctx.stack.pop();
+    if (result) {
+      serialized += `([${result.substring(0, result.length - 1)}])`;
     }
-    case 7 /* Array */: {
-      const size = value.length;
-      let values = "";
-      ctx.stack.push(id);
-      for (let i = 0; i < size; i++) {
-        const item = value[i];
-        if (item) {
-          if (isReferenceInStack(ctx, item)) {
-            createArrayAssign(ctx, id, i, getRefParam(ctx, item[1]));
-            values += ",";
-          } else {
-            values += serializeTree(ctx, item);
-            if (i < size - 1) {
-              values += ",";
-            }
-          }
-        } else {
+  }
+  return assignRef(ctx, id, serialized);
+}
+function serializeNodeList(ctx, value, id) {
+  const size = value.length;
+  let values = "";
+  for (let i = 0; i < size; i++) {
+    const item = value[i];
+    if (item) {
+      if (isReferenceInStack(ctx, item)) {
+        createArrayAssign(ctx, id, i, getRefParam(ctx, item[1]));
+        values += ",";
+      } else {
+        values += serializeTree(ctx, item);
+        if (i < size - 1) {
           values += ",";
         }
       }
-      ctx.stack.pop();
-      return assignRef(ctx, id, `[${values}]`);
+    } else {
+      values += ",";
     }
-    case 12 /* AggregateError */: {
-      ctx.stack.push(id);
-      let serialized = `new AggregateError(${serializeTree(ctx, value[2])},${quote(value[0])})`;
-      ctx.stack.pop();
-      if (value[1]) {
-        if (ctx.features & 64 /* ObjectAssign */) {
-          const options = serializeObject(ctx, id, value[1]);
-          serialized = `Object.assign(${serialized},${options})`;
-        } else {
-          markRef(ctx, id);
-          const assignments = serializeAssignments(ctx, id, value[1]);
-          if (assignments) {
-            const ref = getRefParam(ctx, id);
-            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-          }
-        }
+  }
+  return `[${values}]`;
+}
+function serializeArray(ctx, value, id) {
+  ctx.stack.push(id);
+  const result = serializeNodeList(ctx, value, id);
+  ctx.stack.pop();
+  return assignRef(ctx, id, result);
+}
+function serializeWithObjectAssign(ctx, value, id, serialized) {
+  const fields = serializeDictionary(ctx, id, value);
+  if (fields !== "{}") {
+    return `Object.assign(${serialized},${fields})`;
+  }
+  return serialized;
+}
+function serializeAggregateError(ctx, message, options, errors, id) {
+  ctx.stack.push(id);
+  let serialized = `new AggregateError(${serializeTree(ctx, errors)},${quote(message)})`;
+  ctx.stack.pop();
+  if (options) {
+    if (ctx.features & 64 /* ObjectAssign */) {
+      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
+    } else {
+      markRef(ctx, id);
+      const assignments = serializeAssignments(ctx, id, options);
+      if (assignments) {
+        const ref = getRefParam(ctx, id);
+        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
       }
-      return assignRef(ctx, id, serialized);
     }
-    case 11 /* Error */: {
-      let serialized = `new ${value[0]}(${quote(value[1])})`;
-      if (value[2]) {
-        if (ctx.features & 64 /* ObjectAssign */) {
-          const options = serializeObject(ctx, id, value[2]);
-          serialized = `Object.assign(${serialized},${options})`;
-        } else {
-          markRef(ctx, id);
-          const assignments = serializeAssignments(ctx, id, value[2]);
-          if (assignments) {
-            const ref = getRefParam(ctx, id);
-            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-          }
-        }
+  }
+  return assignRef(ctx, id, serialized);
+}
+function serializeError(ctx, constructor, message, options, id) {
+  let serialized = `new ${constructor}(${quote(message)})`;
+  if (options) {
+    if (ctx.features & 64 /* ObjectAssign */) {
+      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
+    } else {
+      markRef(ctx, id);
+      const assignments = serializeAssignments(ctx, id, options);
+      if (assignments) {
+        const ref = getRefParam(ctx, id);
+        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
       }
-      return assignRef(ctx, id, serialized);
     }
-    case 13 /* Iterable */: {
-      const parent = ctx.stack;
-      ctx.stack = [];
-      const values = serializeTree(ctx, value[1]);
-      ctx.stack = parent;
-      let serialized;
-      if (ctx.features & 2 /* ArrayPrototypeValues */) {
-        serialized = `${values}.values()`;
-      } else {
-        serialized = `${values}[Symbol.iterator]()`;
-      }
-      if (ctx.features & 4 /* ArrowFunction */) {
-        serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-      } else if (ctx.features & 32 /* MethodShorthand */) {
-        serialized = `{[Symbol.iterator](){return ${serialized}}}`;
-      } else {
-        serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
-      }
-      if (value[0]) {
-        if (ctx.features & 64 /* ObjectAssign */) {
-          const options = serializeObject(ctx, id, value[0]);
-          serialized = `Object.assign(${serialized},${options})`;
-        } else {
-          markRef(ctx, id);
-          const assignments = serializeAssignments(ctx, id, value[0]);
-          if (assignments) {
-            const ref = getRefParam(ctx, id);
-            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-          }
-        }
+  }
+  return assignRef(ctx, id, serialized);
+}
+function serializeIterable(ctx, options, items, id) {
+  const parent = ctx.stack;
+  ctx.stack = [];
+  const values = serializeNodeList(ctx, items, id);
+  ctx.stack = parent;
+  let serialized;
+  if (ctx.features & 2 /* ArrayPrototypeValues */) {
+    serialized = `${values}.values()`;
+  } else {
+    serialized = `${values}[Symbol.iterator]()`;
+  }
+  if (ctx.features & 4 /* ArrowFunction */) {
+    serialized = `{[Symbol.iterator]:()=>${serialized}}`;
+  } else if (ctx.features & 32 /* MethodShorthand */) {
+    serialized = `{[Symbol.iterator](){return ${serialized}}}`;
+  } else {
+    serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
+  }
+  if (options) {
+    if (ctx.features & 64 /* ObjectAssign */) {
+      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
+    } else {
+      markRef(ctx, id);
+      const assignments = serializeAssignments(ctx, id, options);
+      if (assignments) {
+        const ref = getRefParam(ctx, id);
+        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
       }
-      return assignRef(ctx, id, serialized);
     }
-    case 9 /* NullConstructor */: {
-      let serialized = "Object.create(null)";
-      if (ctx.features & 64 /* ObjectAssign */) {
-        const fields = serializeObject(ctx, id, value);
-        if (fields !== "{}") {
-          serialized = `Object.assign(${serialized},${fields})`;
-        }
-      } else {
-        markRef(ctx, id);
-        const assignments = serializeAssignments(ctx, id, value);
-        if (assignments) {
-          const ref = getRefParam(ctx, id);
-          return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-        }
-      }
-      return assignRef(ctx, id, serialized);
+  }
+  return assignRef(ctx, id, serialized);
+}
+function serializeNullConstructor(ctx, value, id) {
+  let serialized = "Object.create(null)";
+  if (ctx.features & 64 /* ObjectAssign */) {
+    serialized = serializeWithObjectAssign(ctx, value, id, serialized);
+  } else {
+    markRef(ctx, id);
+    const assignments = serializeAssignments(ctx, id, value);
+    if (assignments) {
+      const ref = getRefParam(ctx, id);
+      return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
     }
+  }
+  return assignRef(ctx, id, serialized);
+}
+function serializeTree(ctx, [type, value, id]) {
+  switch (type) {
+    case 0 /* Primitive */:
+      return String(value);
+    case 2 /* Reference */:
+      return getRefParam(ctx, value);
+    case 10 /* Promise */:
+      return serializePromise(ctx, value, id);
+    case 1 /* BigInt */:
+      return value;
+    case 3 /* Date */:
+      return assignRef(ctx, id, `new Date("${value}")`);
+    case 4 /* RegExp */:
+      return assignRef(ctx, id, value);
+    case 15 /* BigIntTypedArray */:
+    case 14 /* TypedArray */:
+      return serializeTypedArray(ctx, value[0], value[1], value[2], id);
+    case 5 /* Set */:
+      return serializeSet(ctx, value, id);
+    case 6 /* Map */:
+      return serializeMap(ctx, value[0], value[1], value[2], id);
+    case 7 /* Array */:
+      return serializeArray(ctx, value, id);
+    case 12 /* AggregateError */:
+      return serializeAggregateError(ctx, value[0], value[1], value[2], id);
+    case 11 /* Error */:
+      return serializeError(ctx, value[0], value[1], value[2], id);
+    case 13 /* Iterable */:
+      return serializeIterable(ctx, value[0], value[1], id);
+    case 9 /* NullConstructor */:
+      return serializeNullConstructor(ctx, value, id);
     case 8 /* Object */:
-      return assignRef(ctx, id, serializeObject(ctx, id, value));
+      return assignRef(ctx, id, serializeDictionary(ctx, id, value));
     default:
       throw new Error("Unsupported type");
   }
 }
 
+// src/tree/sync.ts
+function generateDictionary2(ctx, properties) {
+  const keys = Object.keys(properties);
+  const nodes = {};
+  const deferred = {};
+  for (const key of keys) {
+    if (isIterable(properties[key])) {
+      deferred[key] = properties[key];
+    } else {
+      nodes[key] = generateTreeSync(ctx, properties[key]);
+    }
+  }
+  for (const key of Object.keys(deferred)) {
+    nodes[key] = generateTreeSync(ctx, deferred[key]);
+  }
+  return nodes;
+}
+function generateSetNode2(ctx, current, id) {
+  assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+  const len = current.size;
+  const nodes = new Array(len);
+  const deferred = new Array(len);
+  let deferredSize = 0;
+  let nodeSize = 0;
+  for (const item of current.keys()) {
+    if (isIterable(item)) {
+      deferred[deferredSize++] = item;
+    } else {
+      nodes[nodeSize++] = generateTreeSync(ctx, item);
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
+  }
+  return [5 /* Set */, nodes, id];
+}
+function generateMapNode2(ctx, current, id) {
+  assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+  const len = current.size;
+  const keyNodes = new Array(len);
+  const valueNodes = new Array(len);
+  const deferredKey = new Array(len);
+  const deferredValue = new Array(len);
+  let deferredSize = 0;
+  let nodeSize = 0;
+  for (const [key, value] of current.entries()) {
+    if (isIterable(key) || isIterable(value)) {
+      deferredKey[deferredSize] = key;
+      deferredValue[deferredSize] = value;
+      deferredSize++;
+    } else {
+      keyNodes[nodeSize] = generateTreeSync(ctx, key);
+      valueNodes[nodeSize] = generateTreeSync(ctx, value);
+      nodeSize++;
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
+  }
+  return [6 /* Map */, [keyNodes, valueNodes, len], id];
+}
+function generateNodeList2(ctx, current) {
+  const size = current.length;
+  const nodes = new Array(size);
+  const deferred = new Array(size);
+  for (let i = 0; i < size; i++) {
+    if (i in current) {
+      if (isIterable(current[i])) {
+        deferred[i] = current[i];
+      } else {
+        nodes[i] = generateTreeSync(ctx, current[i]);
+      }
+    }
+  }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = generateTreeSync(ctx, deferred[i]);
+    }
+  }
+  return nodes;
+}
+function generateArrayNode2(ctx, current, id) {
+  return [7 /* Array */, generateNodeList2(ctx, current), id];
+}
+function generateAggregateErrorNode2(ctx, current, id) {
+  const options = getErrorOptions(current);
+  const optionsNode = options ? generateDictionary2(ctx, options) : void 0;
+  const errorsNode = generateTreeSync(ctx, current.errors);
+  return [12 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
+}
+function generateErrorNode2(ctx, current, id) {
+  const options = getErrorOptions(current);
+  const optionsNode = options ? generateDictionary2(ctx, options) : void 0;
+  return [
+    11 /* Error */,
+    [getErrorConstructor(current), current.message, optionsNode],
+    id
+  ];
+}
+function generateIterableNode2(ctx, current, id) {
+  assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  const options = getIterableOptions(current);
+  return [13 /* Iterable */, [
+    // Parse options first before the items
+    options ? generateDictionary2(ctx, options) : void 0,
+    generateNodeList2(ctx, Array.from(current))
+  ], id];
+}
+function generateTreeSync(ctx, current) {
+  if (isPrimitive(current)) {
+    return [0 /* Primitive */, serializePrimitive(current)];
+  }
+  const id = generateRef(ctx, current);
+  if (Array.isArray(id)) {
+    return id;
+  }
+  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
+  if (semiPrimitive) {
+    return semiPrimitive;
+  }
+  if (constructorCheck(current, Set)) {
+    return generateSetNode2(ctx, current, id);
+  }
+  if (constructorCheck(current, Map)) {
+    return generateMapNode2(ctx, current, id);
+  }
+  if (Array.isArray(current)) {
+    return generateArrayNode2(ctx, current, id);
+  }
+  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+    return generateAggregateErrorNode2(ctx, current, id);
+  }
+  if (current instanceof Error) {
+    return generateErrorNode2(ctx, current, id);
+  }
+  if (isIterable(current)) {
+    return generateIterableNode2(ctx, current, id);
+  }
+  const empty = current.constructor == null;
+  if (current.constructor === Object || empty) {
+    return [
+      empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      generateDictionary2(ctx, current),
+      id
+    ];
+  }
+  throw new Error("Unsupported value");
+}
+function parseSync(ctx, current) {
+  const result = generateTreeSync(ctx, current);
+  return [result, createRef(ctx, current), result[0] === 8 /* Object */];
+}
+
 // src/index.ts
 function finalize(ctx, rootID, isObject, result) {
   if (ctx.vars.length) {