seroval 0.6.0 → 0.8.0

package/dist/esm/development/index.mjs

@@ -16,7 +16,7 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
   Feature2[Feature2["WebAPI"] = 8192] = "WebAPI";
   return Feature2;
 })(Feature || {});
-var ALL_ENABLED = 12287;
+var ALL_ENABLED = 16383;
 
 // src/get-identifier.ts
 var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
@@ -40,7 +40,7 @@ var DEFAULT_OPTIONS = {
   disabledFeatures: 0
 };
 function createParserContext(options = {}) {
-  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+  const result = Object.assign({}, DEFAULT_OPTIONS, options);
   return {
     markedRefs: /* @__PURE__ */ new Set(),
     refs: /* @__PURE__ */ new Map(),
@@ -96,43 +96,47 @@ function createIndexedValue(ctx, current) {
 // src/assert.ts
 function assert(cond, error) {
   if (!cond) {
-    throw new Error(error);
+    throw error;
   }
 }
 
-// src/quote.ts
-function quote(str) {
+// src/string.ts
+function serializeChar(str) {
+  switch (str) {
+    case '"':
+      return '\\"';
+    case "\\":
+      return "\\\\";
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\b":
+      return "\\b";
+    case "	":
+      return "\\t";
+    case "\f":
+      return "\\f";
+    case "<":
+      return "\\x3C";
+    case "\u2028":
+      return "\\u2028";
+    case "\u2029":
+      return "\\u2029";
+    default:
+      return void 0;
+  }
+}
+function serializeString(str) {
   let result = "";
   let lastPos = 0;
+  let replacement;
   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;
+    replacement = serializeChar(str[i]);
+    if (replacement) {
+      result += str.slice(lastPos, i) + replacement;
+      lastPos = i + 1;
     }
-    result += str.slice(lastPos, i) + replacement;
-    lastPos = i + 1;
   }
   if (lastPos === 0) {
     result = str;
@@ -141,8 +145,84 @@ function quote(str) {
   }
   return result;
 }
-function invQuote(str) {
-  return str.replace(/\\"/g, '"').replace(/\\\\/g, "\\").replace(/\\x3C/g, "<").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\u2028/g, "\u2028").replace(/\\u2029/g, "\u2029");
+function deserializeString(str) {
+  return str.replace(/\\"/g, '"').replace(/\\\\/g, "\\").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\b/g, "\b").replace(/\\t/g, "	").replace(/\\f/g, "\f").replace(/\\x3C/g, "<").replace(/\\u2028/g, "\u2028").replace(/\\u2029/g, "\u2029");
+}
+
+// src/tree/UnsupportedTypeError.ts
+var { toString } = Object.prototype;
+var UnsupportedTypeError = class extends Error {
+  constructor(value) {
+    super('Unsupported type "' + toString.call(value) + '"');
+  }
+};
+
+// src/tree/constants.ts
+function createConstantNode(value) {
+  return {
+    t: 2 /* Constant */,
+    i: void 0,
+    s: value,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+var TRUE_NODE = createConstantNode(2 /* True */);
+var FALSE_NODE = createConstantNode(3 /* False */);
+var UNDEFINED_NODE = createConstantNode(1 /* Undefined */);
+var NULL_NODE = createConstantNode(0 /* Null */);
+var NEG_ZERO_NODE = createConstantNode(4 /* NegativeZero */);
+var INFINITY_NODE = createConstantNode(5 /* Infinity */);
+var NEG_INFINITY_NODE = createConstantNode(6 /* NegativeInfinity */);
+var NAN_NODE = createConstantNode(7 /* NaN */);
+function serializeConstant(node) {
+  switch (node.s) {
+    case 2 /* True */:
+      return "!0";
+    case 3 /* False */:
+      return "!1";
+    case 1 /* Undefined */:
+      return "void 0";
+    case 0 /* Null */:
+      return "null";
+    case 4 /* NegativeZero */:
+      return "-0";
+    case 5 /* Infinity */:
+      return "1/0";
+    case 6 /* NegativeInfinity */:
+      return "-1/0";
+    case 7 /* NaN */:
+      return "NaN";
+    default:
+      throw new Error("invariant");
+  }
+}
+function deserializeConstant(node) {
+  switch (node.s) {
+    case 2 /* True */:
+      return true;
+    case 3 /* False */:
+      return false;
+    case 1 /* Undefined */:
+      return void 0;
+    case 0 /* Null */:
+      return null;
+    case 4 /* NegativeZero */:
+      return -0;
+    case 5 /* Infinity */:
+      return Infinity;
+    case 6 /* NegativeInfinity */:
+      return -Infinity;
+    case 7 /* NaN */:
+      return NaN;
+    default:
+      throw new Error("invariant");
+  }
 }
 
 // src/tree/reference.ts
@@ -160,11 +240,11 @@ function hasReference(id) {
   return INV_REFERENCE.has(id);
 }
 function getReferenceID(value) {
-  assert(hasReferenceID(value), "Missing reference id");
+  assert(hasReferenceID(value), new Error("Missing reference id"));
   return REFERENCE.get(value);
 }
 function getReference(id) {
-  assert(hasReference(id), "Missing reference for id:" + id);
+  assert(hasReference(id), new Error("Missing reference for id:" + id));
   return INV_REFERENCE.get(id);
 }
 var GLOBAL_KEY = "__SEROVAL__";
@@ -246,124 +326,51 @@ var SYMBOL_REF = {
 };
 
 // src/tree/primitives.ts
-var TRUE_NODE = {
-  t: 2 /* Boolean */,
-  i: void 0,
-  s: true,
-  l: void 0,
-  c: void 0,
-  m: void 0,
-  d: void 0,
-  a: void 0,
-  f: void 0
-};
-var FALSE_NODE = {
-  t: 2 /* Boolean */,
-  i: void 0,
-  s: false,
-  l: void 0,
-  c: void 0,
-  m: void 0,
-  d: void 0,
-  a: void 0,
-  f: void 0
-};
-var UNDEFINED_NODE = {
-  t: 4 /* Undefined */,
-  i: void 0,
-  s: void 0,
-  l: void 0,
-  c: void 0,
-  m: void 0,
-  d: void 0,
-  a: void 0,
-  f: void 0
-};
-var NULL_NODE = {
-  t: 3 /* Null */,
-  i: void 0,
-  s: void 0,
-  l: void 0,
-  c: void 0,
-  m: void 0,
-  d: void 0,
-  a: void 0,
-  f: void 0
-};
-var NEG_ZERO_NODE = {
-  t: 5 /* NegativeZero */,
-  i: void 0,
-  s: void 0,
-  l: void 0,
-  c: void 0,
-  m: void 0,
-  d: void 0,
-  a: void 0,
-  f: void 0
-};
-var INFINITY_NODE = {
-  t: 6 /* Infinity */,
-  i: void 0,
-  s: void 0,
-  l: void 0,
-  c: void 0,
-  m: void 0,
-  d: void 0,
-  a: void 0,
-  f: void 0
-};
-var NEG_INFINITY_NODE = {
-  t: 7 /* NegativeInfinity */,
-  i: void 0,
-  s: void 0,
-  l: void 0,
-  c: void 0,
-  m: void 0,
-  d: void 0,
-  a: void 0,
-  f: void 0
-};
-var NAN_NODE = {
-  t: 8 /* NaN */,
-  i: void 0,
-  s: void 0,
-  l: void 0,
-  c: void 0,
-  m: void 0,
-  d: void 0,
-  a: void 0,
-  f: void 0
-};
 function createNumberNode(value) {
-  return {
-    t: 0 /* Number */,
-    i: void 0,
-    s: value,
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    d: void 0,
-    a: void 0,
-    f: void 0
-  };
+  switch (value) {
+    case Infinity:
+      return INFINITY_NODE;
+    case -Infinity:
+      return NEG_INFINITY_NODE;
+    default:
+      if (value !== value) {
+        return NAN_NODE;
+      }
+      if (Object.is(value, -0)) {
+        return NEG_ZERO_NODE;
+      }
+      return {
+        t: 0 /* Number */,
+        i: void 0,
+        s: value,
+        l: void 0,
+        c: void 0,
+        m: void 0,
+        d: void 0,
+        a: void 0,
+        f: void 0,
+        b: void 0
+      };
+  }
 }
 function createStringNode(value) {
   return {
     t: 1 /* String */,
     i: void 0,
-    s: quote(value),
+    s: serializeString(value),
     l: void 0,
     c: void 0,
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function createBigIntNode(ctx, current) {
-  assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+  assert(ctx.features & 8 /* BigInt */, new UnsupportedTypeError(current));
   return {
-    t: 9 /* BigInt */,
+    t: 3 /* BigInt */,
     i: void 0,
     s: "" + current,
     l: void 0,
@@ -371,12 +378,13 @@ function createBigIntNode(ctx, current) {
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function createIndexedValueNode(id) {
   return {
-    t: 10 /* IndexedValue */,
+    t: 4 /* IndexedValue */,
     i: id,
     s: void 0,
     l: void 0,
@@ -384,12 +392,13 @@ function createIndexedValueNode(id) {
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function createDateNode(id, current) {
   return {
-    t: 11 /* Date */,
+    t: 5 /* Date */,
     i: id,
     s: current.toISOString(),
     l: void 0,
@@ -397,12 +406,13 @@ function createDateNode(id, current) {
     m: void 0,
     d: void 0,
     f: void 0,
-    a: void 0
+    a: void 0,
+    b: void 0
   };
 }
 function createRegExpNode(id, current) {
   return {
-    t: 12 /* RegExp */,
+    t: 6 /* RegExp */,
     i: id,
     s: void 0,
     l: void 0,
@@ -410,81 +420,133 @@ function createRegExpNode(id, current) {
     m: current.flags,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
-function createTypedArrayNode(ctx, id, current) {
-  const constructor = current.constructor.name;
-  assert(ctx.features & 2048 /* TypedArray */, `Unsupported value type "${constructor}"`);
-  const len = current.length;
+function createArrayBufferNode(id, current) {
+  const bytes = new Uint8Array(current);
+  const len = bytes.length;
   const values = new Array(len);
   for (let i = 0; i < len; i++) {
-    values[i] = "" + current[i];
+    values[i] = bytes[i];
   }
   return {
-    t: 22 /* TypedArray */,
+    t: 21 /* ArrayBuffer */,
     i: id,
     s: values,
-    l: current.byteOffset,
-    c: constructor,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+function serializeArrayBuffer(ctx, current) {
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  return createArrayBufferNode(id, current);
+}
+function createTypedArrayNode(ctx, id, current) {
+  assert(ctx.features & 2048 /* TypedArray */, new UnsupportedTypeError(current));
+  return {
+    t: 15 /* TypedArray */,
+    i: id,
+    s: void 0,
+    l: current.length,
+    c: current.constructor.name,
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset
   };
 }
 var BIGINT_FLAG = 4096 /* BigIntTypedArray */ | 8 /* BigInt */;
 function createBigIntTypedArrayNode(ctx, id, current) {
-  const constructor = current.constructor.name;
   assert(
     (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
-    `Unsupported value type "${constructor}"`
+    new UnsupportedTypeError(current)
   );
-  const len = current.length;
-  const values = new Array(len);
-  for (let i = 0; i < len; i++) {
-    values[i] = "" + current[i];
-  }
   return {
-    t: 23 /* BigIntTypedArray */,
+    t: 16 /* BigIntTypedArray */,
     i: id,
-    s: values,
-    l: current.byteOffset,
-    c: constructor,
+    s: void 0,
+    l: current.length,
+    c: current.constructor.name,
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset
   };
 }
-function createWKSymbolNode(ctx, current) {
-  assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "symbol"');
-  assert(current in INV_SYMBOL_REF, "seroval only supports well-known symbols");
+function createWKSymbolNode(ctx, id, current) {
+  assert(ctx.features & 1024 /* Symbol */, new UnsupportedTypeError(current));
+  assert(current in INV_SYMBOL_REF, new Error("Only well-known symbols are supported."));
   return {
-    t: 24 /* WKSymbol */,
-    i: void 0,
+    t: 17 /* WKSymbol */,
+    i: id,
     s: INV_SYMBOL_REF[current],
     l: void 0,
     c: void 0,
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function createReferenceNode(id, ref) {
   return {
-    t: 27 /* Reference */,
+    t: 20 /* Reference */,
     i: id,
-    s: quote(getReferenceID(ref)),
+    s: serializeString(getReferenceID(ref)),
     l: void 0,
     c: void 0,
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
+  };
+}
+function createDataViewNode(ctx, id, current) {
+  return {
+    t: 22 /* DataView */,
+    i: id,
+    s: void 0,
+    l: current.byteLength,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset
   };
 }
+function createSymbolNode(ctx, current) {
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  if (hasReferenceID(current)) {
+    return createReferenceNode(id, current);
+  }
+  return createWKSymbolNode(ctx, id, current);
+}
+function createFunctionNode(ctx, current) {
+  assert(hasReferenceID(current), new Error("Cannot serialize function without reference ID."));
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  return createReferenceNode(id, current);
+}
 
 // src/tree/shared.ts
 function getErrorConstructorName(error) {
@@ -552,17 +614,6 @@ function getErrorOptions(ctx, error) {
   }
   return options;
 }
-function getIterableOptions(obj) {
-  const names = Object.getOwnPropertyNames(obj);
-  if (names.length) {
-    const options = {};
-    for (const name of names) {
-      options[name] = obj[name];
-    }
-    return options;
-  }
-  return void 0;
-}
 function isIterable(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -626,36 +677,68 @@ function isValidIdentifier(name) {
 
 // src/tree/web-api.ts
 function createURLNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "URL"');
+  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   return {
-    t: 25 /* URL */,
+    t: 18 /* URL */,
     i: id,
-    s: current.href,
+    s: serializeString(current.href),
     l: void 0,
     c: void 0,
     m: void 0,
     d: void 0,
     f: void 0,
-    a: void 0
+    a: void 0,
+    b: void 0
   };
 }
 function createURLSearchParamsNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "URLSearchParams"');
+  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   return {
-    t: 26 /* URLSearchParams */,
+    t: 19 /* URLSearchParams */,
     i: id,
-    s: current.toString(),
+    s: serializeString(current.toString()),
     l: void 0,
     c: void 0,
     m: void 0,
     d: void 0,
     f: void 0,
-    a: void 0
+    a: void 0,
+    b: void 0
+  };
+}
+async function createBlobNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
+  return {
+    t: 23 /* Blob */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: serializeString(current.type),
+    m: void 0,
+    d: void 0,
+    f: serializeArrayBuffer(ctx, await current.arrayBuffer()),
+    a: void 0,
+    b: void 0
+  };
+}
+async function createFileNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
+  return {
+    t: 24 /* File */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: serializeString(current.type),
+    m: serializeString(current.name),
+    d: void 0,
+    f: serializeArrayBuffer(ctx, await current.arrayBuffer()),
+    a: void 0,
+    b: current.lastModified
   };
 }
 
-// src/tree/async.ts
-async function generateNodeList(ctx, current) {
+// src/tree/sync.ts
+function generateNodeList(ctx, current) {
   const size = current.length;
   const nodes = new Array(size);
   const deferred = new Array(size);
@@ -666,32 +749,33 @@ async function generateNodeList(ctx, current) {
       if (isIterable(item)) {
         deferred[i] = item;
       } else {
-        nodes[i] = await parse(ctx, item);
+        nodes[i] = parseSync(ctx, item);
       }
     }
   }
   for (let i = 0; i < size; i++) {
     if (i in deferred) {
-      nodes[i] = await parse(ctx, deferred[i]);
+      nodes[i] = parseSync(ctx, deferred[i]);
     }
   }
   return nodes;
 }
-async function generateArrayNode(ctx, id, current) {
+function generateArrayNode(ctx, id, current) {
   return {
-    t: 15 /* Array */,
+    t: 9 /* Array */,
     i: id,
     s: void 0,
     l: current.length,
     c: void 0,
     m: void 0,
     d: void 0,
-    a: await generateNodeList(ctx, current),
-    f: void 0
+    a: generateNodeList(ctx, current),
+    f: void 0,
+    b: void 0
   };
 }
-async function generateMapNode(ctx, id, current) {
-  assert(ctx.features & 32 /* Map */, 'Unsupported type "Map"');
+function generateMapNode(ctx, id, current) {
+  assert(ctx.features & 32 /* Map */, new UnsupportedTypeError(current));
   const len = current.size;
   const keyNodes = new Array(len);
   const valueNodes = new Array(len);
@@ -705,17 +789,17 @@ async function generateMapNode(ctx, id, current) {
       deferredValue[deferredSize] = value;
       deferredSize++;
     } else {
-      keyNodes[nodeSize] = await parse(ctx, key);
-      valueNodes[nodeSize] = await parse(ctx, value);
+      keyNodes[nodeSize] = parseSync(ctx, key);
+      valueNodes[nodeSize] = parseSync(ctx, value);
       nodeSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodeSize + i] = await parse(ctx, deferredKey[i]);
-    valueNodes[nodeSize + i] = await parse(ctx, deferredValue[i]);
+    keyNodes[nodeSize + i] = parseSync(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = parseSync(ctx, deferredValue[i]);
   }
   return {
-    t: 14 /* Map */,
+    t: 8 /* Map */,
     i: id,
     s: void 0,
     l: void 0,
@@ -723,11 +807,12 @@ async function generateMapNode(ctx, id, current) {
     m: void 0,
     d: { k: keyNodes, v: valueNodes, s: len },
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
-async function generateSetNode(ctx, id, current) {
-  assert(ctx.features & 512 /* Set */, 'Unsupported type "Set"');
+function generateSetNode(ctx, id, current) {
+  assert(ctx.features & 512 /* Set */, new UnsupportedTypeError(current));
   const len = current.size;
   const nodes = new Array(len);
   const deferred = new Array(len);
@@ -737,14 +822,14 @@ async function generateSetNode(ctx, id, current) {
     if (isIterable(item)) {
       deferred[deferredSize++] = item;
     } else {
-      nodes[nodeSize++] = await parse(ctx, item);
+      nodes[nodeSize++] = parseSync(ctx, item);
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    nodes[nodeSize + i] = await parse(ctx, deferred[i]);
+    nodes[nodeSize + i] = parseSync(ctx, deferred[i]);
   }
   return {
-    t: 13 /* Set */,
+    t: 7 /* Set */,
     i: id,
     s: void 0,
     l: len,
@@ -752,10 +837,54 @@ async function generateSetNode(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: nodes,
-    f: void 0
+    f: void 0,
+    b: void 0
+  };
+}
+function generateProperties(ctx, properties) {
+  const keys = Object.keys(properties);
+  let 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;
+  let item;
+  let escaped;
+  for (const key of keys) {
+    item = properties[key];
+    escaped = serializeString(key);
+    if (isIterable(item)) {
+      deferredKeys[deferredSize] = escaped;
+      deferredValues[deferredSize] = item;
+      deferredSize++;
+    } else {
+      keyNodes[nodesSize] = escaped;
+      valueNodes[nodesSize] = parseSync(ctx, item);
+      nodesSize++;
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = parseSync(ctx, deferredValues[i]);
+  }
+  if (ctx.features & 1024 /* Symbol */) {
+    if (Symbol.iterator in properties) {
+      keyNodes[size] = 0 /* SymbolIterator */;
+      const items = Array.from(properties);
+      const id = createIndexedValue(ctx, items);
+      valueNodes[size] = generateArrayNode(ctx, id, items);
+      size++;
+    }
+  }
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
   };
 }
-async function generateProperties(ctx, properties) {
+function generatePlainProperties(ctx, properties) {
   const keys = Object.keys(properties);
   const size = keys.length;
   const keyNodes = new Array(size);
@@ -765,21 +894,23 @@ async function generateProperties(ctx, properties) {
   let deferredSize = 0;
   let nodesSize = 0;
   let item;
+  let escaped;
   for (const key of keys) {
     item = properties[key];
+    escaped = serializeString(key);
     if (isIterable(item)) {
-      deferredKeys[deferredSize] = key;
+      deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
     } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = await parse(ctx, item);
+      keyNodes[nodesSize] = escaped;
+      valueNodes[nodesSize] = parseSync(ctx, item);
       nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
     keyNodes[nodesSize + i] = deferredKeys[i];
-    valueNodes[nodesSize + i] = await parse(ctx, deferredValues[i]);
+    valueNodes[nodesSize + i] = parseSync(ctx, deferredValues[i]);
   }
   return {
     k: keyNodes,
@@ -787,88 +918,204 @@ async function generateProperties(ctx, properties) {
     s: size
   };
 }
-async function generateIterableNode(ctx, id, current) {
-  assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "Iterable"');
-  const options = getIterableOptions(current);
-  const array = Array.from(current);
+function generateObjectNode(ctx, id, current, empty) {
   return {
-    t: 21 /* Iterable */,
+    t: empty ? 11 /* NullConstructor */ : 10 /* Object */,
     i: id,
     s: void 0,
-    l: array.length,
+    l: void 0,
     c: void 0,
     m: void 0,
-    // Parse options first before the items
-    d: options ? await generateProperties(ctx, options) : void 0,
-    a: await generateNodeList(ctx, array),
-    f: void 0
+    d: generateProperties(ctx, current),
+    a: void 0,
+    f: void 0,
+    b: void 0
   };
 }
-async function generatePromiseNode(ctx, id, current) {
-  assert(ctx.features & 256 /* Promise */, 'Unsupported type "Promise"');
-  return current.then(async (value) => ({
-    t: 18 /* Promise */,
+function generateAggregateErrorNode(ctx, id, current) {
+  const options = getErrorOptions(ctx, current);
+  const optionsNode = options ? generateProperties(ctx, options) : void 0;
+  return {
+    t: 14 /* AggregateError */,
     i: id,
     s: void 0,
     l: void 0,
     c: void 0,
-    m: void 0,
-    // Parse options first before the items
-    d: void 0,
+    m: serializeString(current.message),
+    d: optionsNode,
     a: void 0,
-    f: await parse(ctx, value)
-  }));
+    f: void 0,
+    b: void 0
+  };
 }
-async function generateObjectNode(ctx, id, current, empty) {
-  if (Symbol.iterator in current) {
-    return generateIterableNode(ctx, id, current);
-  }
-  if ("then" in current && typeof current.then === "function") {
-    return generatePromiseNode(ctx, id, current);
-  }
+function generateErrorNode(ctx, id, current) {
+  const options = getErrorOptions(ctx, current);
+  const optionsNode = options ? generateProperties(ctx, options) : void 0;
+  return {
+    t: 13 /* Error */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: getErrorConstructorName(current),
+    m: serializeString(current.message),
+    d: optionsNode,
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+function generateHeadersNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
+  const items = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
   return {
-    t: empty ? 17 /* NullConstructor */ : 16 /* Object */,
+    t: 25 /* Headers */,
     i: id,
     s: void 0,
     l: void 0,
     c: void 0,
     m: void 0,
-    d: await generateProperties(ctx, current),
+    d: generatePlainProperties(ctx, items),
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
-async function generateAggregateErrorNode(ctx, id, current) {
-  const options = getErrorOptions(ctx, current);
-  const optionsNode = options ? await generateProperties(ctx, options) : void 0;
+function generateFormDataNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
+  const items = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
   return {
-    t: 20 /* AggregateError */,
+    t: 26 /* FormData */,
     i: id,
     s: void 0,
-    l: current.errors.length,
+    l: void 0,
     c: void 0,
-    m: quote(current.message),
-    d: optionsNode,
-    a: await generateNodeList(ctx, current.errors),
-    f: void 0
+    m: void 0,
+    d: generatePlainProperties(ctx, items),
+    a: void 0,
+    f: void 0,
+    b: void 0
   };
 }
-async function generateErrorNode(ctx, id, current) {
-  const options = getErrorOptions(ctx, current);
-  const optionsNode = options ? await generateProperties(ctx, options) : void 0;
+function generateBoxedNode(ctx, id, current) {
   return {
-    t: 19 /* Error */,
+    t: 27 /* Boxed */,
     i: id,
     s: void 0,
     l: void 0,
-    c: getErrorConstructorName(current),
-    m: quote(current.message),
-    d: optionsNode,
+    c: void 0,
+    m: void 0,
+    d: void 0,
     a: void 0,
-    f: void 0
+    f: parseSync(ctx, current.valueOf()),
+    b: void 0
   };
 }
-async function parse(ctx, current) {
+function parseObject(ctx, current) {
+  if (!current) {
+    return NULL_NODE;
+  }
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  if (hasReferenceID(current)) {
+    return createReferenceNode(id, current);
+  }
+  if (Array.isArray(current)) {
+    return generateArrayNode(ctx, id, current);
+  }
+  switch (current.constructor) {
+    case Number:
+    case Boolean:
+    case String:
+    case BigInt:
+    case Function:
+    case Symbol:
+      return generateBoxedNode(ctx, id, current);
+    case Date:
+      return createDateNode(id, current);
+    case RegExp:
+      return createRegExpNode(id, current);
+    case ArrayBuffer:
+      return createArrayBufferNode(id, current);
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+      return createTypedArrayNode(ctx, id, current);
+    case BigInt64Array:
+    case BigUint64Array:
+      return createBigIntTypedArrayNode(ctx, id, current);
+    case DataView:
+      return createDataViewNode(ctx, id, current);
+    case Map:
+      return generateMapNode(ctx, id, current);
+    case Set:
+      return generateSetNode(ctx, id, current);
+    case Object:
+      return generateObjectNode(
+        ctx,
+        id,
+        current,
+        false
+      );
+    case void 0:
+      return generateObjectNode(
+        ctx,
+        id,
+        current,
+        true
+      );
+    case AggregateError:
+      if (ctx.features & 1 /* AggregateError */) {
+        return generateAggregateErrorNode(ctx, id, current);
+      }
+      return generateErrorNode(ctx, id, current);
+    case Error:
+    case EvalError:
+    case RangeError:
+    case ReferenceError:
+    case SyntaxError:
+    case TypeError:
+    case URIError:
+      return generateErrorNode(ctx, id, current);
+    case URL:
+      return createURLNode(ctx, id, current);
+    case URLSearchParams:
+      return createURLSearchParamsNode(ctx, id, current);
+    case Headers:
+      return generateHeadersNode(ctx, id, current);
+    case FormData:
+      return generateFormDataNode(ctx, id, current);
+    default:
+      break;
+  }
+  if (current instanceof AggregateError) {
+    if (ctx.features & 1 /* AggregateError */) {
+      return generateAggregateErrorNode(ctx, id, current);
+    }
+    return generateErrorNode(ctx, id, current);
+  }
+  if (current instanceof Error) {
+    return generateErrorNode(ctx, id, current);
+  }
+  if (Symbol.iterator in current) {
+    return generateObjectNode(ctx, id, current, !!current.constructor);
+  }
+  throw new UnsupportedTypeError(current);
+}
+function parseSync(ctx, current) {
   switch (typeof current) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
@@ -877,157 +1124,473 @@ async function parse(ctx, current) {
     case "string":
       return createStringNode(current);
     case "number":
-      switch (current) {
-        case Infinity:
-          return INFINITY_NODE;
-        case -Infinity:
-          return NEG_INFINITY_NODE;
-        default:
-          if (current !== current) {
-            return NAN_NODE;
-          }
-          if (Object.is(current, -0)) {
-            return NEG_ZERO_NODE;
-          }
-          return createNumberNode(current);
-      }
+      return createNumberNode(current);
     case "bigint":
       return createBigIntNode(ctx, current);
-    case "object": {
-      if (!current) {
-        return NULL_NODE;
-      }
-      const id = createIndexedValue(ctx, current);
-      if (ctx.markedRefs.has(id)) {
-        return createIndexedValueNode(id);
-      }
-      if (hasReferenceID(current)) {
-        return createReferenceNode(id, current);
+    case "object":
+      return parseObject(ctx, current);
+    case "symbol":
+      return createSymbolNode(ctx, current);
+    case "function":
+      return createFunctionNode(ctx, current);
+    default:
+      throw new UnsupportedTypeError(current);
+  }
+}
+
+// src/tree/async.ts
+async function generateNodeList2(ctx, current) {
+  const size = current.length;
+  const nodes = new Array(size);
+  const deferred = new Array(size);
+  let item;
+  for (let i = 0; i < size; i++) {
+    if (i in current) {
+      item = current[i];
+      if (isIterable(item)) {
+        deferred[i] = item;
+      } else {
+        nodes[i] = await parseAsync(ctx, item);
       }
-      if (Array.isArray(current)) {
-        return generateArrayNode(ctx, id, current);
-      }
-      switch (current.constructor) {
-        case Date:
-          return createDateNode(id, current);
-        case RegExp:
-          return createRegExpNode(id, current);
-        case Promise:
-          return generatePromiseNode(ctx, id, current);
-        case Int8Array:
-        case Int16Array:
-        case Int32Array:
-        case Uint8Array:
-        case Uint16Array:
-        case Uint32Array:
-        case Uint8ClampedArray:
-        case Float32Array:
-        case Float64Array:
-          return createTypedArrayNode(ctx, id, current);
-        case BigInt64Array:
-        case BigUint64Array:
-          return createBigIntTypedArrayNode(ctx, id, current);
-        case Map:
-          return generateMapNode(
-            ctx,
-            id,
-            current
-          );
-        case Set:
-          return generateSetNode(
-            ctx,
-            id,
-            current
-          );
-        case Object:
-          return generateObjectNode(
-            ctx,
-            id,
-            current,
-            false
-          );
-        case void 0:
-          return generateObjectNode(
-            ctx,
-            id,
-            current,
-            true
-          );
-        case AggregateError:
-          if (ctx.features & 1 /* AggregateError */) {
-            return generateAggregateErrorNode(ctx, id, current);
-          }
-          return generateErrorNode(ctx, id, current);
-        case Error:
-        case EvalError:
-        case RangeError:
-        case ReferenceError:
-        case SyntaxError:
-        case TypeError:
-        case URIError:
-          return generateErrorNode(ctx, id, current);
-        case URL:
-          return createURLNode(ctx, id, current);
-        case URLSearchParams:
-          return createURLSearchParamsNode(ctx, id, current);
-        default:
-          break;
-      }
-      if (current instanceof AggregateError) {
-        if (ctx.features & 1 /* AggregateError */) {
-          return generateAggregateErrorNode(ctx, id, current);
-        }
-        return generateErrorNode(ctx, id, current);
-      }
-      if (current instanceof Error) {
-        return generateErrorNode(ctx, id, current);
-      }
-      if (current instanceof Promise) {
-        return generatePromiseNode(ctx, id, current);
-      }
-      if (Symbol.iterator in current) {
-        return generateIterableNode(ctx, id, current);
-      }
-      if ("then" in current && typeof current.then === "function") {
-        return generatePromiseNode(ctx, id, current);
-      }
-      throw new Error("Unsupported type");
     }
-    case "symbol":
-      if (hasReferenceID(current)) {
-        const id = createIndexedValue(ctx, current);
-        if (ctx.markedRefs.has(id)) {
-          return createIndexedValueNode(id);
-        }
-        return createReferenceNode(id, current);
-      }
-      return createWKSymbolNode(ctx, current);
-    case "function": {
-      assert(hasReferenceID(current), "Cannot serialize function without reference ID.");
-      const id = createIndexedValue(ctx, current);
-      if (ctx.markedRefs.has(id)) {
-        return createIndexedValueNode(id);
-      }
-      return createReferenceNode(id, current);
+  }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = await parseAsync(ctx, deferred[i]);
+    }
+  }
+  return nodes;
+}
+async function generateArrayNode2(ctx, id, current) {
+  return {
+    t: 9 /* Array */,
+    i: id,
+    s: void 0,
+    l: current.length,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: await generateNodeList2(ctx, current),
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateMapNode2(ctx, id, current) {
+  assert(ctx.features & 32 /* Map */, new UnsupportedTypeError(current));
+  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 parseAsync(ctx, key);
+      valueNodes[nodeSize] = await parseAsync(ctx, value);
+      nodeSize++;
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodeSize + i] = await parseAsync(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = await parseAsync(ctx, deferredValue[i]);
+  }
+  return {
+    t: 8 /* Map */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: { k: keyNodes, v: valueNodes, s: len },
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateSetNode2(ctx, id, current) {
+  assert(ctx.features & 512 /* Set */, new UnsupportedTypeError(current));
+  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 parseAsync(ctx, item);
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    nodes[nodeSize + i] = await parseAsync(ctx, deferred[i]);
+  }
+  return {
+    t: 7 /* Set */,
+    i: id,
+    s: void 0,
+    l: len,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: nodes,
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateProperties2(ctx, properties) {
+  const keys = Object.keys(properties);
+  let 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;
+  let item;
+  let escaped;
+  for (const key of keys) {
+    item = properties[key];
+    escaped = serializeString(key);
+    if (isIterable(item)) {
+      deferredKeys[deferredSize] = escaped;
+      deferredValues[deferredSize] = item;
+      deferredSize++;
+    } else {
+      keyNodes[nodesSize] = escaped;
+      valueNodes[nodesSize] = await parseAsync(ctx, item);
+      nodesSize++;
     }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await parseAsync(ctx, deferredValues[i]);
+  }
+  if (ctx.features & 1024 /* Symbol */) {
+    if (Symbol.iterator in properties) {
+      keyNodes[size] = 0 /* SymbolIterator */;
+      const items = Array.from(properties);
+      valueNodes[size] = await generateArrayNode2(
+        ctx,
+        createIndexedValue(ctx, items),
+        items
+      );
+      size++;
+    }
+  }
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
+}
+async function generatePlainProperties2(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;
+  let item;
+  let escaped;
+  for (const key of keys) {
+    item = properties[key];
+    escaped = serializeString(key);
+    if (isIterable(item)) {
+      deferredKeys[deferredSize] = escaped;
+      deferredValues[deferredSize] = item;
+      deferredSize++;
+    } else {
+      keyNodes[nodesSize] = escaped;
+      valueNodes[nodesSize] = await parseAsync(ctx, item);
+      nodesSize++;
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await parseAsync(ctx, deferredValues[i]);
+  }
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
+}
+async function generatePromiseNode(ctx, id, current) {
+  assert(ctx.features & 256 /* Promise */, new UnsupportedTypeError(current));
+  return {
+    t: 12 /* Promise */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    // Parse options first before the items
+    d: void 0,
+    a: void 0,
+    f: await parseAsync(ctx, await current),
+    b: void 0
+  };
+}
+async function generateObjectNode2(ctx, id, current, empty) {
+  return {
+    t: empty ? 11 /* NullConstructor */ : 10 /* Object */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: await generateProperties2(ctx, current),
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateAggregateErrorNode2(ctx, id, current) {
+  const options = getErrorOptions(ctx, current);
+  const optionsNode = options ? await generateProperties2(ctx, options) : void 0;
+  return {
+    t: 14 /* AggregateError */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: serializeString(current.message),
+    d: optionsNode,
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateErrorNode2(ctx, id, current) {
+  const options = getErrorOptions(ctx, current);
+  const optionsNode = options ? await generateProperties2(ctx, options) : void 0;
+  return {
+    t: 13 /* Error */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: getErrorConstructorName(current),
+    m: serializeString(current.message),
+    d: optionsNode,
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateHeadersNode2(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
+  const items = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: 25 /* Headers */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: await generatePlainProperties2(ctx, items),
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateFormDataNode2(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
+  const items = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: 26 /* FormData */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: await generatePlainProperties2(ctx, items),
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateBoxedNode2(ctx, id, current) {
+  return {
+    t: 27 /* Boxed */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    f: await parseAsync(ctx, current.valueOf()),
+    b: void 0
+  };
+}
+async function parseObject2(ctx, current) {
+  if (!current) {
+    return NULL_NODE;
+  }
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  if (hasReferenceID(current)) {
+    return createReferenceNode(id, current);
+  }
+  if (Array.isArray(current)) {
+    return generateArrayNode2(ctx, id, current);
+  }
+  switch (current.constructor) {
+    case Number:
+    case Boolean:
+    case String:
+    case BigInt:
+    case Function:
+    case Symbol:
+      return generateBoxedNode2(ctx, id, current);
+    case Date:
+      return createDateNode(id, current);
+    case RegExp:
+      return createRegExpNode(id, current);
+    case Promise:
+      return generatePromiseNode(ctx, id, current);
+    case ArrayBuffer:
+      return createArrayBufferNode(id, current);
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+      return createTypedArrayNode(ctx, id, current);
+    case BigInt64Array:
+    case BigUint64Array:
+      return createBigIntTypedArrayNode(ctx, id, current);
+    case DataView:
+      return createDataViewNode(ctx, id, current);
+    case Map:
+      return generateMapNode2(
+        ctx,
+        id,
+        current
+      );
+    case Set:
+      return generateSetNode2(
+        ctx,
+        id,
+        current
+      );
+    case Object:
+      return generateObjectNode2(
+        ctx,
+        id,
+        current,
+        false
+      );
+    case void 0:
+      return generateObjectNode2(
+        ctx,
+        id,
+        current,
+        true
+      );
+    case AggregateError:
+      if (ctx.features & 1 /* AggregateError */) {
+        return generateAggregateErrorNode2(ctx, id, current);
+      }
+      return generateErrorNode2(ctx, id, current);
+    case Error:
+    case EvalError:
+    case RangeError:
+    case ReferenceError:
+    case SyntaxError:
+    case TypeError:
+    case URIError:
+      return generateErrorNode2(ctx, id, current);
+    case URL:
+      return createURLNode(ctx, id, current);
+    case URLSearchParams:
+      return createURLSearchParamsNode(ctx, id, current);
+    case Blob:
+      return createBlobNode(ctx, id, current);
+    case File:
+      return createFileNode(ctx, id, current);
+    case Headers:
+      return generateHeadersNode2(ctx, id, current);
+    case FormData:
+      return generateFormDataNode2(ctx, id, current);
     default:
-      throw new Error("Unsupported type");
+      break;
   }
+  if (current instanceof AggregateError) {
+    if (ctx.features & 1 /* AggregateError */) {
+      return generateAggregateErrorNode2(ctx, id, current);
+    }
+    return generateErrorNode2(ctx, id, current);
+  }
+  if (current instanceof Error) {
+    return generateErrorNode2(ctx, id, current);
+  }
+  if (current instanceof Promise) {
+    return generatePromiseNode(ctx, id, current);
+  }
+  if (Symbol.iterator in current) {
+    return generateObjectNode2(ctx, id, current, !!current.constructor);
+  }
+  throw new UnsupportedTypeError(current);
 }
 async function parseAsync(ctx, current) {
-  const result = await parse(ctx, current);
-  const isObject = result.t === 16 /* Object */ || result.t === 21 /* Iterable */;
-  return [result, getRootID(ctx, current), isObject];
+  switch (typeof current) {
+    case "boolean":
+      return current ? TRUE_NODE : FALSE_NODE;
+    case "undefined":
+      return UNDEFINED_NODE;
+    case "string":
+      return createStringNode(current);
+    case "number":
+      return createNumberNode(current);
+    case "bigint":
+      return createBigIntNode(ctx, current);
+    case "object":
+      return parseObject2(ctx, current);
+    case "symbol":
+      return createSymbolNode(ctx, current);
+    case "function":
+      return createFunctionNode(ctx, current);
+    default:
+      throw new UnsupportedTypeError(current);
+  }
 }
 
 // src/tree/deserialize.ts
 function assignIndexedValue(ctx, index, value) {
-  ctx.valueMap.set(index, value);
+  if (ctx.markedRefs.has(index)) {
+    ctx.valueMap.set(index, value);
+  }
   return value;
 }
-function deserializeNodeList(ctx, node, result) {
+function deserializeArray(ctx, node) {
+  const len = node.l;
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    new Array(len)
+  );
   let item;
-  for (let i = 0, len = node.a.length; i < len; i++) {
+  for (let i = 0; i < len; i++) {
     item = node.a[i];
     if (item) {
       result[i] = deserializeTree(ctx, item);
@@ -1035,51 +1598,46 @@ function deserializeNodeList(ctx, node, result) {
   }
   return result;
 }
-function deserializeArray(ctx, node) {
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new Array(node.l)
-  );
-  ctx.stack.push(node.i);
-  deserializeNodeList(ctx, node, result);
-  ctx.stack.pop();
-  return result;
-}
 function deserializeProperties(ctx, node, result) {
-  if (node.s === 0) {
-    return {};
-  }
-  for (let i = 0; i < node.s; i++) {
-    result[node.k[i]] = deserializeTree(ctx, node.v[i]);
+  const len = node.s;
+  if (len) {
+    let key;
+    let value;
+    const keys = node.k;
+    const vals = node.v;
+    for (let i = 0; i < len; i++) {
+      key = keys[i];
+      value = deserializeTree(ctx, vals[i]);
+      switch (key) {
+        case 0 /* SymbolIterator */:
+          {
+            const current = value;
+            result[Symbol.iterator] = () => current.values();
+          }
+          break;
+        default:
+          result[deserializeString(key)] = value;
+          break;
+      }
+    }
   }
   return result;
 }
-function deserializeNullConstructor(ctx, node) {
+function deserializeObject(ctx, node) {
   const result = assignIndexedValue(
     ctx,
     node.i,
-    /* @__PURE__ */ Object.create(null)
+    node.t === 10 /* Object */ ? {} : /* @__PURE__ */ Object.create(null)
   );
-  ctx.stack.push(node.i);
-  deserializeProperties(ctx, node.d, result);
-  ctx.stack.pop();
-  return result;
-}
-function deserializeObject(ctx, node) {
-  const result = assignIndexedValue(ctx, node.i, {});
-  ctx.stack.push(node.i);
   deserializeProperties(ctx, node.d, result);
-  ctx.stack.pop();
   return result;
 }
 function deserializeSet(ctx, node) {
   const result = assignIndexedValue(ctx, node.i, /* @__PURE__ */ new Set());
-  ctx.stack.push(node.i);
-  for (let i = 0, len = node.a.length; i < len; i++) {
-    result.add(deserializeTree(ctx, node.a[i]));
+  const items = node.a;
+  for (let i = 0, len = node.l; i < len; i++) {
+    result.add(deserializeTree(ctx, items[i]));
   }
-  ctx.stack.pop();
   return result;
 }
 function deserializeMap(ctx, node) {
@@ -1088,35 +1646,34 @@ function deserializeMap(ctx, node) {
     node.i,
     /* @__PURE__ */ new Map()
   );
-  ctx.stack.push(node.i);
-  for (let i = 0; i < node.d.s; i++) {
+  const keys = node.d.k;
+  const vals = node.d.v;
+  for (let i = 0, len = node.d.s; i < len; i++) {
     result.set(
-      deserializeTree(ctx, node.d.k[i]),
-      deserializeTree(ctx, node.d.v[i])
+      deserializeTree(ctx, keys[i]),
+      deserializeTree(ctx, vals[i])
     );
   }
-  ctx.stack.pop();
   return result;
 }
 function deserializeDictionary(ctx, node, result) {
   if (node.d) {
-    ctx.stack.push(node.i);
     const fields = deserializeProperties(ctx, node.d, {});
-    ctx.stack.pop();
     Object.assign(result, fields);
   }
   return result;
 }
 function deserializeAggregateError(ctx, node) {
-  const result = assignIndexedValue(ctx, node.i, new AggregateError([], invQuote(node.m)));
-  ctx.stack.push(node.i);
-  result.errors = deserializeNodeList(ctx, node, new Array(node.l));
-  ctx.stack.pop();
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    new AggregateError([], deserializeString(node.m))
+  );
   return deserializeDictionary(ctx, node, result);
 }
 function deserializeError(ctx, node) {
   const ErrorConstructor = getErrorConstructor(node.c);
-  const result = assignIndexedValue(ctx, node.i, new ErrorConstructor(invQuote(node.m)));
+  const result = assignIndexedValue(ctx, node.i, new ErrorConstructor(deserializeString(node.m)));
   return deserializeDictionary(ctx, node, result);
 }
 function createDeferred() {
@@ -1130,90 +1687,157 @@ function createDeferred() {
     })
   };
 }
-function deserializePromise(ctx, node) {
+async function deserializePromise(ctx, node) {
   const deferred = createDeferred();
   const result = assignIndexedValue(ctx, node.i, deferred.promise);
   deferred.resolve(deserializeTree(ctx, node.f));
   return result;
 }
+function deserializeArrayBuffer(ctx, node) {
+  const bytes = new Uint8Array(node.s);
+  const result = assignIndexedValue(ctx, node.i, bytes.buffer);
+  return result;
+}
 function deserializeTypedArray(ctx, node) {
   const TypedArray = getTypedArrayConstructor(node.c);
-  const dummy = new TypedArray();
+  const source = deserializeTree(ctx, node.f);
   const result = assignIndexedValue(ctx, node.i, new TypedArray(
-    dummy.buffer,
+    source,
+    node.b,
+    node.l
+  ));
+  return result;
+}
+function deserializeDate(ctx, node) {
+  return assignIndexedValue(ctx, node.i, new Date(node.s));
+}
+function deserializeRegExp(ctx, node) {
+  return assignIndexedValue(ctx, node.i, new RegExp(node.c, node.m));
+}
+function deserializeURL(ctx, node) {
+  return assignIndexedValue(ctx, node.i, new URL(deserializeString(node.s)));
+}
+function deserializeURLSearchParams(ctx, node) {
+  return assignIndexedValue(ctx, node.i, new URLSearchParams(deserializeString(node.s)));
+}
+function deserializeReference(ctx, node) {
+  return assignIndexedValue(ctx, node.i, getReference(deserializeString(node.s)));
+}
+function deserializeDataView(ctx, node) {
+  const source = deserializeTree(ctx, node.f);
+  const result = assignIndexedValue(ctx, node.i, new DataView(
+    source,
+    node.b,
     node.l
   ));
-  for (let i = 0, len = node.s.length; i < len; i++) {
-    result[i] = node.t === 23 /* BigIntTypedArray */ ? BigInt(node.s[i]) : Number(node.s[i]);
+  return result;
+}
+function deserializeBlob(ctx, node) {
+  const source = deserializeTree(ctx, node.f);
+  const result = assignIndexedValue(ctx, node.i, new Blob(
+    [source],
+    { type: deserializeString(node.c) }
+  ));
+  return result;
+}
+function deserializeFile(ctx, node) {
+  const source = deserializeTree(ctx, node.f);
+  const result = assignIndexedValue(ctx, node.i, new File(
+    [source],
+    deserializeString(node.m),
+    { type: deserializeString(node.c), lastModified: node.b }
+  ));
+  return result;
+}
+function deserializeHeaders(ctx, node) {
+  const result = assignIndexedValue(ctx, node.i, new Headers());
+  const keys = node.d.k;
+  const vals = node.d.v;
+  for (let i = 0, len = node.d.s; i < len; i++) {
+    result.set(
+      deserializeString(keys[i]),
+      deserializeTree(ctx, vals[i])
+    );
   }
   return result;
 }
-function deserializeIterable(ctx, node) {
-  const values = [];
-  deserializeNodeList(ctx, node, values);
-  const result = assignIndexedValue(ctx, node.i, {
-    [Symbol.iterator]: () => values.values()
-  });
-  return deserializeDictionary(ctx, node, result);
+function deserializeFormData(ctx, node) {
+  const result = assignIndexedValue(ctx, node.i, new FormData());
+  const keys = node.d.k;
+  const vals = node.d.v;
+  for (let i = 0, len = node.d.s; i < len; i++) {
+    result.set(
+      deserializeString(keys[i]),
+      deserializeTree(ctx, vals[i])
+    );
+  }
+  return result;
+}
+function deserializeBoxed(ctx, node) {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    Object(deserializeTree(ctx, node.f))
+  );
 }
 function deserializeTree(ctx, node) {
   switch (node.t) {
+    case 2 /* Constant */:
+      return deserializeConstant(node);
     case 0 /* Number */:
-    case 2 /* Boolean */:
       return node.s;
     case 1 /* String */:
-      return invQuote(node.s);
-    case 4 /* Undefined */:
-      return void 0;
-    case 3 /* Null */:
-      return null;
-    case 5 /* NegativeZero */:
-      return -0;
-    case 6 /* Infinity */:
-      return Infinity;
-    case 7 /* NegativeInfinity */:
-      return -Infinity;
-    case 8 /* NaN */:
-      return NaN;
-    case 9 /* BigInt */:
+      return deserializeString(node.s);
+    case 3 /* BigInt */:
       return BigInt(node.s);
-    case 10 /* IndexedValue */:
+    case 4 /* IndexedValue */:
       return ctx.valueMap.get(node.i);
-    case 15 /* Array */:
+    case 9 /* Array */:
       return deserializeArray(ctx, node);
-    case 16 /* Object */:
+    case 10 /* Object */:
+    case 11 /* NullConstructor */:
       return deserializeObject(ctx, node);
-    case 17 /* NullConstructor */:
-      return deserializeNullConstructor(ctx, node);
-    case 11 /* Date */:
-      return assignIndexedValue(ctx, node.i, new Date(node.s));
-    case 12 /* RegExp */:
-      return assignIndexedValue(ctx, node.i, new RegExp(node.c, node.m));
-    case 13 /* Set */:
+    case 5 /* Date */:
+      return deserializeDate(ctx, node);
+    case 6 /* RegExp */:
+      return deserializeRegExp(ctx, node);
+    case 7 /* Set */:
       return deserializeSet(ctx, node);
-    case 14 /* Map */:
+    case 8 /* Map */:
       return deserializeMap(ctx, node);
-    case 23 /* BigIntTypedArray */:
-    case 22 /* TypedArray */:
+    case 21 /* ArrayBuffer */:
+      return deserializeArrayBuffer(ctx, node);
+    case 16 /* BigIntTypedArray */:
+    case 15 /* TypedArray */:
       return deserializeTypedArray(ctx, node);
-    case 20 /* AggregateError */:
+    case 22 /* DataView */:
+      return deserializeDataView(ctx, node);
+    case 14 /* AggregateError */:
       return deserializeAggregateError(ctx, node);
-    case 19 /* Error */:
+    case 13 /* Error */:
       return deserializeError(ctx, node);
-    case 21 /* Iterable */:
-      return deserializeIterable(ctx, node);
-    case 18 /* Promise */:
+    case 12 /* Promise */:
       return deserializePromise(ctx, node);
-    case 24 /* WKSymbol */:
+    case 17 /* WKSymbol */:
       return SYMBOL_REF[node.s];
-    case 25 /* URL */:
-      return assignIndexedValue(ctx, node.i, new URL(node.s));
-    case 26 /* URLSearchParams */:
-      return assignIndexedValue(ctx, node.i, new URLSearchParams(node.s));
-    case 27 /* Reference */:
-      return assignIndexedValue(ctx, node.i, getReference(invQuote(node.s)));
+    case 18 /* URL */:
+      return deserializeURL(ctx, node);
+    case 19 /* URLSearchParams */:
+      return deserializeURLSearchParams(ctx, node);
+    case 20 /* Reference */:
+      return deserializeReference(ctx, node);
+    case 23 /* Blob */:
+      return deserializeBlob(ctx, node);
+    case 24 /* File */:
+      return deserializeFile(ctx, node);
+    case 25 /* Headers */:
+      return deserializeHeaders(ctx, node);
+    case 26 /* FormData */:
+      return deserializeFormData(ctx, node);
+    case 27 /* Boxed */:
+      return deserializeBoxed(ctx, node);
     default:
-      throw new Error("Unsupported type");
+      throw new Error("invariant");
   }
 }
 
@@ -1222,10 +1846,12 @@ function getAssignmentExpression(assignment) {
   switch (assignment.t) {
     case "index":
       return assignment.s + "=" + assignment.v;
-    case "map":
-      return assignment.s + ".set(" + assignment.k + "," + assignment.v + ")";
     case "set":
+      return assignment.s + ".set(" + assignment.k + "," + assignment.v + ")";
+    case "add":
       return assignment.s + ".add(" + assignment.v + ")";
+    case "append":
+      return assignment.s + ".append(" + assignment.k + "," + assignment.v + ")";
     default:
       return "";
   }
@@ -1252,10 +1878,10 @@ function mergeAssignments(assignments) {
             current = item;
           }
           break;
-        case "map":
+        case "set":
           if (item.s === prev.s) {
             current = {
-              t: "map",
+              t: "set",
               s: getAssignmentExpression(current),
               k: item.k,
               v: item.v
@@ -1265,10 +1891,10 @@ function mergeAssignments(assignments) {
             current = item;
           }
           break;
-        case "set":
+        case "add":
           if (item.s === prev.s) {
             current = {
-              t: "set",
+              t: "add",
               s: getAssignmentExpression(current),
               k: void 0,
               v: item.v
@@ -1278,6 +1904,10 @@ function mergeAssignments(assignments) {
             current = item;
           }
           break;
+        case "append":
+          newAssignments.push(current);
+          current = item;
+          break;
         default:
           break;
       }
@@ -1312,26 +1942,31 @@ function createAssignment(ctx, source, value) {
     v: value
   });
 }
-function createSetAdd(ctx, ref, value) {
-  markRef(ctx, ref);
+function createAddAssignment(ctx, ref, value) {
   ctx.assignments.push({
-    t: "set",
+    t: "add",
     s: getRefParam(ctx, ref),
     k: void 0,
     v: value
   });
 }
-function createMapSet(ctx, ref, key, value) {
-  markRef(ctx, ref);
+function createSetAssignment(ctx, ref, key, value) {
+  ctx.assignments.push({
+    t: "set",
+    s: getRefParam(ctx, ref),
+    k: key,
+    v: value
+  });
+}
+function createAppendAssignment(ctx, ref, key, value) {
   ctx.assignments.push({
-    t: "map",
+    t: "append",
     s: getRefParam(ctx, ref),
     k: key,
     v: value
   });
 }
 function createArrayAssign(ctx, ref, index, value) {
-  markRef(ctx, ref);
   createAssignment(ctx, getRefParam(ctx, ref) + "[" + index + "]", value);
 }
 function createObjectAssign(ctx, ref, key, value) {
@@ -1345,21 +1980,24 @@ function assignIndexedValue2(ctx, index, value) {
   return value;
 }
 function isIndexedValueInStack(ctx, node) {
-  return node.t === 10 /* IndexedValue */ && ctx.stack.includes(node.i);
+  return node.t === 4 /* IndexedValue */ && ctx.stack.includes(node.i);
 }
-function serializeNodeList(ctx, node) {
-  const size = node.l;
+function serializeArray(ctx, node) {
+  const id = node.i;
+  ctx.stack.push(id);
   let values = "";
   let item;
   let isHoley = false;
-  for (let i = 0; i < size; i++) {
+  const list = node.a;
+  for (let i = 0, len = node.l; i < len; i++) {
     if (i !== 0) {
       values += ",";
     }
-    item = node.a[i];
+    item = list[i];
     if (item) {
       if (isIndexedValueInStack(ctx, item)) {
-        createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
+        markRef(ctx, id);
+        createArrayAssign(ctx, id, i, getRefParam(ctx, item.i));
         isHoley = true;
       } else {
         values += serializeTree(ctx, item);
@@ -1369,16 +2007,29 @@ function serializeNodeList(ctx, node) {
       isHoley = true;
     }
   }
-  return "[" + values + (isHoley ? ",]" : "]");
-}
-function serializeArray(ctx, node) {
-  ctx.stack.push(node.i);
-  const result = serializeNodeList(ctx, node);
   ctx.stack.pop();
-  return assignIndexedValue2(ctx, node.i, result);
+  return assignIndexedValue2(ctx, id, "[" + values + (isHoley ? ",]" : "]"));
+}
+function getIterableAccess(ctx) {
+  return ctx.features & 2 /* ArrayPrototypeValues */ ? ".values()" : "[Symbol.iterator]()";
+}
+function serializeIterable(ctx, node) {
+  const parent = ctx.stack;
+  ctx.stack = [];
+  let serialized = serializeTree(ctx, node) + getIterableAccess(ctx);
+  ctx.stack = parent;
+  if (ctx.features & 4 /* ArrowFunction */) {
+    serialized = "[Symbol.iterator]:()=>" + serialized;
+  } else if (ctx.features & 64 /* MethodShorthand */) {
+    serialized = "[Symbol.iterator](){return " + serialized + "}";
+  } else {
+    serialized = "[Symbol.iterator]:function(){return " + serialized + "}";
+  }
+  return serialized;
 }
 function serializeProperties(ctx, sourceID, node) {
-  if (node.s === 0) {
+  const len = node.s;
+  if (len === 0) {
     return "{}";
   }
   let result = "";
@@ -1389,21 +2040,32 @@ function serializeProperties(ctx, sourceID, node) {
   let isIdentifier;
   let refParam;
   let hasPrev = false;
-  for (let i = 0; i < node.s; i++) {
-    key = node.k[i];
-    val = node.v[i];
-    check = Number(key);
-    isIdentifier = check >= 0 || isValidIdentifier(key);
-    if (isIndexedValueInStack(ctx, val)) {
-      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 += (hasPrev ? "," : "") + (isIdentifier ? key : '"' + quote(key) + '"') + ":" + serializeTree(ctx, val);
-      hasPrev = true;
+  const keys = node.k;
+  const values = node.v;
+  for (let i = 0; i < len; i++) {
+    key = keys[i];
+    val = values[i];
+    switch (key) {
+      case 0 /* SymbolIterator */:
+        result += (hasPrev ? "," : "") + serializeIterable(ctx, val);
+        hasPrev = true;
+        break;
+      default:
+        check = Number(key);
+        isIdentifier = check >= 0 || isValidIdentifier(key);
+        if (isIndexedValueInStack(ctx, val)) {
+          refParam = getRefParam(ctx, val.i);
+          markRef(ctx, sourceID);
+          if (isIdentifier && Number.isNaN(check)) {
+            createObjectAssign(ctx, sourceID, key, refParam);
+          } else {
+            createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + key + '"', refParam);
+          }
+        } else {
+          result += (hasPrev ? "," : "") + (isIdentifier ? key : '"' + key + '"') + ":" + serializeTree(ctx, val);
+          hasPrev = true;
+        }
+        break;
     }
   }
   ctx.stack.pop();
@@ -1419,26 +2081,41 @@ function serializeWithObjectAssign(ctx, value, id, serialized) {
 function serializeAssignments(ctx, sourceID, node) {
   ctx.stack.push(sourceID);
   const mainAssignments = [];
-  let parentStack;
-  let refParam;
   let key;
-  let check;
+  let value;
   let parentAssignment;
-  let isIdentifier;
-  for (let i = 0; i < node.s; i++) {
-    parentStack = ctx.stack;
-    ctx.stack = [];
-    refParam = serializeTree(ctx, node.v[i]);
-    ctx.stack = parentStack;
-    key = node.k[i];
-    check = Number(key);
+  const keys = node.k;
+  const values = node.v;
+  for (let i = 0, len = node.s; i < len; i++) {
+    key = keys[i];
+    value = values[i];
     parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
-    isIdentifier = check >= 0 || isValidIdentifier(key);
-    if (isIdentifier && Number.isNaN(check)) {
-      createObjectAssign(ctx, sourceID, key, refParam);
-    } else {
-      createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + quote(key) + '"', refParam);
+    switch (key) {
+      case 0 /* SymbolIterator */:
+        {
+          const parent = ctx.stack;
+          ctx.stack = [];
+          const serialized = serializeTree(ctx, value) + getIterableAccess(ctx);
+          ctx.stack = parent;
+          createArrayAssign(
+            ctx,
+            sourceID,
+            "Symbol.iterator",
+            ctx.features & 4 /* ArrowFunction */ ? "()=>" + serialized : "function(){return " + serialized + "}"
+          );
+        }
+        break;
+      default: {
+        const serialized = serializeTree(ctx, value);
+        const check = Number(key);
+        const isIdentifier = check >= 0 || isValidIdentifier(key);
+        if (isIdentifier && Number.isNaN(check)) {
+          createObjectAssign(ctx, sourceID, key, serialized);
+        } else {
+          createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + key + '"', serialized);
+        }
+      }
     }
     ctx.assignments = parentAssignment;
   }
@@ -1459,8 +2136,9 @@ function serializeDictionary(ctx, i, d, init) {
   }
   return assignIndexedValue2(ctx, i, init);
 }
+var NULL_CONSTRUCTOR = "Object.create(null)";
 function serializeNullConstructor(ctx, node) {
-  return serializeDictionary(ctx, node.i, node.d, "Object.create(null)");
+  return serializeDictionary(ctx, node.i, node.d, NULL_CONSTRUCTOR);
 }
 function serializeObject(ctx, node) {
   return assignIndexedValue2(ctx, node.i, serializeProperties(ctx, node.i, node.d));
@@ -1468,15 +2146,18 @@ function serializeObject(ctx, node) {
 function serializeSet(ctx, node) {
   let serialized = "new Set";
   const size = node.l;
+  const id = node.i;
   if (size) {
     let result = "";
-    ctx.stack.push(node.i);
     let item;
     let hasPrev = false;
+    const items = node.a;
+    ctx.stack.push(id);
     for (let i = 0; i < size; i++) {
-      item = node.a[i];
+      item = items[i];
       if (isIndexedValueInStack(ctx, item)) {
-        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
+        markRef(ctx, id);
+        createAddAssignment(ctx, id, getRefParam(ctx, item.i));
       } else {
         result += (hasPrev ? "," : "") + serializeTree(ctx, item);
         hasPrev = true;
@@ -1487,38 +2168,44 @@ function serializeSet(ctx, node) {
       serialized += "([" + result + "])";
     }
   }
-  return assignIndexedValue2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, id, serialized);
 }
 function serializeMap(ctx, node) {
   let serialized = "new Map";
-  if (node.d.s) {
+  const size = node.d.s;
+  const id = node.i;
+  if (size) {
     let result = "";
-    ctx.stack.push(node.i);
     let key;
     let val;
     let keyRef;
     let valueRef;
     let parent;
     let hasPrev = false;
-    for (let i = 0; i < node.d.s; i++) {
-      key = node.d.k[i];
-      val = node.d.v[i];
+    const keys = node.d.k;
+    const vals = node.d.v;
+    ctx.stack.push(id);
+    for (let i = 0; i < size; i++) {
+      key = keys[i];
+      val = vals[i];
       if (isIndexedValueInStack(ctx, key)) {
-        keyRef = getRefParam(ctx, key.i);
+        keyRef = getRefParam(ctx, id);
+        markRef(ctx, id);
         if (isIndexedValueInStack(ctx, val)) {
           valueRef = getRefParam(ctx, val.i);
-          createMapSet(ctx, node.i, keyRef, valueRef);
+          createSetAssignment(ctx, id, keyRef, valueRef);
         } else {
           parent = ctx.stack;
           ctx.stack = [];
-          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
+          createSetAssignment(ctx, id, keyRef, serializeTree(ctx, val));
           ctx.stack = parent;
         }
       } else if (isIndexedValueInStack(ctx, val)) {
         valueRef = getRefParam(ctx, val.i);
+        markRef(ctx, id);
         parent = ctx.stack;
         ctx.stack = [];
-        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
+        createSetAssignment(ctx, id, serializeTree(ctx, key), valueRef);
         ctx.stack = parent;
       } else {
         result += (hasPrev ? ",[" : "[") + serializeTree(ctx, key) + "," + serializeTree(ctx, val) + "]";
@@ -1530,63 +2217,142 @@ function serializeMap(ctx, node) {
       serialized += "([" + result + "])";
     }
   }
-  return assignIndexedValue2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, id, serialized);
 }
 function serializeAggregateError(ctx, node) {
-  ctx.stack.push(node.i);
-  const serialized = "new AggregateError(" + serializeNodeList(ctx, node) + ',"' + quote(node.m) + '")';
+  const id = node.i;
+  ctx.stack.push(id);
+  const serialized = 'new AggregateError([],"' + node.m + '")';
   ctx.stack.pop();
-  return serializeDictionary(ctx, node.i, node.d, serialized);
+  return serializeDictionary(ctx, id, node.d, serialized);
 }
 function serializeError(ctx, node) {
-  const serialized = "new " + node.c + '("' + quote(node.m) + '")';
-  return serializeDictionary(ctx, node.i, node.d, serialized);
+  return serializeDictionary(ctx, node.i, node.d, "new " + node.c + '("' + node.m + '")');
 }
 function serializePromise(ctx, node) {
   let serialized;
-  if (isIndexedValueInStack(ctx, node.f)) {
-    const ref = getRefParam(ctx, node.f.i);
+  const fulfilled = node.f;
+  const id = node.i;
+  if (isIndexedValueInStack(ctx, fulfilled)) {
+    const ref = getRefParam(ctx, fulfilled.i);
     if (ctx.features & 4 /* ArrowFunction */) {
       serialized = "Promise.resolve().then(()=>" + ref + ")";
     } else {
       serialized = "Promise.resolve().then(function(){return " + ref + "})";
     }
   } else {
-    ctx.stack.push(node.i);
-    const result = serializeTree(ctx, node.f);
+    ctx.stack.push(id);
+    const result = serializeTree(ctx, fulfilled);
     ctx.stack.pop();
     serialized = "Promise.resolve(" + result + ")";
   }
-  return assignIndexedValue2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, id, serialized);
+}
+function serializeArrayBuffer2(ctx, node) {
+  let result = "new Uint8Array(";
+  const buffer = node.s;
+  const len = buffer.length;
+  if (len) {
+    result += "[";
+    for (let i = 0; i < len; i++) {
+      result += (i > 0 ? "," : "") + buffer[i];
+    }
+    result += "]";
+  }
+  return assignIndexedValue2(ctx, node.i, result + ").buffer");
 }
 function serializeTypedArray(ctx, node) {
-  let result = "";
-  const isBigInt = node.t === 23 /* BigIntTypedArray */;
-  for (let i = 0, len = node.s.length; i < len; i++) {
-    result += (i !== 0 ? "," : "") + node.s[i] + (isBigInt ? "n" : "");
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    "new " + node.c + "(" + serializeTree(ctx, node.f) + "," + node.b + "," + node.l + ")"
+  );
+}
+function serializeDate(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, 'new Date("' + node.s + '")');
+}
+function serializeRegExp(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, "/" + node.c + "/" + node.m);
+}
+function serializeURL(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, 'new URL("' + node.s + '")');
+}
+function serializeURLSearchParams(ctx, node) {
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    node.s ? 'new URLSearchParams("' + node.s + '")' : "new URLSearchParams"
+  );
+}
+function serializeReference(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, GLOBAL_KEY + '.get("' + node.s + '")');
+}
+function serializeDataView(ctx, node) {
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    "new DataView(" + serializeTree(ctx, node.f) + "," + node.b + "," + node.l + ")"
+  );
+}
+function serializeBlob(ctx, node) {
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    "new Blob([" + serializeTree(ctx, node.f) + '],{type:"' + node.c + '"})'
+  );
+}
+function serializeFile(ctx, node) {
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    "new File([" + serializeTree(ctx, node.f) + '],"' + node.m + '",{type:"' + node.c + '",lastModified:' + node.b + "})"
+  );
+}
+function serializeHeaders(ctx, node) {
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    "new Headers(" + serializeProperties(ctx, node.i, node.d) + ")"
+  );
+}
+function serializeFormDataEntries(ctx, node) {
+  let value;
+  let key;
+  const keys = node.d.k;
+  const vals = node.d.v;
+  const id = node.i;
+  const mainAssignments = [];
+  let parentAssignment;
+  ctx.stack.push(id);
+  for (let i = 0, len = node.d.s; i < len; i++) {
+    key = keys[i];
+    value = serializeTree(ctx, vals[i]);
+    parentAssignment = ctx.assignments;
+    ctx.assignments = mainAssignments;
+    createAppendAssignment(ctx, id, '"' + key + '"', value);
+    ctx.assignments = parentAssignment;
   }
-  const args = "[" + result + "]" + (node.l !== 0 ? "," + node.l : "");
-  return assignIndexedValue2(ctx, node.i, "new " + node.c + "(" + args + ")");
+  ctx.stack.pop();
+  return resolveAssignments(mainAssignments);
 }
-function serializeIterable(ctx, node) {
-  const parent = ctx.stack;
-  ctx.stack = [];
-  const values = serializeNodeList(ctx, node);
-  ctx.stack = parent;
-  let serialized = values;
-  if (ctx.features & 2 /* ArrayPrototypeValues */) {
-    serialized += ".values()";
-  } else {
-    serialized += "[Symbol.iterator]()";
+function serializeFormData(ctx, node) {
+  const size = node.d.s;
+  const id = node.i;
+  if (size) {
+    markRef(ctx, id);
   }
-  if (ctx.features & 4 /* ArrowFunction */) {
-    serialized = "{[Symbol.iterator]:()=>" + serialized + "}";
-  } else if (ctx.features & 64 /* MethodShorthand */) {
-    serialized = "{[Symbol.iterator](){return " + serialized + "}}";
-  } else {
-    serialized = "{[Symbol.iterator]:function(){return " + serialized + "}}";
+  const result = assignIndexedValue2(ctx, id, "new FormData()");
+  if (size) {
+    const entries = serializeFormDataEntries(ctx, node);
+    return "(" + result + "," + (entries == null ? "" : entries) + getRefParam(ctx, id) + ")";
   }
-  return serializeDictionary(ctx, node.i, node.d, serialized);
+  return result;
+}
+function serializeBoxed(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, "Object(" + serializeTree(ctx, node.f) + ")");
+}
+function serializeWKSymbol(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, SYMBOL_STRING[node.s]);
 }
 function serializeTree(ctx, node) {
   switch (node.t) {
@@ -1594,393 +2360,61 @@ function serializeTree(ctx, node) {
       return "" + node.s;
     case 1 /* String */:
       return '"' + node.s + '"';
-    case 2 /* Boolean */:
-      return node.s ? "!0" : "!1";
-    case 4 /* Undefined */:
-      return "void 0";
-    case 3 /* Null */:
-      return "null";
-    case 5 /* NegativeZero */:
-      return "-0";
-    case 6 /* Infinity */:
-      return "1/0";
-    case 7 /* NegativeInfinity */:
-      return "-1/0";
-    case 8 /* NaN */:
-      return "NaN";
-    case 9 /* BigInt */:
+    case 2 /* Constant */:
+      return serializeConstant(node);
+    case 3 /* BigInt */:
       return node.s + "n";
-    case 10 /* IndexedValue */:
+    case 4 /* IndexedValue */:
       return getRefParam(ctx, node.i);
-    case 15 /* Array */:
+    case 9 /* Array */:
       return serializeArray(ctx, node);
-    case 16 /* Object */:
+    case 10 /* Object */:
       return serializeObject(ctx, node);
-    case 17 /* NullConstructor */:
+    case 11 /* NullConstructor */:
       return serializeNullConstructor(ctx, node);
-    case 11 /* Date */:
-      return assignIndexedValue2(ctx, node.i, 'new Date("' + node.s + '")');
-    case 12 /* RegExp */:
-      return assignIndexedValue2(ctx, node.i, "/" + node.c + "/" + node.m);
-    case 13 /* Set */:
+    case 5 /* Date */:
+      return serializeDate(ctx, node);
+    case 6 /* RegExp */:
+      return serializeRegExp(ctx, node);
+    case 7 /* Set */:
       return serializeSet(ctx, node);
-    case 14 /* Map */:
+    case 8 /* Map */:
       return serializeMap(ctx, node);
-    case 23 /* BigIntTypedArray */:
-    case 22 /* TypedArray */:
+    case 21 /* ArrayBuffer */:
+      return serializeArrayBuffer2(ctx, node);
+    case 16 /* BigIntTypedArray */:
+    case 15 /* TypedArray */:
       return serializeTypedArray(ctx, node);
-    case 20 /* AggregateError */:
+    case 22 /* DataView */:
+      return serializeDataView(ctx, node);
+    case 14 /* AggregateError */:
       return serializeAggregateError(ctx, node);
-    case 19 /* Error */:
+    case 13 /* Error */:
       return serializeError(ctx, node);
-    case 21 /* Iterable */:
-      return serializeIterable(ctx, node);
-    case 18 /* Promise */:
+    case 12 /* Promise */:
       return serializePromise(ctx, node);
-    case 24 /* WKSymbol */:
-      return SYMBOL_STRING[node.s];
-    case 25 /* URL */:
-      return assignIndexedValue2(ctx, node.i, 'new URL("' + node.s + '")');
-    case 26 /* URLSearchParams */:
-      return assignIndexedValue2(ctx, node.i, node.s ? 'new URLSearchParams("' + node.s + '")' : "new URLSearchParams");
-    case 27 /* Reference */:
-      return assignIndexedValue2(ctx, node.i, GLOBAL_KEY + '.get("' + node.s + '")');
-    default:
-      throw new Error("Unsupported type");
-  }
-}
-
-// src/tree/sync.ts
-function generateNodeList2(ctx, current) {
-  const size = current.length;
-  const nodes = new Array(size);
-  const deferred = new Array(size);
-  let item;
-  for (let i = 0; i < size; i++) {
-    if (i in current) {
-      item = current[i];
-      if (isIterable(item)) {
-        deferred[i] = item;
-      } else {
-        nodes[i] = parse2(ctx, item);
-      }
-    }
-  }
-  for (let i = 0; i < size; i++) {
-    if (i in deferred) {
-      nodes[i] = parse2(ctx, deferred[i]);
-    }
-  }
-  return nodes;
-}
-function generateArrayNode2(ctx, id, current) {
-  return {
-    t: 15 /* Array */,
-    i: id,
-    s: void 0,
-    l: current.length,
-    c: void 0,
-    m: void 0,
-    d: void 0,
-    a: generateNodeList2(ctx, current),
-    f: void 0
-  };
-}
-function generateMapNode2(ctx, id, current) {
-  assert(ctx.features & 32 /* 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] = parse2(ctx, key);
-      valueNodes[nodeSize] = parse2(ctx, value);
-      nodeSize++;
-    }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodeSize + i] = parse2(ctx, deferredKey[i]);
-    valueNodes[nodeSize + i] = parse2(ctx, deferredValue[i]);
-  }
-  return {
-    t: 14 /* Map */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    d: { k: keyNodes, v: valueNodes, s: len },
-    a: void 0,
-    f: void 0
-  };
-}
-function generateSetNode2(ctx, id, current) {
-  assert(ctx.features & 512 /* 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++] = parse2(ctx, item);
-    }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    nodes[nodeSize + i] = parse2(ctx, deferred[i]);
-  }
-  return {
-    t: 13 /* Set */,
-    i: id,
-    s: void 0,
-    l: len,
-    c: void 0,
-    m: void 0,
-    d: void 0,
-    a: nodes,
-    f: void 0
-  };
-}
-function generateProperties2(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;
-  let item;
-  for (const key of keys) {
-    item = properties[key];
-    if (isIterable(item)) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = item;
-      deferredSize++;
-    } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = parse2(ctx, item);
-      nodesSize++;
-    }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodesSize + i] = deferredKeys[i];
-    valueNodes[nodesSize + i] = parse2(ctx, deferredValues[i]);
-  }
-  return {
-    k: keyNodes,
-    v: valueNodes,
-    s: size
-  };
-}
-function generateIterableNode2(ctx, id, current) {
-  assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "Iterable"');
-  const options = getIterableOptions(current);
-  const array = Array.from(current);
-  return {
-    t: 21 /* Iterable */,
-    i: id,
-    s: void 0,
-    l: array.length,
-    c: void 0,
-    m: void 0,
-    // Parse options first before the items
-    d: options ? generateProperties2(ctx, options) : void 0,
-    a: generateNodeList2(ctx, array),
-    f: void 0
-  };
-}
-function generateObjectNode2(ctx, id, current, empty) {
-  if (Symbol.iterator in current) {
-    return generateIterableNode2(ctx, id, current);
-  }
-  return {
-    t: empty ? 17 /* NullConstructor */ : 16 /* Object */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    d: generateProperties2(ctx, current),
-    a: void 0,
-    f: void 0
-  };
-}
-function generateAggregateErrorNode2(ctx, id, current) {
-  const options = getErrorOptions(ctx, current);
-  const optionsNode = options ? generateProperties2(ctx, options) : void 0;
-  return {
-    t: 20 /* AggregateError */,
-    i: id,
-    s: void 0,
-    l: current.errors.length,
-    c: void 0,
-    m: quote(current.message),
-    d: optionsNode,
-    a: generateNodeList2(ctx, current.errors),
-    f: void 0
-  };
-}
-function generateErrorNode2(ctx, id, current) {
-  const options = getErrorOptions(ctx, current);
-  const optionsNode = options ? generateProperties2(ctx, options) : void 0;
-  return {
-    t: 19 /* Error */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    c: getErrorConstructorName(current),
-    m: quote(current.message),
-    d: optionsNode,
-    a: void 0,
-    f: void 0
-  };
-}
-function parse2(ctx, current) {
-  switch (typeof current) {
-    case "boolean":
-      return current ? TRUE_NODE : FALSE_NODE;
-    case "undefined":
-      return UNDEFINED_NODE;
-    case "string":
-      return createStringNode(current);
-    case "number":
-      switch (current) {
-        case Infinity:
-          return INFINITY_NODE;
-        case -Infinity:
-          return NEG_INFINITY_NODE;
-        default:
-          if (current !== current) {
-            return NAN_NODE;
-          }
-          if (Object.is(current, -0)) {
-            return NEG_ZERO_NODE;
-          }
-          return createNumberNode(current);
-      }
-    case "bigint":
-      return createBigIntNode(ctx, current);
-    case "object": {
-      if (!current) {
-        return NULL_NODE;
-      }
-      const id = createIndexedValue(ctx, current);
-      if (ctx.markedRefs.has(id)) {
-        return createIndexedValueNode(id);
-      }
-      if (hasReferenceID(current)) {
-        return createReferenceNode(id, current);
-      }
-      if (Array.isArray(current)) {
-        return generateArrayNode2(ctx, id, current);
-      }
-      switch (current.constructor) {
-        case Date:
-          return createDateNode(id, current);
-        case RegExp:
-          return createRegExpNode(id, current);
-        case Int8Array:
-        case Int16Array:
-        case Int32Array:
-        case Uint8Array:
-        case Uint16Array:
-        case Uint32Array:
-        case Uint8ClampedArray:
-        case Float32Array:
-        case Float64Array:
-          return createTypedArrayNode(ctx, id, current);
-        case BigInt64Array:
-        case BigUint64Array:
-          return createBigIntTypedArrayNode(ctx, id, current);
-        case Map:
-          return generateMapNode2(ctx, id, current);
-        case Set:
-          return generateSetNode2(ctx, id, current);
-        case Object:
-          return generateObjectNode2(
-            ctx,
-            id,
-            current,
-            false
-          );
-        case void 0:
-          return generateObjectNode2(
-            ctx,
-            id,
-            current,
-            true
-          );
-        case AggregateError:
-          if (ctx.features & 1 /* AggregateError */) {
-            return generateAggregateErrorNode2(ctx, id, current);
-          }
-          return generateErrorNode2(ctx, id, current);
-        case Error:
-        case EvalError:
-        case RangeError:
-        case ReferenceError:
-        case SyntaxError:
-        case TypeError:
-        case URIError:
-          return generateErrorNode2(ctx, id, current);
-        case URL:
-          return createURLNode(ctx, id, current);
-        case URLSearchParams:
-          return createURLSearchParamsNode(ctx, id, current);
-        default:
-          break;
-      }
-      if (current instanceof AggregateError) {
-        if (ctx.features & 1 /* AggregateError */) {
-          return generateAggregateErrorNode2(ctx, id, current);
-        }
-        return generateErrorNode2(ctx, id, current);
-      }
-      if (current instanceof Error) {
-        return generateErrorNode2(ctx, id, current);
-      }
-      if (Symbol.iterator in current) {
-        return generateIterableNode2(ctx, id, current);
-      }
-      throw new Error("Unsupported type");
-    }
-    case "symbol":
-      if (hasReferenceID(current)) {
-        const id = createIndexedValue(ctx, current);
-        if (ctx.markedRefs.has(id)) {
-          return createIndexedValueNode(id);
-        }
-        return createReferenceNode(id, current);
-      }
-      return createWKSymbolNode(ctx, current);
-    case "function": {
-      assert(hasReferenceID(current), "Cannot serialize function without reference ID.");
-      const id = createIndexedValue(ctx, current);
-      if (ctx.markedRefs.has(id)) {
-        return createIndexedValueNode(id);
-      }
-      return createReferenceNode(id, current);
-    }
+    case 17 /* WKSymbol */:
+      return serializeWKSymbol(ctx, node);
+    case 18 /* URL */:
+      return serializeURL(ctx, node);
+    case 19 /* URLSearchParams */:
+      return serializeURLSearchParams(ctx, node);
+    case 20 /* Reference */:
+      return serializeReference(ctx, node);
+    case 23 /* Blob */:
+      return serializeBlob(ctx, node);
+    case 24 /* File */:
+      return serializeFile(ctx, node);
+    case 25 /* Headers */:
+      return serializeHeaders(ctx, node);
+    case 26 /* FormData */:
+      return serializeFormData(ctx, node);
+    case 27 /* Boxed */:
+      return serializeBoxed(ctx, node);
     default:
-      throw new Error("Unsupported type");
+      throw new Error("invariant");
   }
 }
-function parseSync(ctx, current) {
-  const result = parse2(ctx, current);
-  const isObject = result.t === 16 /* Object */ || result.t === 21 /* Iterable */;
-  return [result, getRootID(ctx, current), isObject];
-}
 
 // src/index.ts
 function finalize(ctx, rootID, isObject, result) {
@@ -2008,39 +2442,45 @@ function finalize(ctx, rootID, isObject, result) {
 }
 function serialize(source, options) {
   const ctx = createParserContext(options);
-  const [tree, rootID, isObject] = parseSync(ctx, source);
+  const tree = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
-  return finalize(serial, rootID, isObject, result);
+  return finalize(
+    serial,
+    getRootID(ctx, source),
+    tree.t === 10 /* Object */,
+    result
+  );
 }
 async function serializeAsync(source, options) {
   const ctx = createParserContext(options);
-  const [tree, rootID, isObject] = await parseAsync(ctx, source);
+  const tree = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
-  return finalize(serial, rootID, isObject, result);
+  return finalize(
+    serial,
+    getRootID(ctx, source),
+    tree.t === 10 /* Object */,
+    result
+  );
 }
 function deserialize(source) {
   return (0, eval)(source);
 }
 function toJSON(source, options) {
   const ctx = createParserContext(options);
-  const [tree, root, isObject] = parseSync(ctx, source);
   return {
-    t: tree,
-    r: root,
-    i: isObject,
+    t: parseSync(ctx, source),
+    r: getRootID(ctx, source),
     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 {
-    t: tree,
-    r: root,
-    i: isObject,
+    t: await parseAsync(ctx, source),
+    r: getRootID(ctx, source),
     f: ctx.features,
     m: Array.from(ctx.markedRefs)
   };
@@ -2051,7 +2491,7 @@ function compileJSON(source) {
     markedRefs: source.m
   });
   const result = serializeTree(serial, source.t);
-  return finalize(serial, source.r, source.i, result);
+  return finalize(serial, source.r, source.t.i === 10 /* Object */, result);
 }
 function fromJSON(source) {
   const serial = createSerializationContext({