seroval 0.10.4 → 0.11.0

package/dist/esm/development/index.mjs

@@ -24,6 +24,7 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
   return Feature2;
 })(Feature || {});
 var ALL_ENABLED = 16383;
+var BIGINT_FLAG = 4096 /* BigIntTypedArray */ | 8 /* BigInt */;
 
 // src/core/constants.ts
 var SYMBOL_STRING = {
@@ -116,13 +117,6 @@ function deserializeConstant(node) {
   }
 }
 
-// src/core/assert.ts
-function assert(cond, error) {
-  if (!cond) {
-    throw error;
-  }
-}
-
 // src/core/get-identifier.ts
 var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
 var REF_START_CHARS_LEN = REF_START_CHARS.length;
@@ -281,6 +275,13 @@ var INFINITY_NODE = createConstantNode(5 /* Infinity */);
 var NEG_INFINITY_NODE = createConstantNode(6 /* NegativeInfinity */);
 var NAN_NODE = createConstantNode(7 /* NaN */);
 
+// src/core/assert.ts
+function assert(cond, error) {
+  if (!cond) {
+    throw error;
+  }
+}
+
 // src/core/keys.ts
 var REFERENCES_KEY = "__SEROVAL_REFS__";
 var GLOBAL_CONTEXT_API = "_$";
@@ -530,7 +531,6 @@ function serializeArrayBuffer(ctx, current) {
   return createArrayBufferNode(id, current);
 }
 function createTypedArrayNode(ctx, id, current) {
-  assert(ctx.features & 2048 /* TypedArray */, new UnsupportedTypeError(current));
   return {
     t: 15 /* TypedArray */,
     i: id,
@@ -546,12 +546,7 @@ function createTypedArrayNode(ctx, id, current) {
     o: void 0
   };
 }
-var BIGINT_FLAG = 4096 /* BigIntTypedArray */ | 8 /* BigInt */;
 function createBigIntTypedArrayNode(ctx, id, current) {
-  assert(
-    (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
-    new UnsupportedTypeError(current)
-  );
   return {
     t: 16 /* BigIntTypedArray */,
     i: id,
@@ -778,8 +773,7 @@ async function createFileNode(ctx, id, current) {
 }
 
 // src/core/web-api.ts
-function createURLNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
+function createURLNode(id, current) {
   return {
     t: 18 /* URL */,
     i: id,
@@ -795,8 +789,7 @@ function createURLNode(ctx, id, current) {
     o: void 0
   };
 }
-function createURLSearchParamsNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
+function createURLSearchParamsNode(id, current) {
   return {
     t: 19 /* URLSearchParams */,
     i: id,
@@ -812,6 +805,22 @@ function createURLSearchParamsNode(ctx, id, current) {
     o: void 0
   };
 }
+function createDOMExceptionNode(id, current) {
+  return {
+    t: 39 /* DOMException */,
+    i: id,
+    s: serializeString(current.message),
+    l: void 0,
+    c: serializeString(current.name),
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
 
 // src/core/promise-to-result.ts
 async function promiseToResult(current) {
@@ -822,6 +831,45 @@ async function promiseToResult(current) {
   }
 }
 
+// src/core/constructors.ts
+function createRequestOptions(current, body) {
+  return {
+    body,
+    cache: current.cache,
+    credentials: current.credentials,
+    headers: current.headers,
+    integrity: current.integrity,
+    keepalive: current.keepalive,
+    method: current.method,
+    mode: current.mode,
+    redirect: current.redirect,
+    referrer: current.referrer,
+    referrerPolicy: current.referrerPolicy
+  };
+}
+function createResponseOptions(current) {
+  return {
+    headers: current.headers,
+    status: current.status,
+    statusText: current.statusText
+  };
+}
+function createEventOptions(current) {
+  return {
+    bubbles: current.bubbles,
+    cancelable: current.cancelable,
+    composed: current.composed
+  };
+}
+function createCustomEventOptions(current) {
+  return {
+    detail: current.detail,
+    bubbles: current.bubbles,
+    cancelable: current.cancelable,
+    composed: current.composed
+  };
+}
+
 // src/core/tree/async.ts
 async function generateNodeList(ctx, current) {
   const size = current.length;
@@ -862,7 +910,6 @@ async function generateArrayNode(ctx, id, current) {
   };
 }
 async 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);
@@ -901,7 +948,6 @@ async function generateMapNode(ctx, id, current) {
   };
 }
 async 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);
@@ -1013,7 +1059,6 @@ async function generatePlainProperties(ctx, properties) {
   };
 }
 async function generatePromiseNode(ctx, id, current) {
-  assert(ctx.features & 256 /* Promise */, new UnsupportedTypeError(current));
   const [status, result] = await promiseToResult(current);
   return {
     t: 12 /* Promise */,
@@ -1083,7 +1128,6 @@ async function generateErrorNode(ctx, id, current) {
   };
 }
 async function generateHeadersNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -1104,7 +1148,6 @@ async function generateHeadersNode(ctx, id, current) {
   };
 }
 async function generateFormDataNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -1140,6 +1183,76 @@ async function generateBoxedNode(ctx, id, current) {
     o: void 0
   };
 }
+async function generateRequestNode(ctx, id, current) {
+  return {
+    t: 35 /* Request */,
+    i: id,
+    s: serializeString(current.url),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    f: await parseObject(
+      ctx,
+      createRequestOptions(current, current.body ? await current.clone().arrayBuffer() : null)
+    ),
+    a: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
+async function generateResponseNode(ctx, id, current) {
+  return {
+    t: 36 /* Response */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    f: void 0,
+    a: [
+      current.body ? serializeArrayBuffer(ctx, await current.clone().arrayBuffer()) : NULL_NODE,
+      await parseObject(ctx, createResponseOptions(current))
+    ],
+    b: void 0,
+    o: void 0
+  };
+}
+async function generateEventNode(ctx, id, current) {
+  return {
+    t: 37 /* Event */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: await parseObject(ctx, createEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
+async function generateCustomEventNode(ctx, id, current) {
+  return {
+    t: 38 /* CustomEvent */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: await parseObject(ctx, createCustomEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
 async function parseObject(ctx, current) {
   if (!current) {
     return NULL_NODE;
@@ -1154,49 +1267,17 @@ async function parseObject(ctx, current) {
   if (Array.isArray(current)) {
     return generateArrayNode(ctx, id, current);
   }
-  switch (current.constructor) {
+  const currentClass = current.constructor;
+  switch (currentClass) {
     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 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 generateMapNode(
-        ctx,
-        id,
-        current
-      );
-    case Set:
-      return generateSetNode(
-        ctx,
-        id,
-        current
-      );
     case Object:
       return generateObjectNode(
         ctx,
@@ -1211,11 +1292,6 @@ async function parseObject(ctx, current) {
         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:
@@ -1224,40 +1300,100 @@ async function parseObject(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;
   }
-  if (current instanceof AggregateError) {
-    if (ctx.features & 1 /* AggregateError */) {
-      return generateAggregateErrorNode(ctx, id, current);
+  if (ctx.features & 2048 /* TypedArray */) {
+    switch (currentClass) {
+      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 DataView:
+        return createDataViewNode(ctx, id, current);
+      default:
+        break;
     }
-    return generateErrorNode(ctx, id, current);
   }
-  if (current instanceof Error) {
-    return generateErrorNode(ctx, id, current);
+  if ((ctx.features & BIGINT_FLAG) === BIGINT_FLAG) {
+    switch (currentClass) {
+      case BigInt64Array:
+      case BigUint64Array:
+        return createBigIntTypedArrayNode(ctx, id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 32 /* Map */ && currentClass === Map) {
+    return generateMapNode(
+      ctx,
+      id,
+      current
+    );
+  }
+  if (ctx.features & 512 /* Set */ && currentClass === Set) {
+    return generateSetNode(
+      ctx,
+      id,
+      current
+    );
   }
-  if (current instanceof Promise) {
+  if (ctx.features & 8192 /* WebAPI */) {
+    switch (currentClass) {
+      case URL:
+        return createURLNode(id, current);
+      case URLSearchParams:
+        return createURLSearchParamsNode(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);
+      case Request:
+        return generateRequestNode(ctx, id, current);
+      case Response:
+        return generateResponseNode(ctx, id, current);
+      case Event:
+        return generateEventNode(ctx, id, current);
+      case CustomEvent:
+        return generateCustomEventNode(ctx, id, current);
+      case DOMException:
+        return createDOMExceptionNode(id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 1 /* AggregateError */ && (currentClass === AggregateError || current instanceof AggregateError)) {
+    return generateAggregateErrorNode(ctx, id, current);
+  }
+  if (ctx.features & 256 /* Promise */ && (currentClass === Promise || current instanceof Promise)) {
     return generatePromiseNode(ctx, id, current);
   }
-  if (Symbol.iterator in current) {
-    return generateObjectNode(ctx, id, current, !!current.constructor);
+  if (current instanceof Error) {
+    return generateErrorNode(ctx, id, current);
+  }
+  if (ctx.features & 1024 /* Symbol */ && Symbol.iterator in current) {
+    return generateObjectNode(ctx, id, current, !!currentClass);
   }
   throw new UnsupportedTypeError(current);
 }
 async function parseAsync(ctx, current) {
-  switch (typeof current) {
+  const t = typeof current;
+  if (ctx.features & 8 /* BigInt */ && t === "bigint") {
+    return createBigIntNode(ctx, current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -1266,8 +1402,6 @@ async function parseAsync(ctx, current) {
       return createStringNode(current);
     case "number":
       return createNumberNode(current);
-    case "bigint":
-      return createBigIntNode(ctx, current);
     case "object":
       return parseObject(ctx, current);
     case "symbol":
@@ -1508,6 +1642,53 @@ function deserializeBoxed(ctx, node) {
     Object(deserializeTree(ctx, node.f))
   );
 }
+function deserializeRequest(ctx, node) {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new Request(deserializeString(node.s), deserializeTree(ctx, node.f))
+  );
+}
+function deserializeResponse(ctx, node) {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new Response(
+      deserializeTree(ctx, node.a[0]),
+      deserializeTree(ctx, node.a[1])
+    )
+  );
+}
+function deserializeEvent(ctx, node) {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new Event(
+      deserializeString(node.s),
+      deserializeTree(ctx, node.f)
+    )
+  );
+}
+function deserializeCustomEvent(ctx, node) {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new CustomEvent(
+      deserializeString(node.s),
+      deserializeTree(ctx, node.f)
+    )
+  );
+}
+function deserializeDOMException(ctx, node) {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new DOMException(
+      deserializeString(node.s),
+      deserializeString(node.c)
+    )
+  );
+}
 function deserializeTree(ctx, node) {
   switch (node.t) {
     case 2 /* Constant */:
@@ -1564,6 +1745,16 @@ function deserializeTree(ctx, node) {
       return deserializeFormData(ctx, node);
     case 27 /* Boxed */:
       return deserializeBoxed(ctx, node);
+    case 35 /* Request */:
+      return deserializeRequest(ctx, node);
+    case 36 /* Response */:
+      return deserializeResponse(ctx, node);
+    case 37 /* Event */:
+      return deserializeEvent(ctx, node);
+    case 38 /* CustomEvent */:
+      return deserializeCustomEvent(ctx, node);
+    case 39 /* DOMException */:
+      return deserializeDOMException(ctx, node);
     default:
       throw new Error("invariant");
   }
@@ -2138,6 +2329,33 @@ function serializeBoxed(ctx, node) {
 function serializeWKSymbol(ctx, node) {
   return assignIndexedValue2(ctx, node.i, SYMBOL_STRING[node.s]);
 }
+function serializeRequest(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, 'new Request("' + node.s + '",' + serializeTree(ctx, node.f) + ")");
+}
+function serializeResponse(ctx, node) {
+  return assignIndexedValue2(ctx, node.i, "new Response(" + serializeTree(ctx, node.a[0]) + "," + serializeTree(ctx, node.a[1]) + ")");
+}
+function serializeEvent(ctx, node) {
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    'new Event("' + node.s + '",' + serializeTree(ctx, node.f) + ")"
+  );
+}
+function serializeCustomEvent(ctx, node) {
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    'new CustomEvent("' + node.s + '",' + serializeTree(ctx, node.f) + ")"
+  );
+}
+function serializeDOMException(ctx, node) {
+  return assignIndexedValue2(
+    ctx,
+    node.i,
+    'new DOMException("' + node.s + '","' + node.c + '")'
+  );
+}
 function serializeTree(ctx, node) {
   switch (node.t) {
     case 0 /* Number */:
@@ -2195,6 +2413,16 @@ function serializeTree(ctx, node) {
       return serializeFormData(ctx, node);
     case 27 /* Boxed */:
       return serializeBoxed(ctx, node);
+    case 35 /* Request */:
+      return serializeRequest(ctx, node);
+    case 36 /* Response */:
+      return serializeResponse(ctx, node);
+    case 37 /* Event */:
+      return serializeEvent(ctx, node);
+    case 38 /* CustomEvent */:
+      return serializeCustomEvent(ctx, node);
+    case 39 /* DOMException */:
+      return serializeDOMException(ctx, node);
     default:
       throw new Error("invariant");
   }
@@ -2240,7 +2468,6 @@ function generateArrayNode2(ctx, id, current) {
   };
 }
 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);
@@ -2279,7 +2506,6 @@ function generateMapNode2(ctx, id, current) {
   };
 }
 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);
@@ -2440,7 +2666,6 @@ function generateErrorNode2(ctx, id, current) {
   };
 }
 function generateHeadersNode2(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -2461,7 +2686,6 @@ function generateHeadersNode2(ctx, id, current) {
   };
 }
 function generateFormDataNode2(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -2497,6 +2721,38 @@ function generateBoxedNode2(ctx, id, current) {
     o: void 0
   };
 }
+function generateEventNode2(ctx, id, current) {
+  return {
+    t: 37 /* Event */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parseObject2(ctx, createEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
+function generateCustomEventNode2(ctx, id, current) {
+  return {
+    t: 38 /* CustomEvent */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parseObject2(ctx, createCustomEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
 function parseObject2(ctx, current) {
   if (!current) {
     return NULL_NODE;
@@ -2511,39 +2767,17 @@ function parseObject2(ctx, current) {
   if (Array.isArray(current)) {
     return generateArrayNode2(ctx, id, current);
   }
-  switch (current.constructor) {
+  const currentClass = current.constructor;
+  switch (currentClass) {
     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 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,
@@ -2558,11 +2792,6 @@ function parseObject2(ctx, current) {
         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:
@@ -2571,33 +2800,81 @@ function parseObject2(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;
   }
-  if (current instanceof AggregateError) {
-    if (ctx.features & 1 /* AggregateError */) {
-      return generateAggregateErrorNode2(ctx, id, current);
+  if (ctx.features & 2048 /* TypedArray */) {
+    switch (currentClass) {
+      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 DataView:
+        return createDataViewNode(ctx, id, current);
+      default:
+        break;
+    }
+  }
+  if ((ctx.features & BIGINT_FLAG) === BIGINT_FLAG) {
+    switch (currentClass) {
+      case BigInt64Array:
+      case BigUint64Array:
+        return createBigIntTypedArrayNode(ctx, id, current);
+      default:
+        break;
     }
-    return generateErrorNode2(ctx, id, current);
+  }
+  if (ctx.features & 32 /* Map */ && currentClass === Map) {
+    return generateMapNode2(ctx, id, current);
+  }
+  if (ctx.features & 512 /* Set */ && currentClass === Set) {
+    return generateSetNode2(ctx, id, current);
+  }
+  if (ctx.features & 8192 /* WebAPI */) {
+    switch (currentClass) {
+      case URL:
+        return createURLNode(id, current);
+      case URLSearchParams:
+        return createURLSearchParamsNode(id, current);
+      case Headers:
+        return generateHeadersNode2(ctx, id, current);
+      case FormData:
+        return generateFormDataNode2(ctx, id, current);
+      case Event:
+        return generateEventNode2(ctx, id, current);
+      case CustomEvent:
+        return generateCustomEventNode2(ctx, id, current);
+      case DOMException:
+        return createDOMExceptionNode(id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 1 /* AggregateError */ && (currentClass === AggregateError || current instanceof AggregateError)) {
+    return generateAggregateErrorNode2(ctx, id, current);
   }
   if (current instanceof Error) {
     return generateErrorNode2(ctx, id, current);
   }
-  if (Symbol.iterator in current) {
-    return generateObjectNode2(ctx, id, current, !!current.constructor);
+  if (ctx.features & 1024 /* Symbol */ && Symbol.iterator in current) {
+    return generateObjectNode2(ctx, id, current, !!currentClass);
   }
   throw new UnsupportedTypeError(current);
 }
 function parseSync(ctx, current) {
-  switch (typeof current) {
+  const t = typeof current;
+  if (ctx.features & 8 /* BigInt */ && t === "bigint") {
+    return createBigIntNode(ctx, current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -2606,8 +2883,6 @@ function parseSync(ctx, current) {
       return createStringNode(current);
     case "number":
       return createNumberNode(current);
-    case "bigint":
-      return createBigIntNode(ctx, current);
     case "object":
       return parseObject2(ctx, current);
     case "symbol":
@@ -2919,7 +3194,6 @@ async function generateArrayNode3(ctx, id, current) {
   };
 }
 async function generateMapNode3(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);
@@ -2958,7 +3232,6 @@ async function generateMapNode3(ctx, id, current) {
   };
 }
 async function generateSetNode3(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);
@@ -3070,7 +3343,6 @@ async function generatePlainProperties3(ctx, properties) {
   };
 }
 async function generatePromiseNode2(ctx, id, current) {
-  assert(ctx.features & 256 /* Promise */, new UnsupportedTypeError(current));
   const [status, result] = await promiseToResult(current);
   return {
     t: 12 /* Promise */,
@@ -3140,7 +3412,6 @@ async function generateErrorNode3(ctx, id, current) {
   };
 }
 async function generateHeadersNode3(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -3161,7 +3432,6 @@ async function generateHeadersNode3(ctx, id, current) {
   };
 }
 async function generateFormDataNode3(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -3197,6 +3467,76 @@ async function generateBoxedNode3(ctx, id, current) {
     o: void 0
   };
 }
+async function generateRequestNode2(ctx, id, current) {
+  return {
+    t: 35 /* Request */,
+    i: id,
+    s: serializeString(current.url),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    f: await parseObject3(
+      ctx,
+      createRequestOptions(current, current.body ? await current.clone().arrayBuffer() : null)
+    ),
+    a: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
+async function generateResponseNode2(ctx, id, current) {
+  return {
+    t: 36 /* Response */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    f: void 0,
+    a: [
+      current.body ? serializeArrayBuffer3(ctx, await current.clone().arrayBuffer()) : NULL_NODE,
+      await parseObject3(ctx, createResponseOptions(current))
+    ],
+    b: void 0,
+    o: void 0
+  };
+}
+async function generateEventNode3(ctx, id, current) {
+  return {
+    t: 37 /* Event */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: await parseObject3(ctx, createEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
+async function generateCustomEventNode3(ctx, id, current) {
+  return {
+    t: 38 /* CustomEvent */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: await parseObject3(ctx, createCustomEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
 async function parseObject3(ctx, current) {
   if (!current) {
     return NULL_NODE;
@@ -3213,49 +3553,17 @@ async function parseObject3(ctx, current) {
   if (Array.isArray(current)) {
     return generateArrayNode3(ctx, id, current);
   }
-  switch (current.constructor) {
+  const currentClass = current.constructor;
+  switch (currentClass) {
     case Number:
     case Boolean:
     case String:
     case BigInt:
-    case Function:
-    case Symbol:
       return generateBoxedNode3(ctx, id, current);
     case Date:
       return createDateNode(id, current);
     case RegExp:
       return createRegExpNode(id, current);
-    case Promise:
-      return generatePromiseNode2(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 createTypedArrayNode2(ctx, id, current);
-    case BigInt64Array:
-    case BigUint64Array:
-      return createBigIntTypedArrayNode2(ctx, id, current);
-    case DataView:
-      return createDataViewNode2(ctx, id, current);
-    case Map:
-      return generateMapNode3(
-        ctx,
-        id,
-        current
-      );
-    case Set:
-      return generateSetNode3(
-        ctx,
-        id,
-        current
-      );
     case Object:
       return generateObjectNode3(
         ctx,
@@ -3270,11 +3578,6 @@ async function parseObject3(ctx, current) {
         current,
         true
       );
-    case AggregateError:
-      if (ctx.features & 1 /* AggregateError */) {
-        return generateAggregateErrorNode3(ctx, id, current);
-      }
-      return generateErrorNode3(ctx, id, current);
     case Error:
     case EvalError:
     case RangeError:
@@ -3283,40 +3586,100 @@ async function parseObject3(ctx, current) {
     case TypeError:
     case URIError:
       return generateErrorNode3(ctx, id, current);
-    case URL:
-      return createURLNode(ctx, id, current);
-    case URLSearchParams:
-      return createURLSearchParamsNode(ctx, id, current);
-    case Blob:
-      return createBlobNode2(ctx, id, current);
-    case File:
-      return createFileNode2(ctx, id, current);
-    case Headers:
-      return generateHeadersNode3(ctx, id, current);
-    case FormData:
-      return generateFormDataNode3(ctx, id, current);
     default:
       break;
   }
-  if (current instanceof AggregateError) {
-    if (ctx.features & 1 /* AggregateError */) {
-      return generateAggregateErrorNode3(ctx, id, current);
+  if (ctx.features & 2048 /* TypedArray */) {
+    switch (currentClass) {
+      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 createTypedArrayNode2(ctx, id, current);
+      case DataView:
+        return createDataViewNode2(ctx, id, current);
+      default:
+        break;
     }
-    return generateErrorNode3(ctx, id, current);
   }
-  if (current instanceof Error) {
-    return generateErrorNode3(ctx, id, current);
+  if ((ctx.features & BIGINT_FLAG) === BIGINT_FLAG) {
+    switch (currentClass) {
+      case BigInt64Array:
+      case BigUint64Array:
+        return createBigIntTypedArrayNode2(ctx, id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 32 /* Map */ && currentClass === Map) {
+    return generateMapNode3(
+      ctx,
+      id,
+      current
+    );
   }
-  if (current instanceof Promise) {
+  if (ctx.features & 512 /* Set */ && currentClass === Set) {
+    return generateSetNode3(
+      ctx,
+      id,
+      current
+    );
+  }
+  if (ctx.features & 8192 /* WebAPI */) {
+    switch (currentClass) {
+      case URL:
+        return createURLNode(id, current);
+      case URLSearchParams:
+        return createURLSearchParamsNode(id, current);
+      case Blob:
+        return createBlobNode2(ctx, id, current);
+      case File:
+        return createFileNode2(ctx, id, current);
+      case Headers:
+        return generateHeadersNode3(ctx, id, current);
+      case FormData:
+        return generateFormDataNode3(ctx, id, current);
+      case Request:
+        return generateRequestNode2(ctx, id, current);
+      case Response:
+        return generateResponseNode2(ctx, id, current);
+      case Event:
+        return generateEventNode3(ctx, id, current);
+      case CustomEvent:
+        return generateCustomEventNode3(ctx, id, current);
+      case DOMException:
+        return createDOMExceptionNode(id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 1 /* AggregateError */ && (currentClass === AggregateError || current instanceof AggregateError)) {
+    return generateAggregateErrorNode3(ctx, id, current);
+  }
+  if (ctx.features & 256 /* Promise */ && (currentClass === Promise || current instanceof Promise)) {
     return generatePromiseNode2(ctx, id, current);
   }
-  if (Symbol.iterator in current) {
-    return generateObjectNode3(ctx, id, current, !!current.constructor);
+  if (current instanceof Error) {
+    return generateErrorNode3(ctx, id, current);
+  }
+  if (ctx.features & 1024 /* Symbol */ && Symbol.iterator in current) {
+    return generateObjectNode3(ctx, id, current, !!currentClass);
   }
   throw new UnsupportedTypeError(current);
 }
 async function crossParseAsync(ctx, current) {
-  switch (typeof current) {
+  const t = typeof current;
+  if (ctx.features & 8 /* BigInt */ && t === "bigint") {
+    return createBigIntNode(ctx, current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -3325,8 +3688,6 @@ async function crossParseAsync(ctx, current) {
       return createStringNode(current);
     case "number":
       return createNumberNode(current);
-    case "bigint":
-      return createBigIntNode(ctx, current);
     case "object":
       return parseObject3(ctx, current);
     case "symbol":
@@ -3806,6 +4167,33 @@ function serializeReadableStreamError(ctx, node) {
 function serializeReadableStreamConstructor(node) {
   return assignIndexedValue3(node.i, GLOBAL_CONTEXT_API + "." + GLOBAL_CONTEXT_STREAM_CONSTRUCTOR + "()");
 }
+function serializeRequest2(ctx, node) {
+  return assignIndexedValue3(node.i, 'new Request("' + node.s + '",' + crossSerializeTree(ctx, node.f) + ")");
+}
+function serializeResponse2(ctx, node) {
+  return assignIndexedValue3(
+    node.i,
+    "new Response(" + crossSerializeTree(ctx, node.a[0]) + "," + crossSerializeTree(ctx, node.a[1]) + ")"
+  );
+}
+function serializeEvent2(ctx, node) {
+  return assignIndexedValue3(
+    node.i,
+    'new Event("' + node.s + '",' + crossSerializeTree(ctx, node.f) + ")"
+  );
+}
+function serializeCustomEvent2(ctx, node) {
+  return assignIndexedValue3(
+    node.i,
+    'new CustomEvent("' + node.s + '",' + crossSerializeTree(ctx, node.f) + ")"
+  );
+}
+function serializeDOMException2(node) {
+  return assignIndexedValue3(
+    node.i,
+    'new DOMException("' + node.s + '","' + node.c + '")'
+  );
+}
 function crossSerializeTree(ctx, node) {
   switch (node.t) {
     case 0 /* Number */:
@@ -3877,6 +4265,16 @@ function crossSerializeTree(ctx, node) {
       return serializeReadableStreamEnqueue(ctx, node);
     case 34 /* ReadableStreamError */:
       return serializeReadableStreamError(ctx, node);
+    case 35 /* Request */:
+      return serializeRequest2(ctx, node);
+    case 36 /* Response */:
+      return serializeResponse2(ctx, node);
+    case 37 /* Event */:
+      return serializeEvent2(ctx, node);
+    case 38 /* CustomEvent */:
+      return serializeCustomEvent2(ctx, node);
+    case 39 /* DOMException */:
+      return serializeDOMException2(node);
     default:
       throw new Error("invariant");
   }
@@ -3922,7 +4320,6 @@ function generateArrayNode4(ctx, id, current) {
   };
 }
 function generateMapNode4(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);
@@ -3961,7 +4358,6 @@ function generateMapNode4(ctx, id, current) {
   };
 }
 function generateSetNode4(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);
@@ -4073,7 +4469,6 @@ function generatePlainProperties4(ctx, properties) {
   };
 }
 function generatePromiseNode3(ctx, id, current) {
-  assert(ctx.features & 256 /* Promise */, new UnsupportedTypeError(current));
   current.then(
     (data) => {
       if (ctx.alive) {
@@ -4183,7 +4578,6 @@ function generateErrorNode4(ctx, id, current) {
   };
 }
 function generateHeadersNode4(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -4204,7 +4598,6 @@ function generateHeadersNode4(ctx, id, current) {
   };
 }
 function generateFormDataNode4(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -4241,7 +4634,6 @@ function generateBoxedNode4(ctx, id, current) {
   };
 }
 function generateReadableStreamNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const reader = current.getReader();
   pushPendingState(ctx);
   function push() {
@@ -4320,6 +4712,76 @@ function generateReadableStreamNode(ctx, id, current) {
     o: void 0
   };
 }
+function generateRequestNode3(ctx, id, current) {
+  return {
+    t: 35 /* Request */,
+    i: id,
+    s: serializeString(current.url),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    f: parseObject4(
+      ctx,
+      createRequestOptions(current, current.clone().body)
+    ),
+    a: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
+function generateResponseNode3(ctx, id, current) {
+  return {
+    t: 36 /* Response */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    f: void 0,
+    a: [
+      current.body ? parseObject4(ctx, current.clone().body) : NULL_NODE,
+      parseObject4(ctx, createResponseOptions(current))
+    ],
+    b: void 0,
+    o: void 0
+  };
+}
+function generateEventNode4(ctx, id, current) {
+  return {
+    t: 37 /* Event */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parseObject4(ctx, createEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
+function generateCustomEventNode4(ctx, id, current) {
+  return {
+    t: 38 /* CustomEvent */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parseObject4(ctx, createCustomEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
 function parseObject4(ctx, current) {
   if (!current) {
     return NULL_NODE;
@@ -4336,7 +4798,8 @@ function parseObject4(ctx, current) {
   if (Array.isArray(current)) {
     return generateArrayNode4(ctx, id, current);
   }
-  switch (current.constructor) {
+  const currentClass = current.constructor;
+  switch (currentClass) {
     case Number:
     case Boolean:
     case String:
@@ -4348,37 +4811,6 @@ function parseObject4(ctx, current) {
       return createDateNode(id, current);
     case RegExp:
       return createRegExpNode(id, current);
-    case Promise:
-      return generatePromiseNode3(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 createTypedArrayNode2(ctx, id, current);
-    case BigInt64Array:
-    case BigUint64Array:
-      return createBigIntTypedArrayNode2(ctx, id, current);
-    case DataView:
-      return createDataViewNode2(ctx, id, current);
-    case Map:
-      return generateMapNode4(
-        ctx,
-        id,
-        current
-      );
-    case Set:
-      return generateSetNode4(
-        ctx,
-        id,
-        current
-      );
     case Object:
       return generateObjectNode4(
         ctx,
@@ -4393,11 +4825,6 @@ function parseObject4(ctx, current) {
         current,
         true
       );
-    case AggregateError:
-      if (ctx.features & 1 /* AggregateError */) {
-        return generateAggregateErrorNode4(ctx, id, current);
-      }
-      return generateErrorNode4(ctx, id, current);
     case Error:
     case EvalError:
     case RangeError:
@@ -4406,38 +4833,90 @@ function parseObject4(ctx, current) {
     case TypeError:
     case URIError:
       return generateErrorNode4(ctx, id, current);
-    case URL:
-      return createURLNode(ctx, id, current);
-    case URLSearchParams:
-      return createURLSearchParamsNode(ctx, id, current);
-    case Headers:
-      return generateHeadersNode4(ctx, id, current);
-    case FormData:
-      return generateFormDataNode4(ctx, id, current);
-    case ReadableStream:
-      return generateReadableStreamNode(ctx, id, current);
     default:
       break;
   }
-  if (current instanceof AggregateError) {
-    if (ctx.features & 1 /* AggregateError */) {
-      return generateAggregateErrorNode4(ctx, id, current);
+  if (ctx.features & 2048 /* TypedArray */) {
+    switch (currentClass) {
+      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 createTypedArrayNode2(ctx, id, current);
+      case DataView:
+        return createDataViewNode2(ctx, id, current);
+      default:
+        break;
     }
-    return generateErrorNode4(ctx, id, current);
   }
-  if (current instanceof Error) {
-    return generateErrorNode4(ctx, id, current);
+  if ((ctx.features & BIGINT_FLAG) === BIGINT_FLAG) {
+    switch (currentClass) {
+      case BigInt64Array:
+      case BigUint64Array:
+        return createBigIntTypedArrayNode2(ctx, id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 32 /* Map */ && currentClass === Map) {
+    return generateMapNode4(ctx, id, current);
+  }
+  if (ctx.features & 512 /* Set */ && currentClass === Set) {
+    return generateSetNode4(ctx, id, current);
+  }
+  if (ctx.features & 8192 /* WebAPI */) {
+    switch (currentClass) {
+      case URL:
+        return createURLNode(id, current);
+      case URLSearchParams:
+        return createURLSearchParamsNode(id, current);
+      case Headers:
+        return generateHeadersNode4(ctx, id, current);
+      case FormData:
+        return generateFormDataNode4(ctx, id, current);
+      case ReadableStream:
+        return generateReadableStreamNode(ctx, id, current);
+      case Request:
+        return generateRequestNode3(ctx, id, current);
+      case Response:
+        return generateResponseNode3(ctx, id, current);
+      case Event:
+        return generateEventNode4(ctx, id, current);
+      case CustomEvent:
+        return generateCustomEventNode4(ctx, id, current);
+      case DOMException:
+        return createDOMExceptionNode(id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 1 /* AggregateError */ && (currentClass === AggregateError || current instanceof AggregateError)) {
+    return generateAggregateErrorNode4(ctx, id, current);
   }
-  if (current instanceof Promise) {
+  if (ctx.features & 256 /* Promise */ && (currentClass === Promise || current instanceof Promise)) {
     return generatePromiseNode3(ctx, id, current);
   }
-  if (Symbol.iterator in current) {
-    return generateObjectNode4(ctx, id, current, !!current.constructor);
+  if (current instanceof Error) {
+    return generateErrorNode4(ctx, id, current);
+  }
+  if (ctx.features & 1024 /* Symbol */ && Symbol.iterator in current) {
+    return generateObjectNode4(ctx, id, current, !!currentClass);
   }
   throw new UnsupportedTypeError(current);
 }
 function crossParseStream(ctx, current) {
-  switch (typeof current) {
+  const t = typeof current;
+  if (ctx.features & 8 /* BigInt */ && t === "bigint") {
+    return createBigIntNode(ctx, current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -4446,8 +4925,6 @@ function crossParseStream(ctx, current) {
       return createStringNode(current);
     case "number":
       return createNumberNode(current);
-    case "bigint":
-      return createBigIntNode(ctx, current);
     case "object":
       return parseObject4(ctx, current);
     case "symbol":
@@ -4499,7 +4976,6 @@ function generateArrayNode5(ctx, id, current) {
   };
 }
 function generateMapNode5(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);
@@ -4538,7 +5014,6 @@ function generateMapNode5(ctx, id, current) {
   };
 }
 function generateSetNode5(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);
@@ -4698,7 +5173,6 @@ function generateErrorNode5(ctx, id, current) {
   };
 }
 function generateHeadersNode5(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -4719,7 +5193,6 @@ function generateHeadersNode5(ctx, id, current) {
   };
 }
 function generateFormDataNode5(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   const items = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -4755,6 +5228,38 @@ function generateBoxedNode5(ctx, id, current) {
     o: void 0
   };
 }
+function generateEventNode5(ctx, id, current) {
+  return {
+    t: 37 /* Event */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parseObject5(ctx, createEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
+function generateCustomEventNode5(ctx, id, current) {
+  return {
+    t: 38 /* CustomEvent */,
+    i: id,
+    s: serializeString(current.type),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parseObject5(ctx, createCustomEventOptions(current)),
+    b: void 0,
+    o: void 0
+  };
+}
 function parseObject5(ctx, current) {
   if (!current) {
     return NULL_NODE;
@@ -4771,39 +5276,17 @@ function parseObject5(ctx, current) {
   if (Array.isArray(current)) {
     return generateArrayNode5(ctx, id, current);
   }
-  switch (current.constructor) {
+  const currentClass = current.constructor;
+  switch (currentClass) {
     case Number:
     case Boolean:
     case String:
     case BigInt:
-    case Function:
-    case Symbol:
       return generateBoxedNode5(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 createTypedArrayNode2(ctx, id, current);
-    case BigInt64Array:
-    case BigUint64Array:
-      return createBigIntTypedArrayNode2(ctx, id, current);
-    case DataView:
-      return createDataViewNode2(ctx, id, current);
-    case Map:
-      return generateMapNode5(ctx, id, current);
-    case Set:
-      return generateSetNode5(ctx, id, current);
     case Object:
       return generateObjectNode5(
         ctx,
@@ -4818,11 +5301,6 @@ function parseObject5(ctx, current) {
         current,
         true
       );
-    case AggregateError:
-      if (ctx.features & 1 /* AggregateError */) {
-        return generateAggregateErrorNode5(ctx, id, current);
-      }
-      return generateErrorNode5(ctx, id, current);
     case Error:
     case EvalError:
     case RangeError:
@@ -4831,33 +5309,81 @@ function parseObject5(ctx, current) {
     case TypeError:
     case URIError:
       return generateErrorNode5(ctx, id, current);
-    case URL:
-      return createURLNode(ctx, id, current);
-    case URLSearchParams:
-      return createURLSearchParamsNode(ctx, id, current);
-    case Headers:
-      return generateHeadersNode5(ctx, id, current);
-    case FormData:
-      return generateFormDataNode5(ctx, id, current);
     default:
       break;
   }
-  if (current instanceof AggregateError) {
-    if (ctx.features & 1 /* AggregateError */) {
-      return generateAggregateErrorNode5(ctx, id, current);
+  if (ctx.features & 2048 /* TypedArray */) {
+    switch (currentClass) {
+      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 createTypedArrayNode2(ctx, id, current);
+      case DataView:
+        return createDataViewNode2(ctx, id, current);
+      default:
+        break;
     }
-    return generateErrorNode5(ctx, id, current);
+  }
+  if ((ctx.features & BIGINT_FLAG) === BIGINT_FLAG) {
+    switch (currentClass) {
+      case BigInt64Array:
+      case BigUint64Array:
+        return createBigIntTypedArrayNode2(ctx, id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 32 /* Map */ && currentClass === Map) {
+    return generateMapNode5(ctx, id, current);
+  }
+  if (ctx.features & 512 /* Set */ && currentClass === Set) {
+    return generateSetNode5(ctx, id, current);
+  }
+  if (ctx.features & 8192 /* WebAPI */) {
+    switch (currentClass) {
+      case URL:
+        return createURLNode(id, current);
+      case URLSearchParams:
+        return createURLSearchParamsNode(id, current);
+      case Headers:
+        return generateHeadersNode5(ctx, id, current);
+      case FormData:
+        return generateFormDataNode5(ctx, id, current);
+      case Event:
+        return generateEventNode5(ctx, id, current);
+      case CustomEvent:
+        return generateCustomEventNode5(ctx, id, current);
+      case DOMException:
+        return createDOMExceptionNode(id, current);
+      default:
+        break;
+    }
+  }
+  if (ctx.features & 1 /* AggregateError */ && (currentClass === AggregateError || current instanceof AggregateError)) {
+    return generateAggregateErrorNode5(ctx, id, current);
   }
   if (current instanceof Error) {
     return generateErrorNode5(ctx, id, current);
   }
-  if (Symbol.iterator in current) {
-    return generateObjectNode5(ctx, id, current, !!current.constructor);
+  if (ctx.features & 1024 /* Symbol */ && Symbol.iterator in current) {
+    return generateObjectNode5(ctx, id, current, !!currentClass);
   }
   throw new UnsupportedTypeError(current);
 }
 function crossParseSync(ctx, current) {
-  switch (typeof current) {
+  const t = typeof current;
+  if (ctx.features & 8 /* BigInt */ && t === "bigint") {
+    return createBigIntNode(ctx, current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -4866,8 +5392,6 @@ function crossParseSync(ctx, current) {
       return createStringNode(current);
     case "number":
       return createNumberNode(current);
-    case "bigint":
-      return createBigIntNode(ctx, current);
     case "object":
       return parseObject5(ctx, current);
     case "symbol":