seroval 0.5.1 → 0.7.0

package/dist/esm/development/index.mjs

@@ -13,9 +13,10 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
   Feature2[Feature2["Symbol"] = 1024] = "Symbol";
   Feature2[Feature2["TypedArray"] = 2048] = "TypedArray";
   Feature2[Feature2["BigIntTypedArray"] = 4096] = "BigIntTypedArray";
+  Feature2[Feature2["WebAPI"] = 8192] = "WebAPI";
   return Feature2;
 })(Feature || {});
-var ALL_ENABLED = 8191;
+var ALL_ENABLED = 16383;
 
 // src/get-identifier.ts
 var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
@@ -81,7 +82,7 @@ function getRootID(ctx, current) {
   }
   return ref;
 }
-function createRef(ctx, current) {
+function createIndexedValue(ctx, current) {
   const ref = ctx.refs.get(current);
   if (ref == null) {
     const id = ctx.refs.size;
@@ -99,39 +100,43 @@ function assert(cond, 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;
@@ -140,8 +145,61 @@ 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/reference.ts
+var REFERENCE = /* @__PURE__ */ new Map();
+var INV_REFERENCE = /* @__PURE__ */ new Map();
+function createReference(id, value) {
+  REFERENCE.set(value, id);
+  INV_REFERENCE.set(id, value);
+  return value;
+}
+function hasReferenceID(value) {
+  return REFERENCE.has(value);
+}
+function hasReference(id) {
+  return INV_REFERENCE.has(id);
+}
+function getReferenceID(value) {
+  assert(hasReferenceID(value), "Missing reference id");
+  return REFERENCE.get(value);
+}
+function getReference(id) {
+  assert(hasReference(id), "Missing reference for id:" + id);
+  return INV_REFERENCE.get(id);
+}
+var GLOBAL_KEY = "__SEROVAL__";
+if (typeof globalThis !== void 0) {
+  Object.defineProperty(globalThis, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+} else if (typeof window !== void 0) {
+  Object.defineProperty(window, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+} else if (typeof self !== void 0) {
+  Object.defineProperty(self, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+} else if (typeof global !== void 0) {
+  Object.defineProperty(global, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
 }
 
 // src/tree/symbols.ts
@@ -201,7 +259,8 @@ var TRUE_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  f: void 0
+  f: void 0,
+  b: void 0
 };
 var FALSE_NODE = {
   t: 2 /* Boolean */,
@@ -212,7 +271,8 @@ var FALSE_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  f: void 0
+  f: void 0,
+  b: void 0
 };
 var UNDEFINED_NODE = {
   t: 4 /* Undefined */,
@@ -223,7 +283,8 @@ var UNDEFINED_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  f: void 0
+  f: void 0,
+  b: void 0
 };
 var NULL_NODE = {
   t: 3 /* Null */,
@@ -234,7 +295,8 @@ var NULL_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  f: void 0
+  f: void 0,
+  b: void 0
 };
 var NEG_ZERO_NODE = {
   t: 5 /* NegativeZero */,
@@ -245,7 +307,8 @@ var NEG_ZERO_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  f: void 0
+  f: void 0,
+  b: void 0
 };
 var INFINITY_NODE = {
   t: 6 /* Infinity */,
@@ -256,7 +319,8 @@ var INFINITY_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  f: void 0
+  f: void 0,
+  b: void 0
 };
 var NEG_INFINITY_NODE = {
   t: 7 /* NegativeInfinity */,
@@ -267,7 +331,8 @@ var NEG_INFINITY_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  f: void 0
+  f: void 0,
+  b: void 0
 };
 var NAN_NODE = {
   t: 8 /* NaN */,
@@ -278,7 +343,8 @@ var NAN_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  f: void 0
+  f: void 0,
+  b: void 0
 };
 function createNumberNode(value) {
   return {
@@ -290,20 +356,22 @@ function createNumberNode(value) {
     m: void 0,
     d: void 0,
     a: void 0,
-    f: 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) {
@@ -317,12 +385,13 @@ function createBigIntNode(ctx, current) {
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
-function createReferenceNode(id) {
+function createIndexedValueNode(id) {
   return {
-    t: 10 /* Reference */,
+    t: 10 /* IndexedValue */,
     i: id,
     s: void 0,
     l: void 0,
@@ -330,7 +399,8 @@ function createReferenceNode(id) {
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function createDateNode(id, current) {
@@ -343,7 +413,8 @@ 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) {
@@ -356,27 +427,51 @@ 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: 28 /* ArrayBuffer */,
     i: id,
     s: values,
-    l: current.byteOffset,
+    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) {
+  const constructor = current.constructor.name;
+  assert(ctx.features & 2048 /* TypedArray */, `Unsupported value type "${constructor}"`);
+  return {
+    t: 22 /* TypedArray */,
+    i: id,
+    s: void 0,
+    l: current.length,
     c: constructor,
     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 */;
@@ -386,24 +481,22 @@ function createBigIntTypedArrayNode(ctx, id, current) {
     (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
     `Unsupported value type "${constructor}"`
   );
-  const len = current.length;
-  const values = new Array(len);
-  for (let i = 0; i < len; i++) {
-    values[i] = "" + current[i];
-  }
   return {
     t: 23 /* BigIntTypedArray */,
     i: id,
-    s: values,
-    l: current.byteOffset,
+    s: void 0,
+    l: current.length,
     c: constructor,
     m: void 0,
     d: void 0,
     a: void 0,
-    f: void 0
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset
   };
 }
-function createWKSymbolNode(current) {
+function createWKSymbolNode(ctx, current) {
+  assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "symbol"');
+  assert(current in INV_SYMBOL_REF, "seroval only supports well-known symbols");
   return {
     t: 24 /* WKSymbol */,
     i: void 0,
@@ -413,7 +506,36 @@ function createWKSymbolNode(current) {
     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 */,
+    i: id,
+    s: serializeString(getReferenceID(ref)),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+function createDataViewNode(ctx, id, current) {
+  return {
+    t: 29 /* 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
   };
 }
 
@@ -555,6 +677,68 @@ function isValidIdentifier(name) {
   return (char === "$" || char === "_" || char >= "A" && char <= "Z" || char >= "a" && char <= "z") && IDENTIFIER_CHECK.test(name);
 }
 
+// src/tree/web-api.ts
+function createURLNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "URL"');
+  return {
+    t: 25 /* URL */,
+    i: id,
+    s: serializeString(current.href),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    f: void 0,
+    a: void 0,
+    b: void 0
+  };
+}
+function createURLSearchParamsNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "URLSearchParams"');
+  return {
+    t: 26 /* URLSearchParams */,
+    i: id,
+    s: serializeString(current.toString()),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    f: void 0,
+    a: void 0,
+    b: void 0
+  };
+}
+async function createBlobNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "Blob"');
+  return {
+    t: 30 /* 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 */, 'Unsupported type "File"');
+  return {
+    t: 31 /* 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) {
   const size = current.length;
@@ -588,7 +772,8 @@ async function generateArrayNode(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: await generateNodeList(ctx, current),
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 async function generateMapNode(ctx, id, current) {
@@ -624,7 +809,8 @@ 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) {
@@ -653,7 +839,8 @@ async function generateSetNode(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: nodes,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 async function generateProperties(ctx, properties) {
@@ -666,14 +853,16 @@ 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;
+      keyNodes[nodesSize] = escaped;
       valueNodes[nodesSize] = await parse(ctx, item);
       nodesSize++;
     }
@@ -702,7 +891,8 @@ async function generateIterableNode(ctx, id, current) {
     // Parse options first before the items
     d: options ? await generateProperties(ctx, options) : void 0,
     a: await generateNodeList(ctx, array),
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 async function generatePromiseNode(ctx, id, current) {
@@ -717,7 +907,8 @@ async function generatePromiseNode(ctx, id, current) {
     // Parse options first before the items
     d: void 0,
     a: void 0,
-    f: await parse(ctx, value)
+    f: await parse(ctx, value),
+    b: void 0
   }));
 }
 async function generateObjectNode(ctx, id, current, empty) {
@@ -736,7 +927,8 @@ async function generateObjectNode(ctx, id, current, empty) {
     m: void 0,
     d: await generateProperties(ctx, current),
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 async function generateAggregateErrorNode(ctx, id, current) {
@@ -746,12 +938,13 @@ async function generateAggregateErrorNode(ctx, id, current) {
     t: 20 /* AggregateError */,
     i: id,
     s: void 0,
-    l: current.errors.length,
+    l: void 0,
     c: void 0,
-    m: current.message,
+    m: serializeString(current.message),
     d: optionsNode,
-    a: await generateNodeList(ctx, current.errors),
-    f: void 0
+    a: void 0,
+    f: void 0,
+    b: void 0
   };
 }
 async function generateErrorNode(ctx, id, current) {
@@ -763,10 +956,49 @@ async function generateErrorNode(ctx, id, current) {
     s: void 0,
     l: void 0,
     c: getErrorConstructorName(current),
-    m: current.message,
+    m: serializeString(current.message),
     d: optionsNode,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateHeadersNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "Headers"');
+  const items = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: 32 /* Headers */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: await generateProperties(ctx, items),
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+async function generateFormDataNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "FormData"');
+  const items = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: 33 /* FormData */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: await generateProperties(ctx, items),
+    a: void 0,
+    f: void 0,
+    b: void 0
   };
 }
 async function parse(ctx, current) {
@@ -784,24 +1016,26 @@ async function parse(ctx, current) {
         case -Infinity:
           return NEG_INFINITY_NODE;
         default:
-          break;
-      }
-      if (current !== current) {
-        return NAN_NODE;
-      }
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
+          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 = createRef(ctx, current);
+      const id = createIndexedValue(ctx, current);
       if (ctx.markedRefs.has(id)) {
-        return createReferenceNode(id);
+        return createIndexedValueNode(id);
+      }
+      if (hasReferenceID(current)) {
+        return createReferenceNode(id, current);
       }
       if (Array.isArray(current)) {
         return generateArrayNode(ctx, id, current);
@@ -813,6 +1047,8 @@ async function parse(ctx, current) {
           return createRegExpNode(id, current);
         case Promise:
           return generatePromiseNode(ctx, id, current);
+        case ArrayBuffer:
+          return createArrayBufferNode(id, current);
         case Int8Array:
         case Int16Array:
         case Int32Array:
@@ -826,6 +1062,8 @@ async function parse(ctx, current) {
         case BigInt64Array:
         case BigUint64Array:
           return createBigIntTypedArrayNode(ctx, id, current);
+        case DataView:
+          return createDataViewNode(ctx, id, current);
         case Map:
           return generateMapNode(
             ctx,
@@ -865,6 +1103,18 @@ async function parse(ctx, current) {
         case TypeError:
         case URIError:
           return generateErrorNode(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 generateHeadersNode(ctx, id, current);
+        case FormData:
+          return generateFormDataNode(ctx, id, current);
         default:
           break;
       }
@@ -889,9 +1139,22 @@ async function parse(ctx, current) {
       throw new Error("Unsupported type");
     }
     case "symbol":
-      assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "symbol"');
-      assert(current in INV_SYMBOL_REF, "seroval only supports well-known symbols");
-      return createWKSymbolNode(current);
+      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);
+    }
     default:
       throw new Error("Unsupported type");
   }
@@ -903,13 +1166,20 @@ async function parseAsync(ctx, current) {
 }
 
 // src/tree/deserialize.ts
-function assignRef(ctx, index, value) {
-  ctx.valueMap.set(index, value);
+function assignIndexedValue(ctx, index, value) {
+  if (ctx.markedRefs.has(index)) {
+    ctx.valueMap.set(index, value);
+  }
   return value;
 }
-function deserializeNodeList(ctx, node, result) {
+function deserializeArray(ctx, node) {
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    new Array(node.l)
+  );
   let item;
-  for (let i = 0, len = node.a.length; i < len; i++) {
+  for (let i = 0, len = node.l; i < len; i++) {
     item = node.a[i];
     if (item) {
       result[i] = deserializeTree(ctx, item);
@@ -917,84 +1187,68 @@ function deserializeNodeList(ctx, node, result) {
   }
   return result;
 }
-function deserializeArray(ctx, node) {
-  const result = assignRef(
-    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]);
+    result[deserializeString(node.k[i])] = deserializeTree(ctx, node.v[i]);
   }
   return result;
 }
 function deserializeNullConstructor(ctx, node) {
-  const result = assignRef(ctx, node.i, /* @__PURE__ */ Object.create(null));
-  ctx.stack.push(node.i);
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    /* @__PURE__ */ Object.create(null)
+  );
   deserializeProperties(ctx, node.d, result);
-  ctx.stack.pop();
   return result;
 }
 function deserializeObject(ctx, node) {
-  const result = assignRef(ctx, node.i, {});
-  ctx.stack.push(node.i);
+  const result = assignIndexedValue(ctx, node.i, {});
   deserializeProperties(ctx, node.d, result);
-  ctx.stack.pop();
   return result;
 }
 function deserializeSet(ctx, node) {
-  const result = assignRef(ctx, node.i, /* @__PURE__ */ new Set());
-  ctx.stack.push(node.i);
-  for (let i = 0, len = node.a.length; i < len; i++) {
+  const result = assignIndexedValue(ctx, node.i, /* @__PURE__ */ new Set());
+  for (let i = 0, len = node.l; i < len; i++) {
     result.add(deserializeTree(ctx, node.a[i]));
   }
-  ctx.stack.pop();
   return result;
 }
 function deserializeMap(ctx, node) {
-  const result = assignRef(
+  const result = assignIndexedValue(
     ctx,
     node.i,
     /* @__PURE__ */ new Map()
   );
-  ctx.stack.push(node.i);
-  for (let i = 0; i < node.d.s; i++) {
+  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])
     );
   }
-  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 = assignRef(ctx, node.i, new AggregateError([], 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 = assignRef(ctx, node.i, new ErrorConstructor(node.m));
+  const result = assignIndexedValue(ctx, node.i, new ErrorConstructor(deserializeString(node.m)));
   return deserializeDictionary(ctx, node, result);
 }
 function createDeferred() {
@@ -1010,37 +1264,107 @@ function createDeferred() {
 }
 function deserializePromise(ctx, node) {
   const deferred = createDeferred();
-  const result = assignRef(ctx, node.i, deferred.promise);
+  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 result = assignRef(ctx, node.i, new TypedArray(
-    dummy.buffer,
+  const source = deserializeTree(ctx, node.f);
+  const result = assignIndexedValue(ctx, node.i, new TypedArray(
+    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 deserializeIterable(ctx, node) {
   const values = [];
-  deserializeNodeList(ctx, node, values);
-  const result = assignRef(ctx, node.i, {
+  let item;
+  for (let i = 0, len = node.l; i < len; i++) {
+    item = node.a[i];
+    if (item) {
+      values[i] = deserializeTree(ctx, item);
+    }
+  }
+  const result = assignIndexedValue(ctx, node.i, {
     [Symbol.iterator]: () => values.values()
   });
   return deserializeDictionary(ctx, node, 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
+  ));
+  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());
+  for (let i = 0, len = node.d.s; i < len; i++) {
+    result.set(
+      deserializeString(node.d.k[i]),
+      deserializeTree(ctx, node.d.v[i])
+    );
+  }
+  return result;
+}
+function deserializeFormData(ctx, node) {
+  const result = assignIndexedValue(ctx, node.i, new FormData());
+  for (let i = 0, len = node.d.s; i < len; i++) {
+    result.set(
+      deserializeString(node.d.k[i]),
+      deserializeTree(ctx, node.d.v[i])
+    );
+  }
+  return result;
+}
 function deserializeTree(ctx, node) {
   switch (node.t) {
     case 0 /* Number */:
     case 2 /* Boolean */:
       return node.s;
     case 1 /* String */:
-      return invQuote(node.s);
+      return deserializeString(node.s);
     case 4 /* Undefined */:
       return void 0;
     case 3 /* Null */:
@@ -1055,7 +1379,7 @@ function deserializeTree(ctx, node) {
       return NaN;
     case 9 /* BigInt */:
       return BigInt(node.s);
-    case 10 /* Reference */:
+    case 10 /* IndexedValue */:
       return ctx.valueMap.get(node.i);
     case 15 /* Array */:
       return deserializeArray(ctx, node);
@@ -1064,16 +1388,20 @@ function deserializeTree(ctx, node) {
     case 17 /* NullConstructor */:
       return deserializeNullConstructor(ctx, node);
     case 11 /* Date */:
-      return assignRef(ctx, node.i, new Date(node.s));
+      return deserializeDate(ctx, node);
     case 12 /* RegExp */:
-      return assignRef(ctx, node.i, new RegExp(node.c, node.m));
+      return deserializeRegExp(ctx, node);
     case 13 /* Set */:
       return deserializeSet(ctx, node);
     case 14 /* Map */:
       return deserializeMap(ctx, node);
+    case 28 /* ArrayBuffer */:
+      return deserializeArrayBuffer(ctx, node);
     case 23 /* BigIntTypedArray */:
     case 22 /* TypedArray */:
       return deserializeTypedArray(ctx, node);
+    case 29 /* DataView */:
+      return deserializeDataView(ctx, node);
     case 20 /* AggregateError */:
       return deserializeAggregateError(ctx, node);
     case 19 /* Error */:
@@ -1084,6 +1412,20 @@ function deserializeTree(ctx, node) {
       return deserializePromise(ctx, node);
     case 24 /* WKSymbol */:
       return SYMBOL_REF[node.s];
+    case 25 /* URL */:
+      return deserializeURL(ctx, node);
+    case 26 /* URLSearchParams */:
+      return deserializeURLSearchParams(ctx, node);
+    case 27 /* Reference */:
+      return deserializeReference(ctx, node);
+    case 30 /* Blob */:
+      return deserializeBlob(ctx, node);
+    case 31 /* File */:
+      return deserializeFile(ctx, node);
+    case 32 /* Headers */:
+      return deserializeHeaders(ctx, node);
+    case 33 /* FormData */:
+      return deserializeFormData(ctx, node);
     default:
       throw new Error("Unsupported type");
   }
@@ -1094,10 +1436,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 "";
   }
@@ -1124,10 +1468,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
@@ -1137,10 +1481,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
@@ -1150,6 +1494,10 @@ function mergeAssignments(assignments) {
             current = item;
           }
           break;
+        case "append":
+          newAssignments.push(current);
+          current = item;
+          break;
         default:
           break;
       }
@@ -1184,40 +1532,45 @@ 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) {
   markRef(ctx, ref);
   createAssignment(ctx, getRefParam(ctx, ref) + "." + key, value);
 }
-function assignRef2(ctx, index, value) {
+function assignIndexedValue2(ctx, index, value) {
   if (ctx.markedRefs.has(index)) {
     return getRefParam(ctx, index) + "=" + value;
   }
   return value;
 }
-function isReferenceInStack(ctx, node) {
-  return node.t === 10 /* Reference */ && ctx.stack.includes(node.i);
+function isIndexedValueInStack(ctx, node) {
+  return node.t === 10 /* IndexedValue */ && ctx.stack.includes(node.i);
 }
 function serializeNodeList(ctx, node) {
   const size = node.l;
@@ -1230,7 +1583,8 @@ function serializeNodeList(ctx, node) {
     }
     item = node.a[i];
     if (item) {
-      if (isReferenceInStack(ctx, item)) {
+      if (isIndexedValueInStack(ctx, item)) {
+        markRef(ctx, node.i);
         createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
         isHoley = true;
       } else {
@@ -1247,7 +1601,7 @@ function serializeArray(ctx, node) {
   ctx.stack.push(node.i);
   const result = serializeNodeList(ctx, node);
   ctx.stack.pop();
-  return assignRef2(ctx, node.i, result);
+  return assignIndexedValue2(ctx, node.i, result);
 }
 function serializeProperties(ctx, sourceID, node) {
   if (node.s === 0) {
@@ -1261,20 +1615,24 @@ 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];
+  const keys = node.k;
+  const values = node.v;
+  for (let i = 0, len = node.s; i < len; i++) {
+    key = keys[i];
+    val = values[i];
     check = Number(key);
     isIdentifier = check >= 0 || isValidIdentifier(key);
-    if (isReferenceInStack(ctx, val)) {
+    if (isIndexedValueInStack(ctx, val)) {
       refParam = getRefParam(ctx, val.i);
       if (isIdentifier && Number.isNaN(check)) {
+        markRef(ctx, sourceID);
         createObjectAssign(ctx, sourceID, key, refParam);
       } else {
-        createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + quote(key) + '"', refParam);
+        markRef(ctx, sourceID);
+        createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + key + '"', refParam);
       }
     } else {
-      result += (hasPrev ? "," : "") + (isIdentifier ? key : '"' + quote(key) + '"') + ":" + serializeTree(ctx, val);
+      result += (hasPrev ? "," : "") + (isIdentifier ? key : '"' + key + '"') + ":" + serializeTree(ctx, val);
       hasPrev = true;
     }
   }
@@ -1297,12 +1655,14 @@ function serializeAssignments(ctx, sourceID, node) {
   let check;
   let parentAssignment;
   let isIdentifier;
-  for (let i = 0; i < node.s; i++) {
+  const keys = node.k;
+  const values = node.v;
+  for (let i = 0, len = node.s; i < len; i++) {
     parentStack = ctx.stack;
     ctx.stack = [];
-    refParam = serializeTree(ctx, node.v[i]);
+    refParam = serializeTree(ctx, values[i]);
     ctx.stack = parentStack;
-    key = node.k[i];
+    key = keys[i];
     check = Number(key);
     parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
@@ -1310,7 +1670,7 @@ function serializeAssignments(ctx, sourceID, node) {
     if (isIdentifier && Number.isNaN(check)) {
       createObjectAssign(ctx, sourceID, key, refParam);
     } else {
-      createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + quote(key) + '"', refParam);
+      createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + key + '"', refParam);
     }
     ctx.assignments = parentAssignment;
   }
@@ -1325,17 +1685,17 @@ function serializeDictionary(ctx, i, d, init) {
       markRef(ctx, i);
       const assignments = serializeAssignments(ctx, i, d);
       if (assignments) {
-        return "(" + assignRef2(ctx, i, init) + "," + assignments + getRefParam(ctx, i) + ")";
+        return "(" + assignIndexedValue2(ctx, i, init) + "," + assignments + getRefParam(ctx, i) + ")";
       }
     }
   }
-  return assignRef2(ctx, i, init);
+  return assignIndexedValue2(ctx, i, init);
 }
 function serializeNullConstructor(ctx, node) {
   return serializeDictionary(ctx, node.i, node.d, "Object.create(null)");
 }
 function serializeObject(ctx, node) {
-  return assignRef2(ctx, node.i, serializeProperties(ctx, node.i, node.d));
+  return assignIndexedValue2(ctx, node.i, serializeProperties(ctx, node.i, node.d));
 }
 function serializeSet(ctx, node) {
   let serialized = "new Set";
@@ -1347,8 +1707,9 @@ function serializeSet(ctx, node) {
     let hasPrev = false;
     for (let i = 0; i < size; i++) {
       item = node.a[i];
-      if (isReferenceInStack(ctx, item)) {
-        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
+      if (isIndexedValueInStack(ctx, item)) {
+        markRef(ctx, node.i);
+        createAddAssignment(ctx, node.i, getRefParam(ctx, item.i));
       } else {
         result += (hasPrev ? "," : "") + serializeTree(ctx, item);
         hasPrev = true;
@@ -1359,7 +1720,7 @@ function serializeSet(ctx, node) {
       serialized += "([" + result + "])";
     }
   }
-  return assignRef2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, node.i, serialized);
 }
 function serializeMap(ctx, node) {
   let serialized = "new Map";
@@ -1375,22 +1736,24 @@ function serializeMap(ctx, node) {
     for (let i = 0; i < node.d.s; i++) {
       key = node.d.k[i];
       val = node.d.v[i];
-      if (isReferenceInStack(ctx, key)) {
+      if (isIndexedValueInStack(ctx, key)) {
         keyRef = getRefParam(ctx, key.i);
-        if (isReferenceInStack(ctx, val)) {
+        markRef(ctx, node.i);
+        if (isIndexedValueInStack(ctx, val)) {
           valueRef = getRefParam(ctx, val.i);
-          createMapSet(ctx, node.i, keyRef, valueRef);
+          createSetAssignment(ctx, node.i, keyRef, valueRef);
         } else {
           parent = ctx.stack;
           ctx.stack = [];
-          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
+          createSetAssignment(ctx, node.i, keyRef, serializeTree(ctx, val));
           ctx.stack = parent;
         }
-      } else if (isReferenceInStack(ctx, val)) {
+      } else if (isIndexedValueInStack(ctx, val)) {
         valueRef = getRefParam(ctx, val.i);
+        markRef(ctx, node.i);
         parent = ctx.stack;
         ctx.stack = [];
-        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
+        createSetAssignment(ctx, node.i, serializeTree(ctx, key), valueRef);
         ctx.stack = parent;
       } else {
         result += (hasPrev ? ",[" : "[") + serializeTree(ctx, key) + "," + serializeTree(ctx, val) + "]";
@@ -1402,21 +1765,21 @@ function serializeMap(ctx, node) {
       serialized += "([" + result + "])";
     }
   }
-  return assignRef2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, node.i, serialized);
 }
 function serializeAggregateError(ctx, node) {
   ctx.stack.push(node.i);
-  const serialized = "new AggregateError(" + serializeNodeList(ctx, node) + ',"' + quote(node.m) + '")';
+  const serialized = 'new AggregateError([],"' + node.m + '")';
   ctx.stack.pop();
   return serializeDictionary(ctx, node.i, node.d, serialized);
 }
 function serializeError(ctx, node) {
-  const serialized = "new " + node.c + '("' + quote(node.m) + '")';
+  const serialized = "new " + node.c + '("' + node.m + '")';
   return serializeDictionary(ctx, node.i, node.d, serialized);
 }
 function serializePromise(ctx, node) {
   let serialized;
-  if (isReferenceInStack(ctx, node.f)) {
+  if (isIndexedValueInStack(ctx, node.f)) {
     const ref = getRefParam(ctx, node.f.i);
     if (ctx.features & 4 /* ArrowFunction */) {
       serialized = "Promise.resolve().then(()=>" + ref + ")";
@@ -1429,16 +1792,22 @@ function serializePromise(ctx, node) {
     ctx.stack.pop();
     serialized = "Promise.resolve(" + result + ")";
   }
-  return assignRef2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, node.i, serialized);
 }
-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" : "");
+function serializeArrayBuffer2(ctx, node) {
+  let result = "new Uint8Array(";
+  if (node.s.length) {
+    result += "[";
+    for (let i = 0, len = node.s.length; i < len; i++) {
+      result += (i > 0 ? "," : "") + node.s[i];
+    }
+    result += "]";
   }
-  const args = "[" + result + "]" + (node.l !== 0 ? "," + node.l : "");
-  return assignRef2(ctx, node.i, "new " + node.c + "(" + args + ")");
+  return assignIndexedValue2(ctx, node.i, result + ").buffer");
+}
+function serializeTypedArray(ctx, node) {
+  const args = serializeTree(ctx, node.f) + "," + node.b + "," + node.l;
+  return assignIndexedValue2(ctx, node.i, "new " + node.c + "(" + args + ")");
 }
 function serializeIterable(ctx, node) {
   const parent = ctx.stack;
@@ -1460,6 +1829,68 @@ function serializeIterable(ctx, node) {
   }
   return serializeDictionary(ctx, node.i, node.d, serialized);
 }
+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) {
+  const args = serializeTree(ctx, node.f) + "," + node.b + "," + node.l;
+  return assignIndexedValue2(ctx, node.i, "new DataView(" + args + ")");
+}
+function serializeBlob(ctx, node) {
+  const args = "[" + serializeTree(ctx, node.f) + '],{type:"' + node.c + '"}';
+  return assignIndexedValue2(ctx, node.i, "new Blob(" + args + ")");
+}
+function serializeFile(ctx, node) {
+  const options = '{type:"' + node.c + '",lastModified:' + node.b + "}";
+  const args = "[" + serializeTree(ctx, node.f) + '],"' + node.m + '",' + options;
+  return assignIndexedValue2(ctx, node.i, "new File(" + args + ")");
+}
+function serializeHeaders(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, "new Headers(" + serializeProperties(ctx, node.i, node.d) + ")");
+}
+function serializeFormDataEntries(ctx, node) {
+  ctx.stack.push(node.i);
+  const mainAssignments = [];
+  let parentStack;
+  let value;
+  let key;
+  let parentAssignment;
+  for (let i = 0; i < node.d.s; i++) {
+    parentStack = ctx.stack;
+    ctx.stack = [];
+    value = serializeTree(ctx, node.d.v[i]);
+    key = node.d.k[i];
+    ctx.stack = parentStack;
+    parentAssignment = ctx.assignments;
+    ctx.assignments = mainAssignments;
+    createAppendAssignment(ctx, node.i, '"' + key + '"', value);
+    ctx.assignments = parentAssignment;
+  }
+  ctx.stack.pop();
+  return resolveAssignments(mainAssignments);
+}
+function serializeFormData(ctx, node) {
+  if (node.d.s) {
+    markRef(ctx, node.i);
+  }
+  const result = assignIndexedValue2(ctx, node.i, "new FormData()");
+  if (node.d.s) {
+    return "(" + result + "," + serializeFormDataEntries(ctx, node) + getRefParam(ctx, node.i) + ")";
+  }
+  return result;
+}
 function serializeTree(ctx, node) {
   switch (node.t) {
     case 0 /* Number */:
@@ -1482,7 +1913,7 @@ function serializeTree(ctx, node) {
       return "NaN";
     case 9 /* BigInt */:
       return node.s + "n";
-    case 10 /* Reference */:
+    case 10 /* IndexedValue */:
       return getRefParam(ctx, node.i);
     case 15 /* Array */:
       return serializeArray(ctx, node);
@@ -1491,16 +1922,20 @@ function serializeTree(ctx, node) {
     case 17 /* NullConstructor */:
       return serializeNullConstructor(ctx, node);
     case 11 /* Date */:
-      return assignRef2(ctx, node.i, 'new Date("' + node.s + '")');
+      return serializeDate(ctx, node);
     case 12 /* RegExp */:
-      return assignRef2(ctx, node.i, "/" + node.c + "/" + node.m);
+      return serializeRegExp(ctx, node);
     case 13 /* Set */:
       return serializeSet(ctx, node);
     case 14 /* Map */:
       return serializeMap(ctx, node);
+    case 28 /* ArrayBuffer */:
+      return serializeArrayBuffer2(ctx, node);
     case 23 /* BigIntTypedArray */:
     case 22 /* TypedArray */:
       return serializeTypedArray(ctx, node);
+    case 29 /* DataView */:
+      return serializeDataView(ctx, node);
     case 20 /* AggregateError */:
       return serializeAggregateError(ctx, node);
     case 19 /* Error */:
@@ -1511,6 +1946,20 @@ function serializeTree(ctx, node) {
       return serializePromise(ctx, node);
     case 24 /* WKSymbol */:
       return SYMBOL_STRING[node.s];
+    case 25 /* URL */:
+      return serializeURL(ctx, node);
+    case 26 /* URLSearchParams */:
+      return serializeURLSearchParams(ctx, node);
+    case 27 /* Reference */:
+      return serializeReference(ctx, node);
+    case 30 /* Blob */:
+      return serializeBlob(ctx, node);
+    case 31 /* File */:
+      return serializeFile(ctx, node);
+    case 32 /* Headers */:
+      return serializeHeaders(ctx, node);
+    case 33 /* FormData */:
+      return serializeFormData(ctx, node);
     default:
       throw new Error("Unsupported type");
   }
@@ -1549,7 +1998,8 @@ function generateArrayNode2(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: generateNodeList2(ctx, current),
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function generateMapNode2(ctx, id, current) {
@@ -1585,7 +2035,8 @@ function generateMapNode2(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
   };
 }
 function generateSetNode2(ctx, id, current) {
@@ -1614,7 +2065,8 @@ function generateSetNode2(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: nodes,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function generateProperties2(ctx, properties) {
@@ -1627,14 +2079,16 @@ function generateProperties2(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;
+      keyNodes[nodesSize] = escaped;
       valueNodes[nodesSize] = parse2(ctx, item);
       nodesSize++;
     }
@@ -1663,7 +2117,8 @@ function generateIterableNode2(ctx, id, current) {
     // Parse options first before the items
     d: options ? generateProperties2(ctx, options) : void 0,
     a: generateNodeList2(ctx, array),
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function generateObjectNode2(ctx, id, current, empty) {
@@ -1679,7 +2134,8 @@ function generateObjectNode2(ctx, id, current, empty) {
     m: void 0,
     d: generateProperties2(ctx, current),
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
   };
 }
 function generateAggregateErrorNode2(ctx, id, current) {
@@ -1689,12 +2145,13 @@ function generateAggregateErrorNode2(ctx, id, current) {
     t: 20 /* AggregateError */,
     i: id,
     s: void 0,
-    l: current.errors.length,
+    l: void 0,
     c: void 0,
-    m: current.message,
+    m: serializeString(current.message),
     d: optionsNode,
-    a: generateNodeList2(ctx, current.errors),
-    f: void 0
+    a: void 0,
+    f: void 0,
+    b: void 0
   };
 }
 function generateErrorNode2(ctx, id, current) {
@@ -1706,10 +2163,49 @@ function generateErrorNode2(ctx, id, current) {
     s: void 0,
     l: void 0,
     c: getErrorConstructorName(current),
-    m: current.message,
+    m: serializeString(current.message),
     d: optionsNode,
     a: void 0,
-    f: void 0
+    f: void 0,
+    b: void 0
+  };
+}
+function generateHeadersNode2(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "Headers"');
+  const items = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: 32 /* Headers */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: generateProperties2(ctx, items),
+    a: void 0,
+    f: void 0,
+    b: void 0
+  };
+}
+function generateFormDataNode2(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "FormData"');
+  const items = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: 33 /* FormData */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: generateProperties2(ctx, items),
+    a: void 0,
+    f: void 0,
+    b: void 0
   };
 }
 function parse2(ctx, current) {
@@ -1727,24 +2223,26 @@ function parse2(ctx, current) {
         case -Infinity:
           return NEG_INFINITY_NODE;
         default:
-          break;
-      }
-      if (current !== current) {
-        return NAN_NODE;
-      }
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
+          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 = createRef(ctx, current);
+      const id = createIndexedValue(ctx, current);
       if (ctx.markedRefs.has(id)) {
-        return createReferenceNode(id);
+        return createIndexedValueNode(id);
+      }
+      if (hasReferenceID(current)) {
+        return createReferenceNode(id, current);
       }
       if (Array.isArray(current)) {
         return generateArrayNode2(ctx, id, current);
@@ -1754,6 +2252,8 @@ function parse2(ctx, current) {
           return createDateNode(id, current);
         case RegExp:
           return createRegExpNode(id, current);
+        case ArrayBuffer:
+          return createArrayBufferNode(id, current);
         case Int8Array:
         case Int16Array:
         case Int32Array:
@@ -1767,14 +2267,26 @@ function parse2(ctx, 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);
+          return generateObjectNode2(
+            ctx,
+            id,
+            current,
+            false
+          );
         case void 0:
-          return generateObjectNode2(ctx, id, current, true);
+          return generateObjectNode2(
+            ctx,
+            id,
+            current,
+            true
+          );
         case AggregateError:
           if (ctx.features & 1 /* AggregateError */) {
             return generateAggregateErrorNode2(ctx, id, current);
@@ -1788,6 +2300,14 @@ function parse2(ctx, current) {
         case TypeError:
         case URIError:
           return generateErrorNode2(ctx, id, current);
+        case URL:
+          return createURLNode(ctx, id, current);
+        case URLSearchParams:
+          return createURLSearchParamsNode(ctx, id, current);
+        case Headers:
+          return generateHeadersNode2(ctx, id, current);
+        case FormData:
+          return generateFormDataNode2(ctx, id, current);
         default:
           break;
       }
@@ -1806,9 +2326,22 @@ function parse2(ctx, current) {
       throw new Error("Unsupported type");
     }
     case "symbol":
-      assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "symbol"');
-      assert(current in INV_SYMBOL_REF, "seroval only supports well-known symbols");
-      return createWKSymbolNode(current);
+      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);
+    }
     default:
       throw new Error("Unsupported type");
   }
@@ -1901,6 +2434,7 @@ var src_default = serialize;
 export {
   Feature,
   compileJSON,
+  createReference,
   src_default as default,
   deserialize,
   fromJSON,