seroval 0.10.4 → 0.11.1

package/dist/cjs/development/index.cjs

@@ -63,6 +63,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 = {
@@ -155,13 +156,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;
@@ -320,6 +314,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 = "_$";
@@ -438,8 +439,7 @@ function createStringNode(value) {
     o: void 0
   };
 }
-function createBigIntNode(ctx, current) {
-  assert(ctx.features & 8 /* BigInt */, new UnsupportedTypeError(current));
+function createBigIntNode(current) {
   return {
     t: 3 /* BigInt */,
     i: void 0,
@@ -525,8 +525,7 @@ function createArrayBufferNode(id, current) {
     o: void 0
   };
 }
-function createWKSymbolNode(ctx, id, current) {
-  assert(ctx.features & 1024 /* Symbol */, new UnsupportedTypeError(current));
+function createWKSymbolNode(id, current) {
   assert(current in INV_SYMBOL_REF, new Error("Only well-known symbols are supported."));
   return {
     t: 17 /* WKSymbol */,
@@ -569,7 +568,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,
@@ -585,12 +583,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,
@@ -630,7 +623,7 @@ function createSymbolNode(ctx, current) {
   if (hasReferenceID(current)) {
     return createReferenceNode(id, current);
   }
-  return createWKSymbolNode(ctx, id, current);
+  return createWKSymbolNode(id, current);
 }
 function createFunctionNode(ctx, current) {
   assert(hasReferenceID(current), new Error("Cannot serialize function without reference ID."));
@@ -782,7 +775,6 @@ function getObjectFlag(obj) {
 
 // src/core/tree/web-api.ts
 async function createBlobNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   return {
     t: 23 /* Blob */,
     i: id,
@@ -799,7 +791,6 @@ async function createBlobNode(ctx, id, current) {
   };
 }
 async function createFileNode(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   return {
     t: 24 /* File */,
     i: id,
@@ -817,8 +808,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,
@@ -834,8 +824,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,
@@ -851,6 +840,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) {
@@ -861,6 +866,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;
@@ -901,7 +945,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);
@@ -940,7 +983,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);
@@ -1052,7 +1094,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 */,
@@ -1122,7 +1163,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;
@@ -1143,7 +1183,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;
@@ -1179,6 +1218,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;
@@ -1193,49 +1302,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,
@@ -1250,11 +1327,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:
@@ -1263,40 +1335,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 (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 (current instanceof Promise) {
+  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(current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -1305,8 +1437,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":
@@ -1547,6 +1677,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 */:
@@ -1603,6 +1780,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");
   }
@@ -2177,6 +2364,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 */:
@@ -2234,6 +2448,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");
   }
@@ -2279,7 +2503,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);
@@ -2318,7 +2541,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);
@@ -2479,7 +2701,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;
@@ -2500,7 +2721,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;
@@ -2536,6 +2756,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;
@@ -2550,39 +2802,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,
@@ -2597,11 +2827,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:
@@ -2610,33 +2835,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(current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -2645,8 +2918,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":
@@ -2806,7 +3077,6 @@ function serializeArrayBuffer3(ctx, current) {
   return createArrayBufferNode(newID, current);
 }
 function createTypedArrayNode2(ctx, id, current) {
-  assert(ctx.features & 2048 /* TypedArray */, new UnsupportedTypeError(current));
   return {
     t: 15 /* TypedArray */,
     i: id,
@@ -2869,7 +3139,7 @@ function createSymbolNode2(ctx, current) {
   if (hasReferenceID(current)) {
     return createReferenceNode(newID, current);
   }
-  return createWKSymbolNode(ctx, newID, current);
+  return createWKSymbolNode(newID, current);
 }
 function createFunctionNode2(ctx, current) {
   assert(hasReferenceID(current), new Error("Cannot serialize function without reference ID."));
@@ -2884,7 +3154,6 @@ function createFunctionNode2(ctx, current) {
 
 // src/core/cross/web-api.ts
 async function createBlobNode2(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   return {
     t: 23 /* Blob */,
     i: id,
@@ -2901,7 +3170,6 @@ async function createBlobNode2(ctx, id, current) {
   };
 }
 async function createFileNode2(ctx, id, current) {
-  assert(ctx.features & 8192 /* WebAPI */, new UnsupportedTypeError(current));
   return {
     t: 24 /* File */,
     i: id,
@@ -2958,7 +3226,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);
@@ -2997,7 +3264,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);
@@ -3109,7 +3375,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 */,
@@ -3179,7 +3444,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;
@@ -3200,7 +3464,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;
@@ -3236,6 +3499,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;
@@ -3252,49 +3585,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,
@@ -3309,11 +3610,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:
@@ -3322,40 +3618,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 (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 (current instanceof Promise) {
+  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(current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -3364,8 +3720,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":
@@ -3845,6 +4199,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 */:
@@ -3916,6 +4297,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");
   }
@@ -3961,7 +4352,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);
@@ -4000,7 +4390,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);
@@ -4112,7 +4501,6 @@ function generatePlainProperties4(ctx, properties) {
   };
 }
 function generatePromiseNode3(ctx, id, current) {
-  assert(ctx.features & 256 /* Promise */, new UnsupportedTypeError(current));
   current.then(
     (data) => {
       if (ctx.alive) {
@@ -4222,7 +4610,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;
@@ -4243,7 +4630,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;
@@ -4280,7 +4666,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() {
@@ -4359,6 +4744,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;
@@ -4375,7 +4830,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:
@@ -4387,37 +4843,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,
@@ -4432,11 +4857,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:
@@ -4445,38 +4865,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 (current instanceof Promise) {
+  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 (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(current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -4485,8 +4957,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":
@@ -4538,7 +5008,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);
@@ -4577,7 +5046,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);
@@ -4737,7 +5205,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;
@@ -4758,7 +5225,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;
@@ -4794,6 +5260,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;
@@ -4810,39 +5308,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,
@@ -4857,11 +5333,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:
@@ -4870,33 +5341,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(current);
+  }
+  switch (t) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
     case "undefined":
@@ -4905,8 +5424,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":