seroval 0.15.0 → 1.0.0

package/dist/esm/development/index.mjs

@@ -1,11 +1,13 @@
-// src/core/UnsupportedTypeError.ts
-var { toString } = Object.prototype;
-var UnsupportedTypeError = class extends Error {
-  constructor(value) {
-    super('Unsupported type "' + toString.call(value) + '"');
-    this.value = value;
-  }
-};
+// src/core/compat.ts
+var Feature = /* @__PURE__ */ ((Feature2) => {
+  Feature2[Feature2["AggregateError"] = 1] = "AggregateError";
+  Feature2[Feature2["ArrowFunction"] = 2] = "ArrowFunction";
+  Feature2[Feature2["ErrorPrototypeStack"] = 4] = "ErrorPrototypeStack";
+  Feature2[Feature2["ObjectAssign"] = 8] = "ObjectAssign";
+  Feature2[Feature2["BigIntTypedArray"] = 16] = "BigIntTypedArray";
+  return Feature2;
+})(Feature || {});
+var ALL_ENABLED = 31;
 
 // src/core/utils/assert.ts
 function assert(cond, error) {
@@ -14,117 +16,6 @@ function assert(cond, error) {
   }
 }
 
-// src/core/constants.ts
-var SYMBOL_STRING = {
-  [0 /* AsyncIterator */]: "Symbol.asyncIterator",
-  [1 /* HasInstance */]: "Symbol.hasInstance",
-  [2 /* IsConcatSpreadable */]: "Symbol.isConcatSpreadable",
-  [3 /* Iterator */]: "Symbol.iterator",
-  [4 /* Match */]: "Symbol.match",
-  [5 /* MatchAll */]: "Symbol.matchAll",
-  [6 /* Replace */]: "Symbol.replace",
-  [7 /* Search */]: "Symbol.search",
-  [8 /* Species */]: "Symbol.species",
-  [9 /* Split */]: "Symbol.split",
-  [10 /* ToPrimitive */]: "Symbol.toPrimitive",
-  [11 /* ToStringTag */]: "Symbol.toStringTag",
-  [12 /* Unscopables */]: "Symbol.unscopables"
-};
-var INV_SYMBOL_REF = {
-  [Symbol.asyncIterator]: 0 /* AsyncIterator */,
-  [Symbol.hasInstance]: 1 /* HasInstance */,
-  [Symbol.isConcatSpreadable]: 2 /* IsConcatSpreadable */,
-  [Symbol.iterator]: 3 /* Iterator */,
-  [Symbol.match]: 4 /* Match */,
-  [Symbol.matchAll]: 5 /* MatchAll */,
-  [Symbol.replace]: 6 /* Replace */,
-  [Symbol.search]: 7 /* Search */,
-  [Symbol.species]: 8 /* Species */,
-  [Symbol.split]: 9 /* Split */,
-  [Symbol.toPrimitive]: 10 /* ToPrimitive */,
-  [Symbol.toStringTag]: 11 /* ToStringTag */,
-  [Symbol.unscopables]: 12 /* Unscopables */
-};
-var SYMBOL_REF = {
-  [0 /* AsyncIterator */]: Symbol.asyncIterator,
-  [1 /* HasInstance */]: Symbol.hasInstance,
-  [2 /* IsConcatSpreadable */]: Symbol.isConcatSpreadable,
-  [3 /* Iterator */]: Symbol.iterator,
-  [4 /* Match */]: Symbol.match,
-  [5 /* MatchAll */]: Symbol.matchAll,
-  [6 /* Replace */]: Symbol.replace,
-  [7 /* Search */]: Symbol.search,
-  [8 /* Species */]: Symbol.species,
-  [9 /* Split */]: Symbol.split,
-  [10 /* ToPrimitive */]: Symbol.toPrimitive,
-  [11 /* ToStringTag */]: Symbol.toStringTag,
-  [12 /* Unscopables */]: Symbol.unscopables
-};
-var CONSTANT_STRING = {
-  [2 /* True */]: "!0",
-  [3 /* False */]: "!1",
-  [1 /* Undefined */]: "void 0",
-  [0 /* Null */]: "null",
-  [4 /* NegativeZero */]: "-0",
-  [5 /* Infinity */]: "1/0",
-  [6 /* NegativeInfinity */]: "-1/0",
-  [7 /* NaN */]: "0/0"
-};
-var CONSTANT_VAL = {
-  [2 /* True */]: true,
-  [3 /* False */]: false,
-  [1 /* Undefined */]: void 0,
-  [0 /* Null */]: null,
-  [4 /* NegativeZero */]: -0,
-  [5 /* Infinity */]: Infinity,
-  [6 /* NegativeInfinity */]: -Infinity,
-  [7 /* NaN */]: NaN
-};
-var ERROR_CONSTRUCTOR_STRING = {
-  [0 /* Error */]: "Error",
-  [1 /* EvalError */]: "EvalError",
-  [2 /* RangeError */]: "RangeError",
-  [3 /* ReferenceError */]: "ReferenceError",
-  [4 /* SyntaxError */]: "SyntaxError",
-  [5 /* TypeError */]: "TypeError",
-  [6 /* URIError */]: "URIError"
-};
-var ERROR_CONSTRUCTOR = {
-  [0 /* Error */]: Error,
-  [1 /* EvalError */]: EvalError,
-  [2 /* RangeError */]: RangeError,
-  [3 /* ReferenceError */]: ReferenceError,
-  [4 /* SyntaxError */]: SyntaxError,
-  [5 /* TypeError */]: TypeError,
-  [6 /* URIError */]: URIError
-};
-
-// src/core/literals.ts
-function createConstantNode(value) {
-  return {
-    t: 2 /* Constant */,
-    i: void 0,
-    s: value,
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    p: void 0,
-    e: void 0,
-    a: void 0,
-    f: void 0,
-    b: void 0,
-    o: void 0
-  };
-}
-var TRUE_NODE = createConstantNode(2 /* True */);
-var FALSE_NODE = createConstantNode(3 /* False */);
-var UNDEFINED_NODE = createConstantNode(1 /* Undefined */);
-var NULL_NODE = createConstantNode(0 /* Null */);
-var NEG_ZERO_NODE = createConstantNode(4 /* NegativeZero */);
-var INFINITY_NODE = createConstantNode(5 /* Infinity */);
-var NEG_INFINITY_NODE = createConstantNode(6 /* NegativeInfinity */);
-var NAN_NODE = createConstantNode(7 /* NaN */);
-
 // src/core/string.ts
 function serializeChar(str) {
   switch (str) {
@@ -170,8 +61,37 @@ function serializeString(str) {
   }
   return result;
 }
+function deserializeReplacer(str) {
+  switch (str) {
+    case "\\\\":
+      return "\\";
+    case '\\"':
+      return '"';
+    case "\\n":
+      return "\n";
+    case "\\r":
+      return "\r";
+    case "\\b":
+      return "\b";
+    case "\\t":
+      return "	";
+    case "\\f":
+      return "\f";
+    case "\\x3C":
+      return "<";
+    case "\\u2028":
+      return "\u2028";
+    case "\\u2029":
+      return "\u2029";
+    default:
+      return str;
+  }
+}
 function deserializeString(str) {
-  return str.replace(/\\"/g, '"').replace(/\\\\/g, "\\").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\b/g, "\b").replace(/\\t/g, "	").replace(/\\f/g, "\f").replace(/\\x3C/g, "<").replace(/\\u2028/g, "\u2028").replace(/\\u2029/g, "\u2029");
+  return str.replace(
+    /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,
+    deserializeReplacer
+  );
 }
 
 // src/core/keys.ts
@@ -182,7 +102,9 @@ function getCrossReferenceHeader(id) {
   if (id == null) {
     return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
   }
-  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(id)}"]=[]`;
+  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(
+    id
+  )}"]=[]`;
 }
 
 // src/core/reference.ts
@@ -207,28 +129,28 @@ function getReference(id) {
   assert(hasReference(id), new Error("Missing reference for id:" + id));
   return INV_REFERENCE.get(id);
 }
-if (typeof globalThis !== void 0) {
+if (typeof globalThis !== "undefined") {
   Object.defineProperty(globalThis, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false
   });
-} else if (typeof window !== void 0) {
+} else if (typeof window !== "undefined") {
   Object.defineProperty(window, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false
   });
-} else if (typeof self !== void 0) {
+} else if (typeof self !== "undefined") {
   Object.defineProperty(self, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false
   });
-} else if (typeof global !== void 0) {
+} else if (typeof global !== "undefined") {
   Object.defineProperty(global, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
@@ -237,24 +159,163 @@ if (typeof globalThis !== void 0) {
   });
 }
 
-// src/core/compat.ts
-var Feature = /* @__PURE__ */ ((Feature2) => {
-  Feature2[Feature2["AggregateError"] = 1] = "AggregateError";
-  Feature2[Feature2["ArrowFunction"] = 4] = "ArrowFunction";
-  Feature2[Feature2["BigInt"] = 8] = "BigInt";
-  Feature2[Feature2["ErrorPrototypeStack"] = 16] = "ErrorPrototypeStack";
-  Feature2[Feature2["Map"] = 32] = "Map";
-  Feature2[Feature2["ObjectAssign"] = 128] = "ObjectAssign";
-  Feature2[Feature2["Promise"] = 256] = "Promise";
-  Feature2[Feature2["Set"] = 512] = "Set";
-  Feature2[Feature2["Symbol"] = 1024] = "Symbol";
-  Feature2[Feature2["TypedArray"] = 2048] = "TypedArray";
-  Feature2[Feature2["BigIntTypedArray"] = 4096] = "BigIntTypedArray";
-  Feature2[Feature2["WebAPI"] = 8192] = "WebAPI";
-  return Feature2;
-})(Feature || {});
-var ALL_ENABLED = 16383;
-var BIGINT_FLAG = 4096 /* BigIntTypedArray */ | 8 /* BigInt */;
+// src/core/plugin.ts
+function createPlugin(plugin) {
+  return plugin;
+}
+function dedupePlugins(deduped, plugins) {
+  for (let i = 0, len = plugins.length; i < len; i++) {
+    const current = plugins[i];
+    if (!deduped.has(current)) {
+      deduped.add(current);
+      if (current.extends) {
+        dedupePlugins(deduped, current.extends);
+      }
+    }
+  }
+}
+function resolvePlugins(plugins) {
+  if (plugins) {
+    const deduped = /* @__PURE__ */ new Set();
+    dedupePlugins(deduped, plugins);
+    return [...deduped];
+  }
+  return void 0;
+}
+
+// src/core/UnsupportedTypeError.ts
+var { toString: objectToString } = Object.prototype;
+var UnsupportedTypeError = class extends Error {
+  constructor(value) {
+    super('Unsupported type "' + objectToString.call(value) + '"');
+    this.value = value;
+  }
+};
+
+// src/core/constants.ts
+var SYMBOL_STRING = {
+  [0 /* AsyncIterator */]: "Symbol.asyncIterator",
+  [1 /* HasInstance */]: "Symbol.hasInstance",
+  [2 /* IsConcatSpreadable */]: "Symbol.isConcatSpreadable",
+  [3 /* Iterator */]: "Symbol.iterator",
+  [4 /* Match */]: "Symbol.match",
+  [5 /* MatchAll */]: "Symbol.matchAll",
+  [6 /* Replace */]: "Symbol.replace",
+  [7 /* Search */]: "Symbol.search",
+  [8 /* Species */]: "Symbol.species",
+  [9 /* Split */]: "Symbol.split",
+  [10 /* ToPrimitive */]: "Symbol.toPrimitive",
+  [11 /* ToStringTag */]: "Symbol.toStringTag",
+  [12 /* Unscopables */]: "Symbol.unscopables"
+};
+var INV_SYMBOL_REF = {
+  [Symbol.asyncIterator]: 0 /* AsyncIterator */,
+  [Symbol.hasInstance]: 1 /* HasInstance */,
+  [Symbol.isConcatSpreadable]: 2 /* IsConcatSpreadable */,
+  [Symbol.iterator]: 3 /* Iterator */,
+  [Symbol.match]: 4 /* Match */,
+  [Symbol.matchAll]: 5 /* MatchAll */,
+  [Symbol.replace]: 6 /* Replace */,
+  [Symbol.search]: 7 /* Search */,
+  [Symbol.species]: 8 /* Species */,
+  [Symbol.split]: 9 /* Split */,
+  [Symbol.toPrimitive]: 10 /* ToPrimitive */,
+  [Symbol.toStringTag]: 11 /* ToStringTag */,
+  [Symbol.unscopables]: 12 /* Unscopables */
+};
+var SYMBOL_REF = {
+  [0 /* AsyncIterator */]: Symbol.asyncIterator,
+  [1 /* HasInstance */]: Symbol.hasInstance,
+  [2 /* IsConcatSpreadable */]: Symbol.isConcatSpreadable,
+  [3 /* Iterator */]: Symbol.iterator,
+  [4 /* Match */]: Symbol.match,
+  [5 /* MatchAll */]: Symbol.matchAll,
+  [6 /* Replace */]: Symbol.replace,
+  [7 /* Search */]: Symbol.search,
+  [8 /* Species */]: Symbol.species,
+  [9 /* Split */]: Symbol.split,
+  [10 /* ToPrimitive */]: Symbol.toPrimitive,
+  [11 /* ToStringTag */]: Symbol.toStringTag,
+  [12 /* Unscopables */]: Symbol.unscopables
+};
+var CONSTANT_STRING = {
+  [2 /* True */]: "!0",
+  [3 /* False */]: "!1",
+  [1 /* Undefined */]: "void 0",
+  [0 /* Null */]: "null",
+  [4 /* NegativeZero */]: "-0",
+  [5 /* Infinity */]: "1/0",
+  [6 /* NegativeInfinity */]: "-1/0",
+  [7 /* NaN */]: "0/0"
+};
+var CONSTANT_VAL = {
+  [2 /* True */]: true,
+  [3 /* False */]: false,
+  [1 /* Undefined */]: void 0,
+  [0 /* Null */]: null,
+  [4 /* NegativeZero */]: -0,
+  [5 /* Infinity */]: Infinity,
+  [6 /* NegativeInfinity */]: -Infinity,
+  [7 /* NaN */]: NaN
+};
+var ERROR_CONSTRUCTOR_STRING = {
+  [0 /* Error */]: "Error",
+  [1 /* EvalError */]: "EvalError",
+  [2 /* RangeError */]: "RangeError",
+  [3 /* ReferenceError */]: "ReferenceError",
+  [4 /* SyntaxError */]: "SyntaxError",
+  [5 /* TypeError */]: "TypeError",
+  [6 /* URIError */]: "URIError"
+};
+var ERROR_CONSTRUCTOR = {
+  [0 /* Error */]: Error,
+  [1 /* EvalError */]: EvalError,
+  [2 /* RangeError */]: RangeError,
+  [3 /* ReferenceError */]: ReferenceError,
+  [4 /* SyntaxError */]: SyntaxError,
+  [5 /* TypeError */]: TypeError,
+  [6 /* URIError */]: URIError
+};
+
+// src/core/literals.ts
+function createConstantNode(value) {
+  return {
+    t: 2 /* Constant */,
+    i: void 0,
+    s: value,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
+var TRUE_NODE = /* @__PURE__ */ createConstantNode(
+  2 /* True */
+);
+var FALSE_NODE = /* @__PURE__ */ createConstantNode(
+  3 /* False */
+);
+var UNDEFINED_NODE = /* @__PURE__ */ createConstantNode(
+  1 /* Undefined */
+);
+var NULL_NODE = /* @__PURE__ */ createConstantNode(
+  0 /* Null */
+);
+var NEG_ZERO_NODE = /* @__PURE__ */ createConstantNode(
+  4 /* NegativeZero */
+);
+var INFINITY_NODE = /* @__PURE__ */ createConstantNode(
+  5 /* Infinity */
+);
+var NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(
+  6 /* NegativeInfinity */
+);
+var NAN_NODE = /* @__PURE__ */ createConstantNode(7 /* NaN */);
 
 // src/core/utils/error.ts
 function getErrorConstructor(error) {
@@ -278,20 +339,24 @@ function getErrorConstructor(error) {
   }
   return 0 /* Error */;
 }
-function getErrorOptions(error, features) {
-  let options;
-  const constructor = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
-  if (error.name !== constructor) {
-    options = { name: error.name };
-  } else if (error.constructor.name !== constructor) {
-    options = { name: error.constructor.name };
+function getInitialErrorOptions(error) {
+  const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
+  if (error.name !== construct) {
+    return { name: error.name };
+  }
+  if (error.constructor.name !== construct) {
+    return { name: error.constructor.name };
   }
+  return {};
+}
+function getErrorOptions(error, features) {
+  let options = getInitialErrorOptions(error);
   const names = Object.getOwnPropertyNames(error);
   for (let i = 0, len = names.length, name; i < len; i++) {
     name = names[i];
     if (name !== "name" && name !== "message") {
       if (name === "stack") {
-        if (features & 16 /* ErrorPrototypeStack */) {
+        if (features & 4 /* ErrorPrototypeStack */) {
           options = options || {};
           options[name] = error[name];
         }
@@ -325,31 +390,30 @@ function createNumberNode(value) {
       return INFINITY_NODE;
     case -Infinity:
       return NEG_INFINITY_NODE;
-    default:
-      if (value !== value) {
-        return NAN_NODE;
-      }
-      if (Object.is(value, -0)) {
-        return NEG_ZERO_NODE;
-      }
-      return {
-        t: 0 /* Number */,
-        i: void 0,
-        s: value,
-        l: void 0,
-        c: void 0,
-        m: void 0,
-        p: void 0,
-        e: void 0,
-        a: void 0,
-        f: void 0,
-        b: void 0,
-        o: void 0
-      };
   }
-}
-function createStringNode(value) {
-  return {
+  if (value !== value) {
+    return NAN_NODE;
+  }
+  if (Object.is(value, -0)) {
+    return NEG_ZERO_NODE;
+  }
+  return {
+    t: 0 /* Number */,
+    i: void 0,
+    s: value,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
+function createStringNode(value) {
+  return {
     t: 1 /* String */,
     i: void 0,
     s: serializeString(value),
@@ -418,7 +482,7 @@ function createRegExpNode(id, current) {
     i: id,
     s: void 0,
     l: void 0,
-    c: current.source,
+    c: serializeString(current.source),
     m: current.flags,
     p: void 0,
     e: void 0,
@@ -436,7 +500,7 @@ function createArrayBufferNode(id, current) {
     values[i] = bytes[i];
   }
   return {
-    t: 21 /* ArrayBuffer */,
+    t: 19 /* ArrayBuffer */,
     i: id,
     s: values,
     l: void 0,
@@ -451,7 +515,10 @@ function createArrayBufferNode(id, current) {
   };
 }
 function createWKSymbolNode(id, current) {
-  assert(current in INV_SYMBOL_REF, new Error("Only well-known symbols are supported."));
+  assert(
+    current in INV_SYMBOL_REF,
+    new Error("Only well-known symbols are supported.")
+  );
   return {
     t: 17 /* WKSymbol */,
     i: id,
@@ -469,7 +536,7 @@ function createWKSymbolNode(id, current) {
 }
 function createReferenceNode(id, ref) {
   return {
-    t: 20 /* Reference */,
+    t: 18 /* Reference */,
     i: id,
     s: serializeString(getReferenceID(ref)),
     l: void 0,
@@ -485,7 +552,7 @@ function createReferenceNode(id, ref) {
 }
 function createPluginNode(id, tag, value) {
   return {
-    t: 40 /* Plugin */,
+    t: 25 /* Plugin */,
     i: id,
     s: value,
     l: void 0,
@@ -517,7 +584,7 @@ function createArrayNode(id, current, parsedItems) {
 }
 function createBoxedNode(id, boxed) {
   return {
-    t: 27 /* Boxed */,
+    t: 21 /* Boxed */,
     i: id,
     s: void 0,
     l: void 0,
@@ -565,7 +632,7 @@ function createBigIntTypedArrayNode(id, current, buffer) {
 }
 function createDataViewNode(id, current, buffer) {
   return {
-    t: 22 /* DataView */,
+    t: 20 /* DataView */,
     i: id,
     s: void 0,
     l: current.byteLength,
@@ -629,7 +696,7 @@ function createSetNode(id, size, items) {
 }
 function createIteratorFactoryInstanceNode(factory, items) {
   return {
-    t: 43 /* IteratorFactoryInstance */,
+    t: 28 /* IteratorFactoryInstance */,
     i: void 0,
     s: void 0,
     l: void 0,
@@ -637,10 +704,7 @@ function createIteratorFactoryInstanceNode(factory, items) {
     m: void 0,
     p: void 0,
     e: void 0,
-    a: [
-      factory,
-      items
-    ],
+    a: [factory, items],
     f: void 0,
     b: void 0,
     o: void 0
@@ -648,7 +712,7 @@ function createIteratorFactoryInstanceNode(factory, items) {
 }
 function createAsyncIteratorFactoryInstanceNode(factory, items) {
   return {
-    t: 45 /* AsyncIteratorFactoryInstance */,
+    t: 30 /* AsyncIteratorFactoryInstance */,
     i: void 0,
     s: void 0,
     l: void 0,
@@ -656,52 +720,74 @@ function createAsyncIteratorFactoryInstanceNode(factory, items) {
     m: void 0,
     p: void 0,
     e: void 0,
-    a: [
-      factory,
-      items
-    ],
+    a: [factory, items],
     f: void 0,
     b: void 0,
     o: void 0
   };
 }
-
-// src/core/utils/constructors.ts
-function createRequestOptions(current, body) {
+function createStreamConstructorNode(id, factory, sequence) {
   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
+    t: 31 /* StreamConstructor */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: sequence,
+    f: factory,
+    b: void 0,
+    o: void 0
   };
 }
-function createResponseOptions(current) {
+function createStreamNextNode(id, parsed) {
   return {
-    headers: current.headers,
-    status: current.status,
-    statusText: current.statusText
+    t: 32 /* StreamNext */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parsed,
+    b: void 0,
+    o: void 0
   };
 }
-function createEventOptions(current) {
+function createStreamThrowNode(id, parsed) {
   return {
-    bubbles: current.bubbles,
-    cancelable: current.cancelable,
-    composed: current.composed
+    t: 33 /* StreamThrow */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parsed,
+    b: void 0,
+    o: void 0
   };
 }
-function createCustomEventOptions(current) {
+function createStreamReturnNode(id, parsed) {
   return {
-    detail: current.detail,
-    bubbles: current.bubbles,
-    cancelable: current.cancelable,
-    composed: current.composed
+    t: 34 /* StreamReturn */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: parsed,
+    b: void 0,
+    o: void 0
   };
 }
 
@@ -757,163 +843,16 @@ function sequenceToIterator(sequence) {
     };
   };
 }
-async function asyncIteratorToSequence(source) {
-  const values = [];
-  let throwsAt = -1;
-  let doneAt = -1;
-  const iterator = source[Symbol.asyncIterator]();
-  while (true) {
-    try {
-      const value = await iterator.next();
-      values.push(value.value);
-      if (value.done) {
-        doneAt = values.length - 1;
-        break;
-      }
-    } catch (error) {
-      throwsAt = values.length;
-      values.push(error);
-    }
-  }
-  return {
-    v: values,
-    t: throwsAt,
-    d: doneAt
-  };
-}
-function sequenceToAsyncIterator(sequence) {
-  return () => {
-    let index = 0;
-    return {
-      [Symbol.asyncIterator]() {
-        return this;
-      },
-      async next() {
-        if (index > sequence.d) {
-          return {
-            done: true,
-            value: void 0
-          };
-        }
-        const currentIndex = index++;
-        const currentItem = sequence.v[currentIndex];
-        if (currentIndex === sequence.t) {
-          throw currentItem;
-        }
-        return Promise.resolve({
-          done: currentIndex === sequence.d,
-          value: currentItem
-        });
-      }
-    };
-  };
-}
-function asyncIteratorToReadableStream(source, parser) {
-  return new ReadableStream({
-    async start(controller) {
-      const iterator = source[Symbol.asyncIterator]();
-      while (parser.isAlive()) {
-        try {
-          const result = await iterator.next();
-          controller.enqueue([result.done ? 2 : 0, result.value]);
-          if (result.done) {
-            controller.close();
-            return;
-          }
-        } catch (error) {
-          controller.enqueue([1, error]);
-        }
-      }
-      controller.close();
-    }
-  });
-}
-function readableStreamToAsyncIterator(source) {
-  let current = source;
-  return () => {
-    const [left, right] = current.tee();
-    const clone = left;
-    current = right;
-    const reader = clone.getReader();
-    return {
-      [Symbol.asyncIterator]() {
-        return this;
-      },
-      async next() {
-        const result = await reader.read();
-        if (result.done) {
-          return {
-            done: true,
-            value: void 0
-          };
-        }
-        const [status, value] = result.value;
-        if (status === 1) {
-          throw value;
-        }
-        return {
-          done: status === 2,
-          value
-        };
-      }
-    };
-  };
-}
-async function readableStreamToSequence(stream) {
-  const values = [];
-  let throwsAt = -1;
-  let doneAt = -1;
-  const iterator = stream.getReader();
-  while (true) {
-    try {
-      const value = await iterator.read();
-      values.push(value.value);
-      if (value.done) {
-        doneAt = values.length - 1;
-        break;
-      }
-    } catch (error) {
-      throwsAt = values.length;
-      doneAt = throwsAt;
-      values.push(error);
-      break;
-    }
-  }
-  return {
-    v: values,
-    t: throwsAt,
-    d: doneAt
-  };
-}
-function sequenceToReadableStream(sequence) {
-  return new ReadableStream({
-    start(controller) {
-      for (let i = 0; i < sequence.d; i++) {
-        controller.enqueue(sequence.v[i]);
-      }
-      if (sequence.t === -1) {
-        controller.close();
-      } else {
-        controller.error(sequence.v[sequence.t]);
-      }
-    }
-  });
-}
 
 // src/core/special-reference.ts
-var UNIVERSAL_SENTINEL = {};
 var ITERATOR = {};
 var ASYNC_ITERATOR = {};
 var SPECIAL_REFS = {
   [0 /* MapSentinel */]: {},
-  [1 /* ReadableStream */]: {},
-  [2 /* PromiseConstructor */]: {},
-  [3 /* PromiseResolve */]: {},
-  [4 /* PromiseReject */]: {},
-  [5 /* ReadableStreamConstructor */]: {},
-  [6 /* ReadableStreamEnqueue */]: {},
-  [7 /* ReadableStreamError */]: {},
-  [8 /* ReadableStreamClose */]: {}
+  [1 /* PromiseConstructor */]: {},
+  [2 /* PromiseResolve */]: {},
+  [3 /* PromiseReject */]: {},
+  [4 /* StreamConstructor */]: {}
 };
 
 // src/core/context/parser.ts
@@ -930,62 +869,70 @@ var BaseParserContext = class {
   isMarked(id) {
     return this.marked.has(id);
   }
-  getReference(current) {
-    const registeredID = this.refs.get(current);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+  getIndexedValue(current) {
+    const registeredId = this.refs.get(current);
+    if (registeredId != null) {
+      this.markRef(registeredId);
+      return {
+        type: 1,
+        value: createIndexedValueNode(registeredId)
+      };
     }
     const id = this.refs.size;
     this.refs.set(current, id);
+    return {
+      type: 0,
+      value: id
+    };
+  }
+  getReference(current) {
+    const indexed = this.getIndexedValue(current);
+    if (indexed.type === 1) {
+      return indexed;
+    }
     if (hasReferenceID(current)) {
-      return createReferenceNode(id, current);
+      return {
+        type: 2,
+        value: createReferenceNode(indexed.value, current)
+      };
     }
-    return id;
+    return indexed;
   }
   getStrictReference(current) {
-    const registeredID = this.refs.get(current);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+    assert(
+      hasReferenceID(current),
+      new Error(
+        "Cannot serialize " + typeof current + " without reference ID."
+      )
+    );
+    const result = this.getIndexedValue(current);
+    if (result.type === 1) {
+      return result.value;
     }
-    const id = this.refs.size;
-    this.refs.set(current, id);
-    return createReferenceNode(id, current);
+    return createReferenceNode(result.value, current);
   }
-  // eslint-disable-next-line @typescript-eslint/ban-types
   parseFunction(current) {
-    assert(hasReferenceID(current), new Error("Cannot serialize function without reference ID."));
     return this.getStrictReference(current);
   }
-  parseWKSymbol(current) {
-    assert(this.features & 1024 /* Symbol */, new UnsupportedTypeError(current));
-    const registeredID = this.refs.get(current);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
-    }
-    const isValid = current in INV_SYMBOL_REF;
-    assert(current in INV_SYMBOL_REF || hasReferenceID(current), new Error("Cannot serialize symbol without reference ID."));
-    const id = this.refs.size;
-    this.refs.set(current, id);
-    if (isValid) {
-      return createWKSymbolNode(id, current);
+  parseWellKnownSymbol(current) {
+    const ref = this.getReference(current);
+    if (ref.type !== 0) {
+      return ref.value;
     }
-    return createReferenceNode(id, current);
+    assert(
+      current in INV_SYMBOL_REF,
+      new Error("Cannot serialized unsupported symbol.")
+    );
+    return createWKSymbolNode(ref.value, current);
   }
   parseSpecialReference(ref) {
-    const specialRef = SPECIAL_REFS[ref];
-    const registeredID = this.refs.get(specialRef);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+    const result = this.getIndexedValue(SPECIAL_REFS[ref]);
+    if (result.type === 1) {
+      return result.value;
     }
-    const id = this.refs.size;
-    this.refs.set(specialRef, id);
     return {
-      t: 41 /* SpecialReference */,
-      i: id,
+      t: 26 /* SpecialReference */,
+      i: result.value,
       s: ref,
       l: void 0,
       c: void 0,
@@ -999,16 +946,13 @@ var BaseParserContext = class {
     };
   }
   parseIteratorFactory() {
-    const registeredID = this.refs.get(ITERATOR);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+    const result = this.getIndexedValue(ITERATOR);
+    if (result.type === 1) {
+      return result.value;
     }
-    const id = this.refs.size;
-    this.refs.set(ITERATOR, id);
     return {
-      t: 42 /* IteratorFactory */,
-      i: id,
+      t: 27 /* IteratorFactory */,
+      i: result.value,
       s: void 0,
       l: void 0,
       c: void 0,
@@ -1016,30 +960,30 @@ var BaseParserContext = class {
       p: void 0,
       e: void 0,
       a: void 0,
-      f: this.parseWKSymbol(Symbol.iterator),
+      f: this.parseWellKnownSymbol(Symbol.iterator),
       b: void 0,
       o: void 0
     };
   }
-  parseAsyncIteratorFactory(streaming) {
-    const registeredID = this.refs.get(ASYNC_ITERATOR);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+  parseAsyncIteratorFactory() {
+    const result = this.getIndexedValue(ASYNC_ITERATOR);
+    if (result.type === 1) {
+      return result.value;
     }
-    const id = this.refs.size;
-    this.refs.set(ASYNC_ITERATOR, id);
     return {
-      t: 44 /* AsyncIteratorFactory */,
-      i: id,
-      s: streaming,
+      t: 29 /* AsyncIteratorFactory */,
+      i: result.value,
+      s: void 0,
       l: void 0,
       c: void 0,
       m: void 0,
       p: void 0,
       e: void 0,
-      a: void 0,
-      f: this.parseWKSymbol(Symbol.asyncIterator),
+      a: [
+        this.parseSpecialReference(1 /* PromiseConstructor */),
+        this.parseWellKnownSymbol(Symbol.asyncIterator)
+      ],
+      f: void 0,
       b: void 0,
       o: void 0
     };
@@ -1087,104 +1031,189 @@ async function promiseToResult(current) {
   }
 }
 
-// src/core/web-api.ts
-function createURLNode(id, current) {
-  return {
-    t: 18 /* URL */,
-    i: id,
-    s: serializeString(current.href),
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    p: void 0,
-    e: void 0,
-    f: void 0,
-    a: void 0,
-    b: void 0,
-    o: void 0
-  };
-}
-function createURLSearchParamsNode(id, current) {
+// src/core/utils/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
   return {
-    t: 19 /* URLSearchParams */,
-    i: id,
-    s: serializeString(current.toString()),
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    p: void 0,
-    e: void 0,
-    f: void 0,
-    a: void 0,
-    b: void 0,
-    o: void 0
+    promise: new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    }),
+    resolve(value) {
+      resolve(value);
+    },
+    reject(value) {
+      reject(value);
+    }
   };
 }
-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/stream.ts
+function isStream(value) {
+  return "__SEROVAL_STREAM__" in value;
 }
-function createEventNode(id, type, options) {
+function createStream() {
+  const listeners = /* @__PURE__ */ new Set();
+  const buffer = [];
+  let alive = true;
+  let success = false;
+  function flushNext(value) {
+    for (const listener of listeners.keys()) {
+      listener.next(value);
+    }
+  }
+  function flushThrow(value) {
+    for (const listener of listeners.keys()) {
+      listener.throw(value);
+    }
+  }
+  function flushReturn(value) {
+    for (const listener of listeners.keys()) {
+      listener.return(value);
+    }
+  }
   return {
-    t: 37 /* Event */,
-    i: id,
-    s: serializeString(type),
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    p: void 0,
-    e: void 0,
-    a: void 0,
-    f: options,
-    b: void 0,
-    o: void 0
+    __SEROVAL_STREAM__: true,
+    on(listener) {
+      if (alive) {
+        listeners.add(listener);
+      }
+      for (let i = 0, len = buffer.length; i < len; i++) {
+        const value = buffer[i];
+        if (i === len - 1) {
+          if (success) {
+            listener.return(value);
+          } else {
+            listener.throw(value);
+          }
+        } else {
+          listener.next(value);
+        }
+      }
+      return () => {
+        if (alive) {
+          listeners.delete(listener);
+        }
+      };
+    },
+    next(value) {
+      if (alive) {
+        buffer.push(value);
+        flushNext(value);
+      }
+    },
+    throw(value) {
+      if (alive) {
+        buffer.push(value);
+        flushThrow(value);
+        alive = false;
+        success = false;
+        listeners.clear();
+      }
+    },
+    return(value) {
+      if (alive) {
+        buffer.push(value);
+        flushReturn(value);
+        alive = false;
+        success = true;
+        listeners.clear();
+      }
+    }
   };
 }
-function createCustomEventNode(id, type, options) {
-  return {
-    t: 38 /* CustomEvent */,
-    i: id,
-    s: serializeString(type),
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    p: void 0,
-    e: void 0,
-    a: void 0,
-    f: options,
-    b: void 0,
-    o: void 0
-  };
+function createStreamFromAsyncIterable(iterable) {
+  const stream = createStream();
+  const iterator = iterable[Symbol.asyncIterator]();
+  async function push() {
+    try {
+      const value = await iterator.next();
+      if (value.done) {
+        stream.return(value.value);
+      } else {
+        stream.next(value.value);
+        await push();
+      }
+    } catch (error) {
+      stream.throw(error);
+    }
+  }
+  push().catch(() => {
+  });
+  return stream;
 }
-function createReadableStreamNode(id, factory, items) {
-  return {
-    t: 46 /* ReadableStream */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    c: void 0,
-    m: void 0,
-    p: void 0,
-    e: void 0,
-    a: [
-      factory,
-      items
-    ],
-    f: void 0,
-    b: void 0,
-    o: void 0
+function streamToAsyncIterable(stream) {
+  return () => {
+    const buffer = [];
+    const pending = [];
+    let count = 0;
+    let doneAt = -1;
+    let isThrow = false;
+    function resolveAll() {
+      for (let i = 0, len = pending.length; i < len; i++) {
+        pending[i].resolve({ done: true, value: void 0 });
+      }
+    }
+    stream.on({
+      next(value) {
+        const current = pending.shift();
+        if (current) {
+          current.resolve({ done: false, value });
+        }
+        buffer.push(value);
+      },
+      throw(value) {
+        const current = pending.shift();
+        if (current) {
+          current.reject(value);
+        }
+        resolveAll();
+        doneAt = buffer.length;
+        buffer.push(value);
+        isThrow = true;
+      },
+      return(value) {
+        const current = pending.shift();
+        if (current) {
+          current.resolve({ done: true, value });
+        }
+        resolveAll();
+        doneAt = buffer.length;
+        buffer.push(value);
+      }
+    });
+    function finalize() {
+      const current = count++;
+      const value = buffer[current];
+      if (current !== doneAt) {
+        return { done: false, value };
+      }
+      if (isThrow) {
+        throw value;
+      }
+      return { done: true, value };
+    }
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        if (doneAt === -1) {
+          const current = count++;
+          if (current >= buffer.length) {
+            const deferred = createDeferred();
+            pending.push(deferred);
+            return await deferred.promise;
+          }
+          return { done: false, value: buffer[current] };
+        }
+        if (count > doneAt) {
+          return { done: true, value: void 0 };
+        }
+        return finalize();
+      }
+    };
   };
 }
 
@@ -1200,256 +1229,114 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     return nodes;
   }
   async parseArray(id, current) {
-    return createArrayNode(
-      id,
-      current,
-      await this.parseItems(current)
-    );
-  }
-  async parseProperties(properties) {
-    const entries = Object.entries(properties);
-    const keyNodes = [];
-    const valueNodes = [];
-    for (let i = 0, len = entries.length; i < len; i++) {
-      keyNodes.push(serializeString(entries[i][0]));
-      valueNodes.push(await this.parse(entries[i][1]));
-    }
-    if (this.features & 1024 /* Symbol */) {
-      let symbol = Symbol.iterator;
-      if (symbol in properties) {
-        keyNodes.push(
-          this.parseWKSymbol(symbol)
-        );
-        valueNodes.push(
-          createIteratorFactoryInstanceNode(
-            this.parseIteratorFactory(),
-            await this.parse(
-              iteratorToSequence(properties)
-            )
-          )
-        );
-      }
-      symbol = Symbol.asyncIterator;
-      if (symbol in properties) {
-        keyNodes.push(
-          this.parseWKSymbol(symbol)
-        );
-        valueNodes.push(
-          createAsyncIteratorFactoryInstanceNode(
-            this.parseAsyncIteratorFactory(0),
-            await this.parse(
-              await asyncIteratorToSequence(properties)
-            )
-          )
-        );
-      }
-      symbol = Symbol.toStringTag;
-      if (symbol in properties) {
-        keyNodes.push(this.parseWKSymbol(symbol));
-        valueNodes.push(createStringNode(properties[symbol]));
-      }
-      symbol = Symbol.isConcatSpreadable;
-      if (symbol in properties) {
-        keyNodes.push(this.parseWKSymbol(symbol));
-        valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
-      }
-    }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: keyNodes.length
-    };
-  }
-  async parsePlainObject(id, current, empty) {
-    return this.createObjectNode(
-      id,
-      current,
-      empty,
-      await this.parseProperties(current)
-    );
-  }
-  async parseBoxed(id, current) {
-    return createBoxedNode(id, await this.parse(current.valueOf()));
-  }
-  async parseTypedArray(id, current) {
-    return createTypedArrayNode(id, current, await this.parse(current.buffer));
-  }
-  async parseBigIntTypedArray(id, current) {
-    return createBigIntTypedArrayNode(id, current, await this.parse(current.buffer));
-  }
-  async parseDataView(id, current) {
-    return createDataViewNode(id, current, await this.parse(current.buffer));
-  }
-  async parseError(id, current) {
-    const options = getErrorOptions(current, this.features);
-    return createErrorNode(
-      id,
-      current,
-      options ? await this.parseProperties(options) : void 0
-    );
-  }
-  async parseAggregateError(id, current) {
-    const options = getErrorOptions(current, this.features);
-    return createAggregateErrorNode(
-      id,
-      current,
-      options ? await this.parseProperties(options) : void 0
-    );
-  }
-  async parseMap(id, current) {
-    const keyNodes = [];
-    const valueNodes = [];
-    for (const [key, value] of current.entries()) {
-      keyNodes.push(await this.parse(key));
-      valueNodes.push(await this.parse(value));
-    }
-    return this.createMapNode(
-      id,
-      keyNodes,
-      valueNodes,
-      current.size
-    );
-  }
-  async parseSet(id, current) {
-    const items = [];
-    for (const item of current.keys()) {
-      items.push(await this.parse(item));
-    }
-    return createSetNode(id, current.size, items);
-  }
-  async parseBlob(id, current) {
-    return {
-      t: 23 /* Blob */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: serializeString(current.type),
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      f: await this.parse(await current.arrayBuffer()),
-      a: void 0,
-      b: void 0,
-      o: void 0
-    };
-  }
-  async parseFile(id, current) {
-    return {
-      t: 24 /* File */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: serializeString(current.type),
-      m: serializeString(current.name),
-      p: void 0,
-      e: void 0,
-      f: await this.parse(await current.arrayBuffer()),
-      a: void 0,
-      b: current.lastModified,
-      o: void 0
-    };
-  }
-  async parsePlainProperties(entries) {
-    const size = entries.length;
-    const keyNodes = [];
-    const valueNodes = [];
-    for (let i = 0; i < size; i++) {
-      keyNodes.push(serializeString(entries[i][0]));
-      valueNodes.push(await this.parse(entries[i][1]));
-    }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: size
-    };
-  }
-  async parseHeaders(id, current) {
-    const items = [];
-    current.forEach((value, key) => {
-      items.push([key, value]);
-    });
-    return {
-      t: 25 /* Headers */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: await this.parsePlainProperties(items),
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
-  }
-  async parseFormData(id, current) {
-    const items = [];
-    current.forEach((value, key) => {
-      items.push([key, value]);
-    });
-    return {
-      t: 26 /* FormData */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: await this.parsePlainProperties(items),
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
+    return createArrayNode(id, current, await this.parseItems(current));
   }
-  async parseRequest(id, current) {
+  async parseProperties(properties) {
+    const entries = Object.entries(properties);
+    const keyNodes = [];
+    const valueNodes = [];
+    for (let i = 0, len = entries.length; i < len; i++) {
+      keyNodes.push(serializeString(entries[i][0]));
+      valueNodes.push(await this.parse(entries[i][1]));
+    }
+    let symbol = Symbol.iterator;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(
+        createIteratorFactoryInstanceNode(
+          this.parseIteratorFactory(),
+          await this.parse(
+            iteratorToSequence(properties)
+          )
+        )
+      );
+    }
+    symbol = Symbol.asyncIterator;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(
+        createAsyncIteratorFactoryInstanceNode(
+          this.parseAsyncIteratorFactory(),
+          await this.parse(
+            createStreamFromAsyncIterable(
+              properties
+            )
+          )
+        )
+      );
+    }
+    symbol = Symbol.toStringTag;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(createStringNode(properties[symbol]));
+    }
+    symbol = Symbol.isConcatSpreadable;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
+    }
     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 this.parse(
-        createRequestOptions(current, current.body ? await current.clone().arrayBuffer() : null)
-      ),
-      a: void 0,
-      b: void 0,
-      o: void 0
+      k: keyNodes,
+      v: valueNodes,
+      s: keyNodes.length
     };
   }
-  async parseResponse(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 ? await this.parse(await current.clone().arrayBuffer()) : NULL_NODE,
-        await this.parse(createResponseOptions(current))
-      ],
-      b: void 0,
-      o: void 0
-    };
+  async parsePlainObject(id, current, empty) {
+    return this.createObjectNode(
+      id,
+      current,
+      empty,
+      await this.parseProperties(current)
+    );
+  }
+  async parseBoxed(id, current) {
+    return createBoxedNode(id, await this.parse(current.valueOf()));
+  }
+  async parseTypedArray(id, current) {
+    return createTypedArrayNode(id, current, await this.parse(current.buffer));
+  }
+  async parseBigIntTypedArray(id, current) {
+    return createBigIntTypedArrayNode(
+      id,
+      current,
+      await this.parse(current.buffer)
+    );
+  }
+  async parseDataView(id, current) {
+    return createDataViewNode(id, current, await this.parse(current.buffer));
   }
-  async parseEvent(id, current) {
-    return createEventNode(id, current.type, await this.parse(createEventOptions(current)));
+  async parseError(id, current) {
+    const options = getErrorOptions(current, this.features);
+    return createErrorNode(
+      id,
+      current,
+      options ? await this.parseProperties(options) : void 0
+    );
   }
-  async parseCustomEvent(id, current) {
-    return createCustomEventNode(
+  async parseAggregateError(id, current) {
+    const options = getErrorOptions(current, this.features);
+    return createAggregateErrorNode(
       id,
-      current.type,
-      await this.parse(createCustomEventOptions(current))
+      current,
+      options ? await this.parseProperties(options) : void 0
     );
   }
+  async parseMap(id, current) {
+    const keyNodes = [];
+    const valueNodes = [];
+    for (const [key, value] of current.entries()) {
+      keyNodes.push(await this.parse(key));
+      valueNodes.push(await this.parse(value));
+    }
+    return this.createMapNode(id, keyNodes, valueNodes, current.size);
+  }
+  async parseSet(id, current) {
+    const items = [];
+    for (const item of current.keys()) {
+      items.push(await this.parse(item));
+    }
+    return createSetNode(id, current.size, items);
+  }
   async parsePromise(id, current) {
     const [status, result] = await promiseToResult(current);
     return {
@@ -1485,19 +1372,68 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     }
     return void 0;
   }
-  async parseReadableStream(id, current) {
-    return createReadableStreamNode(
+  async parseStream(id, current) {
+    return createStreamConstructorNode(
       id,
-      this.parseSpecialReference(1 /* ReadableStream */),
-      await this.parse(
-        await readableStreamToSequence(current)
-      )
+      this.parseSpecialReference(4 /* StreamConstructor */),
+      await new Promise((resolve, reject) => {
+        const sequence = [];
+        const cleanup = current.on({
+          next: (value) => {
+            this.markRef(id);
+            this.parse(value).then(
+              (data) => {
+                sequence.push(createStreamNextNode(id, data));
+              },
+              (data) => {
+                reject(data);
+                cleanup();
+              }
+            );
+          },
+          throw: (value) => {
+            this.markRef(id);
+            this.parse(value).then(
+              (data) => {
+                sequence.push(createStreamThrowNode(id, data));
+                resolve(sequence);
+                cleanup();
+              },
+              (data) => {
+                reject(data);
+                cleanup();
+              }
+            );
+          },
+          return: (value) => {
+            this.markRef(id);
+            this.parse(value).then(
+              (data) => {
+                sequence.push(createStreamReturnNode(id, data));
+                resolve(sequence);
+                cleanup();
+              },
+              (data) => {
+                reject(data);
+                cleanup();
+              }
+            );
+          }
+        });
+      })
     );
   }
   async parseObject(id, current) {
     if (Array.isArray(current)) {
       return this.parseArray(id, current);
     }
+    if (isStream(current)) {
+      return this.parseStream(id, current);
+    }
+    const parsed = await this.parsePlugin(id, current);
+    if (parsed) {
+      return parsed;
+    }
     const currentClass = current.constructor;
     switch (currentClass) {
       case Object:
@@ -1529,126 +1465,75 @@ var BaseAsyncParserContext = class extends BaseParserContext {
       case String:
       case BigInt:
         return this.parseBoxed(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 this.parseTypedArray(id, current);
+      case DataView:
+        return this.parseDataView(id, current);
+      case Map:
+        return this.parseMap(id, current);
+      case Set:
+        return this.parseSet(id, current);
       default:
         break;
     }
-    const currentFeatures = this.features;
-    if (currentFeatures & 256 /* Promise */ && (currentClass === Promise || current instanceof Promise)) {
+    if (currentClass === Promise || current instanceof Promise) {
       return this.parsePromise(id, current);
     }
-    if (currentFeatures & 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 this.parseTypedArray(id, current);
-        case DataView:
-          return this.parseDataView(id, current);
-        default:
-          break;
-      }
-    }
-    if ((currentFeatures & BIGINT_FLAG) === BIGINT_FLAG) {
+    const currentFeatures = this.features;
+    if (currentFeatures & 16 /* BigIntTypedArray */) {
       switch (currentClass) {
         case BigInt64Array:
         case BigUint64Array:
-          return this.parseBigIntTypedArray(id, current);
-        default:
-          break;
-      }
-    }
-    if (currentFeatures & 32 /* Map */ && currentClass === Map) {
-      return this.parseMap(
-        id,
-        current
-      );
-    }
-    if (currentFeatures & 512 /* Set */ && currentClass === Set) {
-      return this.parseSet(
-        id,
-        current
-      );
-    }
-    if (currentFeatures & 8192 /* WebAPI */) {
-      switch (currentClass) {
-        case (typeof URL !== "undefined" ? URL : UNIVERSAL_SENTINEL):
-          return createURLNode(id, current);
-        case (typeof URLSearchParams !== "undefined" ? URLSearchParams : UNIVERSAL_SENTINEL):
-          return createURLSearchParamsNode(id, current);
-        case (typeof Blob !== "undefined" ? Blob : UNIVERSAL_SENTINEL):
-          return this.parseBlob(id, current);
-        case (typeof File !== "undefined" ? File : UNIVERSAL_SENTINEL):
-          return this.parseFile(id, current);
-        case (typeof Headers !== "undefined" ? Headers : UNIVERSAL_SENTINEL):
-          return this.parseHeaders(id, current);
-        case (typeof FormData !== "undefined" ? FormData : UNIVERSAL_SENTINEL):
-          return this.parseFormData(id, current);
-        case (typeof Request !== "undefined" ? Request : UNIVERSAL_SENTINEL):
-          return this.parseRequest(id, current);
-        case (typeof Response !== "undefined" ? Response : UNIVERSAL_SENTINEL):
-          return this.parseResponse(id, current);
-        case (typeof Event !== "undefined" ? Event : UNIVERSAL_SENTINEL):
-          return this.parseEvent(id, current);
-        case (typeof CustomEvent !== "undefined" ? CustomEvent : UNIVERSAL_SENTINEL):
-          return this.parseCustomEvent(id, current);
-        case (typeof DOMException !== "undefined" ? DOMException : UNIVERSAL_SENTINEL):
-          return createDOMExceptionNode(id, current);
-        case (typeof ReadableStream !== "undefined" ? ReadableStream : UNIVERSAL_SENTINEL):
-          return this.parseReadableStream(id, current);
+          return this.parseBigIntTypedArray(
+            id,
+            current
+          );
         default:
           break;
       }
     }
-    const parsed = await this.parsePlugin(id, current);
-    if (parsed) {
-      return parsed;
-    }
     if (currentFeatures & 1 /* AggregateError */ && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) {
       return this.parseAggregateError(id, current);
     }
     if (current instanceof Error) {
       return this.parseError(id, current);
     }
-    if (currentFeatures & 1024 /* Symbol */ && (Symbol.iterator in current || Symbol.asyncIterator in current)) {
+    if (Symbol.iterator in current || Symbol.asyncIterator in current) {
       return this.parsePlainObject(id, current, !!currentClass);
     }
     throw new UnsupportedTypeError(current);
   }
   async parse(current) {
-    switch (current) {
-      case true:
-        return TRUE_NODE;
-      case false:
-        return FALSE_NODE;
-      case void 0:
-        return UNDEFINED_NODE;
-      case null:
-        return NULL_NODE;
-      default:
-        break;
-    }
     switch (typeof current) {
+      case "boolean":
+        return current ? TRUE_NODE : FALSE_NODE;
+      case "undefined":
+        return UNDEFINED_NODE;
       case "string":
         return createStringNode(current);
       case "number":
         return createNumberNode(current);
       case "bigint":
-        assert(this.features & 8 /* BigInt */, new UnsupportedTypeError(current));
         return createBigIntNode(current);
       case "object": {
-        const id = this.getReference(current);
-        return typeof id === "number" ? this.parseObject(id, current) : id;
+        if (current) {
+          const ref = this.getReference(current);
+          return ref.type === 0 ? await this.parseObject(ref.value, current) : ref.value;
+        }
+        return NULL_NODE;
       }
       case "symbol":
-        return this.parseWKSymbol(current);
+        return this.parseWellKnownSymbol(current);
       case "function":
         return this.parseFunction(current);
       default:
@@ -1695,43 +1580,6 @@ function getTypedArrayConstructor(name) {
   }
 }
 
-// src/core/utils/deferred.ts
-function createDeferred() {
-  let resolve;
-  let reject;
-  return {
-    promise: new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    }),
-    resolve(value) {
-      resolve(value);
-    },
-    reject(value) {
-      reject(value);
-    }
-  };
-}
-function createDeferredStream() {
-  let controller;
-  return {
-    stream: new ReadableStream({
-      start(current) {
-        controller = current;
-      }
-    }),
-    close() {
-      controller.close();
-    },
-    enqueue(data) {
-      controller.enqueue(data);
-    },
-    error(e) {
-      controller.error(e);
-    }
-  };
-}
-
 // src/core/context/deserializer.ts
 function applyObjectFlag(obj, flag) {
   switch (flag) {
@@ -1751,7 +1599,10 @@ var BaseDeserializerContext = class {
     this.refs = options.refs || /* @__PURE__ */ new Map();
   }
   deserializeReference(node) {
-    return this.assignIndexedValue(node.i, getReference(deserializeString(node.s)));
+    return this.assignIndexedValue(
+      node.i,
+      getReference(deserializeString(node.s))
+    );
   }
   deserializeArray(node) {
     const len = node.l;
@@ -1798,7 +1649,10 @@ var BaseDeserializerContext = class {
     return this.assignIndexedValue(node.i, new Date(node.s));
   }
   deserializeRegExp(node) {
-    return this.assignIndexedValue(node.i, new RegExp(node.c, node.m));
+    return this.assignIndexedValue(
+      node.i,
+      new RegExp(deserializeString(node.c), node.m)
+    );
   }
   deserializeSet(node) {
     const result = this.assignIndexedValue(node.i, /* @__PURE__ */ new Set());
@@ -1809,17 +1663,11 @@ var BaseDeserializerContext = class {
     return result;
   }
   deserializeMap(node) {
-    const result = this.assignIndexedValue(
-      node.i,
-      /* @__PURE__ */ new Map()
-    );
+    const result = this.assignIndexedValue(node.i, /* @__PURE__ */ new Map());
     const keys = node.e.k;
     const vals = node.e.v;
     for (let i = 0, len = node.e.s; i < len; i++) {
-      result.set(
-        this.deserialize(keys[i]),
-        this.deserialize(vals[i])
-      );
+      result.set(this.deserialize(keys[i]), this.deserialize(vals[i]));
     }
     return result;
   }
@@ -1829,22 +1677,20 @@ var BaseDeserializerContext = class {
     return result;
   }
   deserializeTypedArray(node) {
-    const TypedArray = getTypedArrayConstructor(node.c);
+    const construct = getTypedArrayConstructor(node.c);
     const source = this.deserialize(node.f);
-    const result = this.assignIndexedValue(node.i, new TypedArray(
-      source,
-      node.b,
-      node.l
-    ));
+    const result = this.assignIndexedValue(
+      node.i,
+      new construct(source, node.b, node.l)
+    );
     return result;
   }
   deserializeDataView(node) {
     const source = this.deserialize(node.f);
-    const result = this.assignIndexedValue(node.i, new DataView(
-      source,
-      node.b,
-      node.l
-    ));
+    const result = this.assignIndexedValue(
+      node.i,
+      new DataView(source, node.b, node.l)
+    );
     return result;
   }
   deserializeDictionary(node, result) {
@@ -1862,14 +1708,14 @@ var BaseDeserializerContext = class {
     return this.deserializeDictionary(node, result);
   }
   deserializeError(node) {
-    const ErrorConstructor = ERROR_CONSTRUCTOR[node.s];
+    const construct = ERROR_CONSTRUCTOR[node.s];
     const result = this.assignIndexedValue(
       node.i,
-      new ErrorConstructor(deserializeString(node.m))
+      new construct(deserializeString(node.m))
     );
     return this.deserializeDictionary(node, result);
   }
-  async deserializePromise(node) {
+  deserializePromise(node) {
     const deferred = createDeferred();
     const result = this.assignIndexedValue(node.i, deferred);
     const deserialized = this.deserialize(node.f);
@@ -1880,107 +1726,16 @@ var BaseDeserializerContext = class {
     }
     return result.promise;
   }
-  deserializeURL(node) {
-    return this.assignIndexedValue(node.i, new URL(deserializeString(node.s)));
-  }
-  deserializeURLSearchParams(node) {
-    return this.assignIndexedValue(node.i, new URLSearchParams(deserializeString(node.s)));
-  }
-  deserializeBlob(node) {
-    const source = this.deserialize(node.f);
-    const result = this.assignIndexedValue(node.i, new Blob(
-      [source],
-      { type: deserializeString(node.c) }
-    ));
-    return result;
-  }
-  deserializeFile(node) {
-    const source = this.deserialize(node.f);
-    const result = this.assignIndexedValue(node.i, new File(
-      [source],
-      deserializeString(node.m),
-      { type: deserializeString(node.c), lastModified: node.b }
-    ));
-    return result;
-  }
-  deserializeHeaders(node) {
-    const result = this.assignIndexedValue(node.i, new Headers());
-    const keys = node.e.k;
-    const vals = node.e.v;
-    for (let i = 0, len = node.e.s; i < len; i++) {
-      result.set(
-        deserializeString(keys[i]),
-        this.deserialize(vals[i])
-      );
-    }
-    return result;
-  }
-  deserializeFormData(node) {
-    const result = this.assignIndexedValue(node.i, new FormData());
-    const keys = node.e.k;
-    const vals = node.e.v;
-    for (let i = 0, len = node.e.s; i < len; i++) {
-      result.set(
-        deserializeString(keys[i]),
-        this.deserialize(vals[i])
-      );
-    }
-    return result;
-  }
   deserializeBoxed(node) {
-    return this.assignIndexedValue(
-      node.i,
-      Object(this.deserialize(node.f))
-    );
-  }
-  deserializeRequest(node) {
-    return this.assignIndexedValue(
-      node.i,
-      new Request(deserializeString(node.s), this.deserialize(node.f))
-    );
-  }
-  deserializeResponse(node) {
-    return this.assignIndexedValue(
-      node.i,
-      new Response(
-        this.deserialize(node.a[0]),
-        this.deserialize(node.a[1])
-      )
-    );
-  }
-  deserializeEvent(node) {
-    return this.assignIndexedValue(
-      node.i,
-      new Event(
-        deserializeString(node.s),
-        this.deserialize(node.f)
-      )
-    );
-  }
-  deserializeCustomEvent(node) {
-    return this.assignIndexedValue(
-      node.i,
-      new CustomEvent(
-        deserializeString(node.s),
-        this.deserialize(node.f)
-      )
-    );
-  }
-  deserializeDOMException(node) {
-    return this.assignIndexedValue(
-      node.i,
-      new DOMException(
-        deserializeString(node.s),
-        deserializeString(node.c)
-      )
-    );
+    return this.assignIndexedValue(node.i, Object(this.deserialize(node.f)));
   }
   deserializePlugin(node) {
     const currentPlugins = this.plugins;
     if (currentPlugins) {
+      const tag = deserializeString(node.c);
       for (let i = 0, len = currentPlugins.length; i < len; i++) {
         const plugin = currentPlugins[i];
-        if (plugin.tag === node.c) {
+        if (plugin.tag === tag) {
           return this.assignIndexedValue(
             node.i,
             plugin.deserialize(node.s, this, {
@@ -1993,75 +1748,65 @@ var BaseDeserializerContext = class {
     throw new Error('Missing plugin for tag "' + node.c + '".');
   }
   deserializePromiseConstructor(node) {
-    return this.assignIndexedValue(
-      node.i,
-      createDeferred()
-    ).promise;
+    return this.assignIndexedValue(node.i, createDeferred()).promise;
   }
   deserializePromiseResolve(node) {
     const deferred = this.refs.get(node.i);
     assert(deferred, new Error("Missing Promise instance."));
-    deferred.resolve(
-      this.deserialize(node.a[1])
-    );
+    deferred.resolve(this.deserialize(node.a[1]));
     return void 0;
   }
   deserializePromiseReject(node) {
     const deferred = this.refs.get(node.i);
     assert(deferred, new Error("Missing Promise instance."));
-    deferred.reject(
-      this.deserialize(node.a[1])
-    );
+    deferred.reject(this.deserialize(node.a[1]));
     return void 0;
   }
-  deserializeReadableStreamConstructor(node) {
-    return this.assignIndexedValue(
-      node.i,
-      createDeferredStream()
-    ).stream;
+  deserializeIteratorFactoryInstance(node) {
+    this.deserialize(node.a[0]);
+    const source = this.deserialize(node.a[1]);
+    return sequenceToIterator(source);
   }
-  deserializeReadableStreamEnqueue(node) {
-    const deferred = this.refs.get(node.i);
-    assert(deferred, new Error("Missing ReadableStream instance."));
-    deferred.enqueue(
-      this.deserialize(node.a[1])
-    );
-    return void 0;
+  deserializeAsyncIteratorFactoryInstance(node) {
+    this.deserialize(node.a[0]);
+    const source = this.deserialize(node.a[1]);
+    return streamToAsyncIterable(source);
+  }
+  deserializeStreamConstructor(node) {
+    const result = this.assignIndexedValue(node.i, createStream());
+    const len = node.a.length;
+    if (len) {
+      for (let i = 0; i < len; i++) {
+        this.deserialize(node.a[i]);
+      }
+    }
+    return result;
   }
-  deserializeReadableStreamError(node) {
+  deserializeStreamNext(node) {
     const deferred = this.refs.get(node.i);
-    assert(deferred, new Error("Missing Promise instance."));
-    deferred.error(
-      this.deserialize(node.a[1])
-    );
+    assert(deferred, new Error("Missing Stream instance."));
+    deferred.next(this.deserialize(node.f));
     return void 0;
   }
-  deserializeReadableStreamClose(node) {
+  deserializeStreamThrow(node) {
     const deferred = this.refs.get(node.i);
-    assert(deferred, new Error("Missing Promise instance."));
-    deferred.close();
+    assert(deferred, new Error("Missing Stream instance."));
+    deferred.throw(this.deserialize(node.f));
     return void 0;
   }
-  deserializeIteratorFactoryInstance(node) {
-    const source = this.deserialize(node.a[1]);
-    return sequenceToIterator(source);
+  deserializeStreamReturn(node) {
+    const deferred = this.refs.get(node.i);
+    assert(deferred, new Error("Missing Stream instance."));
+    deferred.return(this.deserialize(node.f));
+    return void 0;
   }
-  deserializeAsyncIteratorFactoryInstance(node) {
-    const source = this.deserialize(node.a[1]);
-    if (node.s) {
-      return readableStreamToAsyncIterator(
-        source
-      );
-    }
-    return sequenceToAsyncIterator(source);
+  deserializeIteratorFactory(node) {
+    this.deserialize(node.f);
+    return void 0;
   }
-  deserializeReadableStream(node) {
-    return this.assignIndexedValue(
-      node.i,
-      sequenceToReadableStream(
-        this.deserialize(node.a[1])
-      )
-    );
+  deserializeAsyncIteratorFactory(node) {
+    this.deserialize(node.a[1]);
+    return void 0;
   }
   deserialize(node) {
     switch (node.t) {
@@ -2075,7 +1820,7 @@ var BaseDeserializerContext = class {
         return BigInt(node.s);
       case 4 /* IndexedValue */:
         return this.refs.get(node.i);
-      case 20 /* Reference */:
+      case 18 /* Reference */:
         return this.deserializeReference(node);
       case 9 /* Array */:
         return this.deserializeArray(node);
@@ -2090,12 +1835,12 @@ var BaseDeserializerContext = class {
         return this.deserializeSet(node);
       case 8 /* Map */:
         return this.deserializeMap(node);
-      case 21 /* ArrayBuffer */:
+      case 19 /* ArrayBuffer */:
         return this.deserializeArrayBuffer(node);
       case 16 /* BigIntTypedArray */:
       case 15 /* TypedArray */:
         return this.deserializeTypedArray(node);
-      case 22 /* DataView */:
+      case 20 /* DataView */:
         return this.deserializeDataView(node);
       case 14 /* AggregateError */:
         return this.deserializeAggregateError(node);
@@ -2105,55 +1850,32 @@ var BaseDeserializerContext = class {
         return this.deserializePromise(node);
       case 17 /* WKSymbol */:
         return SYMBOL_REF[node.s];
-      case 18 /* URL */:
-        return this.deserializeURL(node);
-      case 19 /* URLSearchParams */:
-        return this.deserializeURLSearchParams(node);
-      case 23 /* Blob */:
-        return this.deserializeBlob(node);
-      case 24 /* File */:
-        return this.deserializeFile(node);
-      case 25 /* Headers */:
-        return this.deserializeHeaders(node);
-      case 26 /* FormData */:
-        return this.deserializeFormData(node);
-      case 27 /* Boxed */:
+      case 21 /* Boxed */:
         return this.deserializeBoxed(node);
-      case 35 /* Request */:
-        return this.deserializeRequest(node);
-      case 36 /* Response */:
-        return this.deserializeResponse(node);
-      case 37 /* Event */:
-        return this.deserializeEvent(node);
-      case 38 /* CustomEvent */:
-        return this.deserializeCustomEvent(node);
-      case 39 /* DOMException */:
-        return this.deserializeDOMException(node);
-      case 40 /* Plugin */:
+      case 25 /* Plugin */:
         return this.deserializePlugin(node);
-      case 28 /* PromiseConstructor */:
+      case 22 /* PromiseConstructor */:
         return this.deserializePromiseConstructor(node);
-      case 29 /* PromiseResolve */:
+      case 23 /* PromiseResolve */:
         return this.deserializePromiseResolve(node);
-      case 30 /* PromiseReject */:
+      case 24 /* PromiseReject */:
         return this.deserializePromiseReject(node);
-      case 31 /* ReadableStreamConstructor */:
-        return this.deserializeReadableStreamConstructor(node);
-      case 32 /* ReadableStreamEnqueue */:
-        return this.deserializeReadableStreamEnqueue(node);
-      case 34 /* ReadableStreamError */:
-        return this.deserializeReadableStreamError(node);
-      case 33 /* ReadableStreamClose */:
-        return this.deserializeReadableStreamClose(node);
-      case 43 /* IteratorFactoryInstance */:
+      case 28 /* IteratorFactoryInstance */:
         return this.deserializeIteratorFactoryInstance(node);
-      case 45 /* AsyncIteratorFactoryInstance */:
+      case 30 /* AsyncIteratorFactoryInstance */:
         return this.deserializeAsyncIteratorFactoryInstance(node);
-      case 46 /* ReadableStream */:
-        return this.deserializeReadableStream(node);
-      case 41 /* SpecialReference */:
-      case 42 /* IteratorFactory */:
-      case 44 /* AsyncIteratorFactory */:
+      case 31 /* StreamConstructor */:
+        return this.deserializeStreamConstructor(node);
+      case 32 /* StreamNext */:
+        return this.deserializeStreamNext(node);
+      case 33 /* StreamThrow */:
+        return this.deserializeStreamThrow(node);
+      case 34 /* StreamReturn */:
+        return this.deserializeStreamReturn(node);
+      case 27 /* IteratorFactory */:
+        return this.deserializeIteratorFactory(node);
+      case 29 /* AsyncIteratorFactory */:
+        return this.deserializeAsyncIteratorFactory(node);
       default:
         throw new Error("invariant");
     }
@@ -2163,10 +1885,7 @@ var BaseDeserializerContext = class {
 // src/core/tree/deserializer.ts
 var VanillaDeserializerContext = class extends BaseDeserializerContext {
   constructor(options) {
-    super({
-      plugins: options.plugins,
-      refs: void 0
-    });
+    super(options);
     this.mode = "vanilla";
     this.marked = new Set(options.markedRefs);
   }
@@ -2286,14 +2005,14 @@ var BaseSerializerContext = class {
     this.marked = new Set(options.markedRefs);
   }
   createFunction(parameters, body) {
-    if (this.features & 4 /* ArrowFunction */) {
+    if (this.features & 2 /* ArrowFunction */) {
       const joined = parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")";
       return joined + "=>" + body;
     }
     return "function(" + parameters.join(",") + "){return " + body + "}";
   }
   createEffectfulFunction(parameters, body) {
-    if (this.features & 4 /* ArrowFunction */) {
+    if (this.features & 2 /* ArrowFunction */) {
       const joined = parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")";
       return joined + "=>{" + body + "}";
     }
@@ -2390,13 +2109,20 @@ var BaseSerializerContext = class {
     return node.t === 4 /* IndexedValue */ && this.stack.includes(node.i);
   }
   serializeReference(node) {
-    return this.assignIndexedValue(node.i, REFERENCES_KEY + '.get("' + node.s + '")');
+    return this.assignIndexedValue(
+      node.i,
+      REFERENCES_KEY + '.get("' + node.s + '")'
+    );
   }
   serializeArrayItem(id, item, index) {
     if (item) {
       if (this.isIndexedValueInStack(item)) {
         this.markRef(id);
-        this.createArrayAssign(id, index, this.getRefParam(item.i));
+        this.createArrayAssign(
+          id,
+          index,
+          this.getRefParam(item.i)
+        );
         return "";
       }
       return this.serialize(item);
@@ -2431,7 +2157,11 @@ var BaseSerializerContext = class {
         if (isIdentifier && check !== check) {
           this.createObjectAssign(source.i, key, refParam);
         } else {
-          this.createArrayAssign(source.i, isIdentifier ? key : '"' + key + '"', refParam);
+          this.createArrayAssign(
+            source.i,
+            isIdentifier ? key : '"' + key + '"',
+            refParam
+          );
         }
         return "";
       }
@@ -2457,7 +2187,10 @@ var BaseSerializerContext = class {
   }
   serializeObject(node) {
     this.pushObjectFlag(node.o, node.i);
-    return this.assignIndexedValue(node.i, this.serializeProperties(node, node.p));
+    return this.assignIndexedValue(
+      node.i,
+      this.serializeProperties(node, node.p)
+    );
   }
   serializeWithObjectAssign(source, value, serialized) {
     const fields = this.serializeProperties(source, value);
@@ -2466,27 +2199,38 @@ var BaseSerializerContext = class {
     }
     return serialized;
   }
-  serializeAssignment(source, mainAssignments, key, value) {
-    if (typeof key === "string") {
-      const serialized = this.serialize(value);
-      const check = Number(key);
-      const isIdentifier = check >= 0 || isValidIdentifier(key);
-      if (this.isIndexedValueInStack(value)) {
-        if (isIdentifier && check !== check) {
-          this.createObjectAssign(source.i, key, serialized);
-        } else {
-          this.createArrayAssign(source.i, isIdentifier ? key : '"' + key + '"', serialized);
-        }
+  serializeStringKeyAssignment(source, mainAssignments, key, value) {
+    const serialized = this.serialize(value);
+    const check = Number(key);
+    const isIdentifier = check >= 0 || isValidIdentifier(key);
+    if (this.isIndexedValueInStack(value)) {
+      if (isIdentifier && check !== check) {
+        this.createObjectAssign(source.i, key, serialized);
       } else {
-        const parentAssignment = this.assignments;
-        this.assignments = mainAssignments;
-        if (isIdentifier) {
-          this.createObjectAssign(source.i, key, serialized);
-        } else {
-          this.createArrayAssign(source.i, isIdentifier ? key : '"' + key + '"', serialized);
-        }
-        this.assignments = parentAssignment;
+        this.createArrayAssign(
+          source.i,
+          isIdentifier ? key : '"' + key + '"',
+          serialized
+        );
+      }
+    } else {
+      const parentAssignment = this.assignments;
+      this.assignments = mainAssignments;
+      if (isIdentifier) {
+        this.createObjectAssign(source.i, key, serialized);
+      } else {
+        this.createArrayAssign(
+          source.i,
+          isIdentifier ? key : '"' + key + '"',
+          serialized
+        );
       }
+      this.assignments = parentAssignment;
+    }
+  }
+  serializeAssignment(source, mainAssignments, key, value) {
+    if (typeof key === "string") {
+      this.serializeStringKeyAssignment(source, mainAssignments, key, value);
     } else {
       const parent = this.stack;
       this.stack = [];
@@ -2494,11 +2238,7 @@ var BaseSerializerContext = class {
       this.stack = parent;
       const parentAssignment = this.assignments;
       this.assignments = mainAssignments;
-      this.createArrayAssign(
-        source.i,
-        this.serialize(key),
-        serialized
-      );
+      this.createArrayAssign(source.i, this.serialize(key), serialized);
       this.assignments = parentAssignment;
     }
   }
@@ -2519,7 +2259,7 @@ var BaseSerializerContext = class {
   }
   serializeDictionary(node, init) {
     if (node.p) {
-      if (this.features & 128 /* ObjectAssign */) {
+      if (this.features & 8 /* ObjectAssign */) {
         init = this.serializeWithObjectAssign(node, node.p, init);
       } else {
         this.markRef(node.i);
@@ -2544,7 +2284,10 @@ var BaseSerializerContext = class {
   serializeSetItem(id, item) {
     if (this.isIndexedValueInStack(item)) {
       this.markRef(id);
-      this.createAddAssignment(id, this.getRefParam(item.i));
+      this.createAddAssignment(
+        id,
+        this.getRefParam(item.i)
+      );
       return "";
     }
     return this.serialize(item);
@@ -2611,14 +2354,14 @@ var BaseSerializerContext = class {
     const size = node.e.s;
     const id = node.i;
     const sentinel = node.f;
-    const sentinelID = this.getRefParam(sentinel.i);
+    const sentinelId = this.getRefParam(sentinel.i);
     if (size) {
       const keys = node.e.k;
       const vals = node.e.v;
       this.stack.push(id);
-      let result = this.serializeMapEntry(id, keys[0], vals[0], sentinelID);
+      let result = this.serializeMapEntry(id, keys[0], vals[0], sentinelId);
       for (let i = 1, item = result; i < size; i++) {
-        item = this.serializeMapEntry(id, keys[i], vals[i], sentinelID);
+        item = this.serializeMapEntry(id, keys[i], vals[i], sentinelId);
         result += (item && result && ",") + item;
       }
       this.stack.pop();
@@ -2626,7 +2369,7 @@ var BaseSerializerContext = class {
         serialized += "([" + result + "])";
       }
     }
-    if (sentinel.t === 41 /* SpecialReference */) {
+    if (sentinel.t === 26 /* SpecialReference */) {
       this.markRef(sentinel.i);
       serialized = "(" + this.serialize(sentinel) + "," + serialized + ")";
     }
@@ -2665,108 +2408,37 @@ var BaseSerializerContext = class {
     return this.serializeDictionary(node, serialized);
   }
   serializeError(node) {
-    return this.serializeDictionary(node, "new " + ERROR_CONSTRUCTOR_STRING[node.s] + '("' + node.m + '")');
+    return this.serializeDictionary(
+      node,
+      "new " + ERROR_CONSTRUCTOR_STRING[node.s] + '("' + node.m + '")'
+    );
   }
   serializePromise(node) {
     let serialized;
     const fulfilled = node.f;
     const id = node.i;
-    const constructor = node.s ? PROMISE_RESOLVE : PROMISE_REJECT;
+    const promiseConstructor = node.s ? PROMISE_RESOLVE : PROMISE_REJECT;
     if (this.isIndexedValueInStack(fulfilled)) {
       const ref = this.getRefParam(fulfilled.i);
-      serialized = constructor + (node.s ? "().then(" + this.createFunction([], ref) + ")" : "().catch(" + this.createEffectfulFunction([], "throw " + ref) + ")");
+      serialized = promiseConstructor + (node.s ? "().then(" + this.createFunction([], ref) + ")" : "().catch(" + this.createEffectfulFunction([], "throw " + ref) + ")");
     } else {
       this.stack.push(id);
       const result = this.serialize(fulfilled);
       this.stack.pop();
-      serialized = constructor + "(" + result + ")";
+      serialized = promiseConstructor + "(" + result + ")";
     }
     return this.assignIndexedValue(id, serialized);
   }
-  serializeWKSymbol(node) {
+  serializeWellKnownSymbol(node) {
     return this.assignIndexedValue(node.i, SYMBOL_STRING[node.s]);
   }
-  serializeURL(node) {
-    return this.assignIndexedValue(node.i, 'new URL("' + node.s + '")');
-  }
-  serializeURLSearchParams(node) {
-    return this.assignIndexedValue(
-      node.i,
-      node.s ? 'new URLSearchParams("' + node.s + '")' : "new URLSearchParams"
-    );
-  }
-  serializeBlob(node) {
-    return this.assignIndexedValue(
-      node.i,
-      "new Blob([" + this.serialize(node.f) + '],{type:"' + node.c + '"})'
-    );
-  }
-  serializeFile(node) {
-    return this.assignIndexedValue(
-      node.i,
-      "new File([" + this.serialize(node.f) + '],"' + node.m + '",{type:"' + node.c + '",lastModified:' + node.b + "})"
-    );
-  }
-  serializeHeaders(node) {
-    return this.assignIndexedValue(
-      node.i,
-      "new Headers(" + this.serializeProperties(node, node.e) + ")"
-    );
-  }
   serializeFormDataEntry(id, key, value) {
     return this.getRefParam(id) + '.append("' + key + '",' + this.serialize(value) + ")";
   }
-  serializeFormDataEntries(node, size) {
-    const keys = node.e.k;
-    const vals = node.e.v;
-    const id = node.i;
-    let result = this.serializeFormDataEntry(id, keys[0], vals[0]);
-    for (let i = 1; i < size; i++) {
-      result += "," + this.serializeFormDataEntry(id, keys[i], vals[i]);
-    }
-    return result;
-  }
-  serializeFormData(node) {
-    const size = node.e.s;
-    const id = node.i;
-    if (size) {
-      this.markRef(id);
-    }
-    const result = this.assignIndexedValue(id, "new FormData()");
-    if (size) {
-      const entries = this.serializeFormDataEntries(node, size);
-      return "(" + result + "," + (entries ? entries + "," : "") + this.getRefParam(id) + ")";
-    }
-    return result;
-  }
   serializeBoxed(node) {
-    return this.assignIndexedValue(node.i, "Object(" + this.serialize(node.f) + ")");
-  }
-  serializeRequest(node) {
-    return this.assignIndexedValue(node.i, 'new Request("' + node.s + '",' + this.serialize(node.f) + ")");
-  }
-  serializeResponse(node) {
-    return this.assignIndexedValue(
-      node.i,
-      "new Response(" + this.serialize(node.a[0]) + "," + this.serialize(node.a[1]) + ")"
-    );
-  }
-  serializeEvent(node) {
-    return this.assignIndexedValue(
-      node.i,
-      'new Event("' + node.s + '",' + this.serialize(node.f) + ")"
-    );
-  }
-  serializeCustomEvent(node) {
-    return this.assignIndexedValue(
-      node.i,
-      'new CustomEvent("' + node.s + '",' + this.serialize(node.f) + ")"
-    );
-  }
-  serializeDOMException(node) {
     return this.assignIndexedValue(
       node.i,
-      'new DOMException("' + node.s + '","' + node.c + '")'
+      "Object(" + this.serialize(node.f) + ")"
     );
   }
   serializePlugin(node) {
@@ -2787,14 +2459,11 @@ var BaseSerializerContext = class {
     throw new Error('Missing plugin for tag "' + node.c + '".');
   }
   getConstructor(node) {
-    const constructor = this.serialize(node);
-    return constructor === this.getRefParam(node.i) ? constructor : "(" + constructor + ")";
+    const current = this.serialize(node);
+    return current === this.getRefParam(node.i) ? current : "(" + current + ")";
   }
   serializePromiseConstructor(node) {
-    return this.assignIndexedValue(
-      node.i,
-      this.getConstructor(node.f) + "()"
-    );
+    return this.assignIndexedValue(node.i, this.getConstructor(node.f) + "()");
   }
   serializePromiseResolve(node) {
     return this.getConstructor(node.a[0]) + "(" + this.getRefParam(node.i) + "," + this.serialize(node.a[1]) + ")";
@@ -2802,70 +2471,44 @@ var BaseSerializerContext = class {
   serializePromiseReject(node) {
     return this.getConstructor(node.a[0]) + "(" + this.getRefParam(node.i) + "," + this.serialize(node.a[1]) + ")";
   }
-  serializeReadableStreamConstructor(node) {
-    return this.assignIndexedValue(
-      node.i,
-      this.getConstructor(node.f) + "()"
-    );
-  }
-  serializeReadableStreamEnqueue(node) {
-    return this.getConstructor(node.a[0]) + "(" + this.getRefParam(node.i) + "," + this.serialize(node.a[1]) + ")";
-  }
-  serializeReadableStreamError(node) {
-    return this.getConstructor(node.a[0]) + "(" + this.getRefParam(node.i) + "," + this.serialize(node.a[1]) + ")";
-  }
-  serializeReadableStreamClose(node) {
-    return this.getConstructor(node.f) + "(" + this.getRefParam(node.i) + ")";
-  }
   serializeSpecialReferenceValue(ref) {
     switch (ref) {
       case 0 /* MapSentinel */:
         return "[]";
-      case 1 /* ReadableStream */:
-        return this.createFunction(
-          ["s"],
-          "new ReadableStream({start:" + this.createFunction(
-            ["c"],
-            "Promise.resolve().then(" + this.createEffectfulFunction(
-              ["i", "v"],
-              "for(i=0;i<s.d;i++)c.enqueue(s.v[i]);(s.t===-1)?c.close():c.error(s.v[i])"
-            ) + ")"
-          ) + "})"
-        );
-      case 2 /* PromiseConstructor */:
+      case 1 /* PromiseConstructor */:
         return this.createFunction(
           ["s", "f", "p"],
           "((p=new Promise(" + this.createEffectfulFunction(["a", "b"], "s=a,f=b") + ")).s=s,p.f=f,p)"
         );
-      case 3 /* PromiseResolve */:
+      case 2 /* PromiseResolve */:
         return this.createEffectfulFunction(
           ["p", "d"],
           'p.s(d),p.status="success",p.value=d;delete p.s;delete p.f'
         );
-      case 4 /* PromiseReject */:
+      case 3 /* PromiseReject */:
         return this.createEffectfulFunction(
           ["p", "d"],
           'p.f(d),p.status="failure",p.value=d;delete p.s;delete p.f'
         );
-      case 5 /* ReadableStreamConstructor */:
+      case 4 /* StreamConstructor */:
         return this.createFunction(
-          ["s", "c"],
-          "((s=new ReadableStream({start:" + this.createEffectfulFunction(["x"], "c=x") + "})).c=c,s)"
-        );
-      case 6 /* ReadableStreamEnqueue */:
-        return this.createEffectfulFunction(
-          ["s", "d"],
-          "s.c.enqueue(d)"
-        );
-      case 7 /* ReadableStreamError */:
-        return this.createEffectfulFunction(
-          ["s", "d"],
-          "s.c.error(d);delete s.c"
-        );
-      case 8 /* ReadableStreamClose */:
-        return this.createEffectfulFunction(
-          ["s"],
-          "s.c.close();delete s.c"
+          ["b", "a", "s", "l", "p", "f", "e", "n"],
+          "(b=[],a=!0,s=!1,l=[],s=0,f=" + this.createEffectfulFunction(
+            ["v", "m", "x"],
+            "for(x=0;x<s;x++)l[x]&&l[x][m](v)"
+          ) + ",n=" + this.createEffectfulFunction(
+            ["o", "x", "z", "c"],
+            'for(x=0,z=b.length;x<z;x++)(c=b[x],x===z-1?o[s?"return":"throw"](c):o.next(c))'
+          ) + ",e=" + this.createFunction(
+            ["o", "t"],
+            "(a&&(l[t=p++]=o),n(o)," + this.createEffectfulFunction([], "a&&(l[t]=void 0)") + ")"
+          ) + ",{__SEROVAL_STREAM__:!0,on:" + this.createFunction(["o"], "e(o)") + ",next:" + this.createEffectfulFunction(["v"], 'a&&(b.push(v),f(v,"next"))') + ",throw:" + this.createEffectfulFunction(
+            ["v"],
+            'a&&(b.push(v),f(v,"throw"),a=s=!1,l.length=0)'
+          ) + ",return:" + this.createEffectfulFunction(
+            ["v"],
+            'a&&(b.push(v),f(v,"return"),a=!1,s=!0,l.length=0)'
+          ) + "})"
         );
       default:
         return "";
@@ -2878,67 +2521,105 @@ var BaseSerializerContext = class {
     );
   }
   serializeIteratorFactory(node) {
-    return this.assignIndexedValue(
+    let result = "";
+    let initialized = false;
+    if (node.f.t !== 4 /* IndexedValue */) {
+      this.markRef(node.f.i);
+      result = "(" + this.serialize(node.f) + ",";
+      initialized = true;
+    }
+    result += this.assignIndexedValue(
       node.i,
       this.createFunction(
         ["s"],
         this.createFunction(
           ["i", "c", "d", "t"],
-          "(i=0,t={[" + this.serialize(node.f) + "]:" + this.createFunction([], "t") + ",next:" + this.createEffectfulFunction([], "if(i>s.d)return{done:!0,value:void 0};c=i++,d=s.v[c];if(c===s.t)throw d;return{done:c===s.d,value:d}") + "})"
+          "(i=0,t={[" + this.getRefParam(node.f.i) + "]:" + this.createFunction([], "t") + ",next:" + this.createEffectfulFunction(
+            [],
+            "if(i>s.d)return{done:!0,value:void 0};if(d=s.v[c=i++],c===s.t)throw d;return{done:c===s.d,value:d}"
+          ) + "})"
         )
       )
     );
+    if (initialized) {
+      result += ")";
+    }
+    return result;
   }
   serializeIteratorFactoryInstance(node) {
     return this.getConstructor(node.a[0]) + "(" + this.serialize(node.a[1]) + ")";
   }
-  getStreamingAsyncIteratorFactory(node) {
-    return this.createFunction(
-      ["s"],
-      this.createFunction(
-        ["b", "t"],
-        "(b=s.tee(),s=b[0],b=b[1].getReader(),t={[" + this.serialize(node.f) + "]:" + this.createFunction([], "t") + ",next:" + this.createFunction(
-          [],
-          "b.read().then(" + this.createEffectfulFunction(
-            ["d"],
-            "if(d.done)return{done:!0,value:void 0};d=d.value;if(d[0]===1)throw d[1];return{done:d[0]===2,value:d[1]}"
-          ) + ")"
-        ) + "})"
-      )
-    );
-  }
-  getBlockingAsyncIteratorFactory(node) {
-    return this.createFunction(
-      ["s"],
-      this.createFunction(
-        ["i", "t"],
-        "(i=0,t={[" + this.serialize(node.f) + "]:" + this.createFunction([], "t") + ",next:" + this.createFunction(
-          [],
-          "Promise.resolve().then(" + this.createEffectfulFunction(
-            ["c", "d"],
-            "if(i>s.d)return{done:!0,value:void 0};c=i++,d=s.v[c];if(c===s.t)throw d;return{done:c===s.d,value:d}"
-          ) + ")"
-        ) + "})"
-      )
-    );
-  }
   serializeAsyncIteratorFactory(node) {
-    return this.assignIndexedValue(
+    const promise = node.a[0];
+    const symbol = node.a[1];
+    let result = "";
+    if (promise.t !== 4 /* IndexedValue */) {
+      this.markRef(promise.i);
+      result += "(" + this.serialize(promise);
+    }
+    if (symbol.t !== 4 /* IndexedValue */) {
+      this.markRef(symbol.i);
+      result += (result ? "," : "(") + this.serialize(symbol);
+    }
+    if (result) {
+      result += ",";
+    }
+    const iterator = this.assignIndexedValue(
       node.i,
-      node.s ? this.getStreamingAsyncIteratorFactory(node) : this.getBlockingAsyncIteratorFactory(node)
+      this.createFunction(
+        ["s"],
+        this.createFunction(
+          ["b", "c", "p", "d", "e", "t", "f"],
+          "(b=[],c=0,p=[],d=-1,e=!1,f=" + this.createEffectfulFunction(
+            ["i", "l"],
+            "for(i=0,l=p.length;i<l;i++)p[i].s({done:!0,value:void 0})"
+          ) + ",s.on({next:" + this.createEffectfulFunction(
+            ["v", "t"],
+            "if(t=p.shift())t.s({done:!1,value:v});b.push(v)"
+          ) + ",throw:" + this.createEffectfulFunction(
+            ["v", "t"],
+            "if(t=p.shift())t.f(v);f(),d=b.length,e=!0,b.push(v)"
+          ) + ",return:" + this.createEffectfulFunction(
+            ["v", "t"],
+            "if(t=p.shift())t.s({done:!0,value:v});f(),d=b.length,b.push(v)"
+          ) + "}),t={[" + this.getRefParam(symbol.i) + "]:" + this.createFunction([], "t") + ",next:" + this.createEffectfulFunction(
+            ["i", "t", "v"],
+            "if(d===-1){return((i=c++)>=b.length)?(p.push(t=" + this.getRefParam(promise.i) + "()),t):{done:!0,value:b[i]}}if(c>d)return{done:!0,value:void 0};if(v=b[i=c++],i!==d)return{done:!1,value:v};if(e)throw v;return{done:!0,value:v}"
+          ) + "})"
+        )
+      )
     );
+    if (result) {
+      return result + iterator + ")";
+    }
+    return iterator;
   }
   serializeAsyncIteratorFactoryInstance(node) {
     return this.getConstructor(node.a[0]) + "(" + this.serialize(node.a[1]) + ")";
   }
-  serializeReadableStream(node) {
-    this.stack.push(node.i);
-    const result = this.getConstructor(node.a[0]) + "(" + this.serialize(node.a[1]) + ")";
-    this.stack.pop();
-    return this.assignIndexedValue(
+  serializeStreamConstructor(node) {
+    const result = this.assignIndexedValue(
       node.i,
-      result
+      this.getConstructor(node.f) + "()"
     );
+    const len = node.a.length;
+    if (len) {
+      let values = this.serialize(node.a[0]);
+      for (let i = 1; i < len; i++) {
+        values += "," + this.serialize(node.a[i]);
+      }
+      return "(" + result + "," + values + "," + this.getRefParam(node.i) + ")";
+    }
+    return result;
+  }
+  serializeStreamNext(node) {
+    return this.getRefParam(node.i) + ".next(" + this.serialize(node.f) + ")";
+  }
+  serializeStreamThrow(node) {
+    return this.getRefParam(node.i) + ".throw(" + this.serialize(node.f) + ")";
+  }
+  serializeStreamReturn(node) {
+    return this.getRefParam(node.i) + ".return(" + this.serialize(node.f) + ")";
   }
   serialize(node) {
     switch (node.t) {
@@ -2952,7 +2633,7 @@ var BaseSerializerContext = class {
         return node.s + "n";
       case 4 /* IndexedValue */:
         return this.getRefParam(node.i);
-      case 20 /* Reference */:
+      case 18 /* Reference */:
         return this.serializeReference(node);
       case 9 /* Array */:
         return this.serializeArray(node);
@@ -2968,12 +2649,12 @@ var BaseSerializerContext = class {
         return this.serializeSet(node);
       case 8 /* Map */:
         return this.serializeMap(node);
-      case 21 /* ArrayBuffer */:
+      case 19 /* ArrayBuffer */:
         return this.serializeArrayBuffer(node);
       case 16 /* BigIntTypedArray */:
       case 15 /* TypedArray */:
         return this.serializeTypedArray(node);
-      case 22 /* DataView */:
+      case 20 /* DataView */:
         return this.serializeDataView(node);
       case 14 /* AggregateError */:
         return this.serializeAggregateError(node);
@@ -2982,59 +2663,35 @@ var BaseSerializerContext = class {
       case 12 /* Promise */:
         return this.serializePromise(node);
       case 17 /* WKSymbol */:
-        return this.serializeWKSymbol(node);
-      case 18 /* URL */:
-        return this.serializeURL(node);
-      case 19 /* URLSearchParams */:
-        return this.serializeURLSearchParams(node);
-      case 23 /* Blob */:
-        return this.serializeBlob(node);
-      case 24 /* File */:
-        return this.serializeFile(node);
-      case 25 /* Headers */:
-        return this.serializeHeaders(node);
-      case 26 /* FormData */:
-        return this.serializeFormData(node);
-      case 27 /* Boxed */:
+        return this.serializeWellKnownSymbol(node);
+      case 21 /* Boxed */:
         return this.serializeBoxed(node);
-      case 28 /* PromiseConstructor */:
+      case 22 /* PromiseConstructor */:
         return this.serializePromiseConstructor(node);
-      case 29 /* PromiseResolve */:
+      case 23 /* PromiseResolve */:
         return this.serializePromiseResolve(node);
-      case 30 /* PromiseReject */:
+      case 24 /* PromiseReject */:
         return this.serializePromiseReject(node);
-      case 31 /* ReadableStreamConstructor */:
-        return this.serializeReadableStreamConstructor(node);
-      case 32 /* ReadableStreamEnqueue */:
-        return this.serializeReadableStreamEnqueue(node);
-      case 34 /* ReadableStreamError */:
-        return this.serializeReadableStreamError(node);
-      case 33 /* ReadableStreamClose */:
-        return this.serializeReadableStreamClose(node);
-      case 35 /* Request */:
-        return this.serializeRequest(node);
-      case 36 /* Response */:
-        return this.serializeResponse(node);
-      case 37 /* Event */:
-        return this.serializeEvent(node);
-      case 38 /* CustomEvent */:
-        return this.serializeCustomEvent(node);
-      case 39 /* DOMException */:
-        return this.serializeDOMException(node);
-      case 40 /* Plugin */:
+      case 25 /* Plugin */:
         return this.serializePlugin(node);
-      case 41 /* SpecialReference */:
+      case 26 /* SpecialReference */:
         return this.serializeSpecialReference(node);
-      case 42 /* IteratorFactory */:
+      case 27 /* IteratorFactory */:
         return this.serializeIteratorFactory(node);
-      case 43 /* IteratorFactoryInstance */:
+      case 28 /* IteratorFactoryInstance */:
         return this.serializeIteratorFactoryInstance(node);
-      case 44 /* AsyncIteratorFactory */:
+      case 29 /* AsyncIteratorFactory */:
         return this.serializeAsyncIteratorFactory(node);
-      case 45 /* AsyncIteratorFactoryInstance */:
+      case 30 /* AsyncIteratorFactoryInstance */:
         return this.serializeAsyncIteratorFactoryInstance(node);
-      case 46 /* ReadableStream */:
-        return this.serializeReadableStream(node);
+      case 31 /* StreamConstructor */:
+        return this.serializeStreamConstructor(node);
+      case 32 /* StreamNext */:
+        return this.serializeStreamNext(node);
+      case 33 /* StreamThrow */:
+        return this.serializeStreamThrow(node);
+      case 34 /* StreamReturn */:
+        return this.serializeStreamReturn(node);
       default:
         throw new Error("invariant");
     }
@@ -3074,12 +2731,6 @@ var VanillaSerializerContext = class extends BaseSerializerContext {
      */
     this.vars = [];
   }
-  /**
-   * Increments the number of references the referenced value has
-   */
-  markRef(current) {
-    this.marked.add(current);
-  }
   /**
    * Creates the reference param (identifier) from the given reference ID
    * Calling this function means the value has been referenced somewhere
@@ -3112,18 +2763,6 @@ var VanillaSerializerContext = class extends BaseSerializerContext {
   serializePromiseReject(node) {
     throw new Error('Unsupported node type "' + node.t + '".');
   }
-  serializeReadableStreamConstructor(node) {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-  serializeReadableStreamEnqueue(node) {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-  serializeReadableStreamError(node) {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-  serializeReadableStreamClose(node) {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
   serializeTop(tree) {
     const result = this.serialize(tree);
     if (tree.i != null && this.vars.length) {
@@ -3157,11 +2796,7 @@ var BaseSyncParserContext = class extends BaseParserContext {
     return nodes;
   }
   parseArray(id, current) {
-    return createArrayNode(
-      id,
-      current,
-      this.parseItems(current)
-    );
+    return createArrayNode(id, current, this.parseItems(current));
   }
   parseProperties(properties) {
     const entries = Object.entries(properties);
@@ -3171,31 +2806,37 @@ var BaseSyncParserContext = class extends BaseParserContext {
       keyNodes.push(serializeString(entries[i][0]));
       valueNodes.push(this.parse(entries[i][1]));
     }
-    if (this.features & 1024 /* Symbol */) {
-      let symbol = Symbol.iterator;
-      if (symbol in properties) {
-        keyNodes.push(
-          this.parseWKSymbol(symbol)
-        );
-        valueNodes.push(
-          createIteratorFactoryInstanceNode(
-            this.parseIteratorFactory(),
-            this.parse(
-              iteratorToSequence(properties)
-            )
+    let symbol = Symbol.iterator;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(
+        createIteratorFactoryInstanceNode(
+          this.parseIteratorFactory(),
+          this.parse(
+            iteratorToSequence(properties)
           )
-        );
-      }
-      symbol = Symbol.toStringTag;
-      if (symbol in properties) {
-        keyNodes.push(this.parseWKSymbol(symbol));
-        valueNodes.push(createStringNode(properties[symbol]));
-      }
-      symbol = Symbol.isConcatSpreadable;
-      if (symbol in properties) {
-        keyNodes.push(this.parseWKSymbol(symbol));
-        valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
-      }
+        )
+      );
+    }
+    symbol = Symbol.asyncIterator;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(
+        createAsyncIteratorFactoryInstanceNode(
+          this.parseAsyncIteratorFactory(),
+          this.parse(createStream())
+        )
+      );
+    }
+    symbol = Symbol.toStringTag;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(createStringNode(properties[symbol]));
+    }
+    symbol = Symbol.isConcatSpreadable;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
     }
     return {
       k: keyNodes,
@@ -3246,12 +2887,7 @@ var BaseSyncParserContext = class extends BaseParserContext {
       keyNodes.push(this.parse(key));
       valueNodes.push(this.parse(value));
     }
-    return this.createMapNode(
-      id,
-      keyNodes,
-      valueNodes,
-      current.size
-    );
+    return this.createMapNode(id, keyNodes, valueNodes, current.size);
   }
   parseSet(id, current) {
     const items = [];
@@ -3260,66 +2896,6 @@ var BaseSyncParserContext = class extends BaseParserContext {
     }
     return createSetNode(id, current.size, items);
   }
-  parsePlainProperties(entries) {
-    const size = entries.length;
-    const keyNodes = [];
-    const valueNodes = [];
-    for (let i = 0; i < size; i++) {
-      keyNodes.push(serializeString(entries[i][0]));
-      valueNodes.push(this.parse(entries[i][1]));
-    }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: size
-    };
-  }
-  parseHeaders(id, current) {
-    const items = [];
-    current.forEach((value, key) => {
-      items.push([key, value]);
-    });
-    return {
-      t: 25 /* Headers */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: this.parsePlainProperties(items),
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
-  }
-  parseFormData(id, current) {
-    const items = [];
-    current.forEach((value, key) => {
-      items.push([key, value]);
-    });
-    return {
-      t: 26 /* FormData */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: this.parsePlainProperties(items),
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
-  }
-  parseEvent(id, current) {
-    return createEventNode(id, current.type, this.parse(createEventOptions(current)));
-  }
-  parseCustomEvent(id, current) {
-    return createCustomEventNode(id, current.type, this.parse(createCustomEventOptions(current)));
-  }
   parsePlugin(id, current) {
     const currentPlugins = this.plugins;
     if (currentPlugins) {
@@ -3338,10 +2914,40 @@ var BaseSyncParserContext = class extends BaseParserContext {
     }
     return void 0;
   }
+  parseStream(id, _current) {
+    return createStreamConstructorNode(
+      id,
+      this.parseSpecialReference(4 /* StreamConstructor */),
+      []
+    );
+  }
+  parsePromise(id, _current) {
+    return {
+      t: 22 /* PromiseConstructor */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: void 0,
+      e: void 0,
+      a: void 0,
+      f: this.parseSpecialReference(1 /* PromiseConstructor */),
+      b: void 0,
+      o: void 0
+    };
+  }
   parseObject(id, current) {
     if (Array.isArray(current)) {
       return this.parseArray(id, current);
     }
+    if (isStream(current)) {
+      return this.parseStream(id, current);
+    }
+    const parsed = this.parsePlugin(id, current);
+    if (parsed) {
+      return parsed;
+    }
     const currentClass = current.constructor;
     switch (currentClass) {
       case Object:
@@ -3373,119 +2979,77 @@ var BaseSyncParserContext = class extends BaseParserContext {
       case String:
       case BigInt:
         return this.parseBoxed(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 this.parseTypedArray(id, current);
+      case DataView:
+        return this.parseDataView(id, current);
+      case Map:
+        return this.parseMap(id, current);
+      case Set:
+        return this.parseSet(id, current);
       default:
-        break;
-    }
-    const currentFeatures = this.features;
-    if (currentFeatures & 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 this.parseTypedArray(id, current);
-        case DataView:
-          return this.parseDataView(id, current);
-        default:
-          break;
-      }
+        break;
+    }
+    if (currentClass === Promise || current instanceof Promise) {
+      return this.parsePromise(id, current);
     }
-    if ((currentFeatures & BIGINT_FLAG) === BIGINT_FLAG) {
+    const currentFeatures = this.features;
+    if (currentFeatures & 16 /* BigIntTypedArray */) {
       switch (currentClass) {
         case BigInt64Array:
         case BigUint64Array:
-          return this.parseBigIntTypedArray(id, current);
-        default:
-          break;
-      }
-    }
-    if (currentFeatures & 32 /* Map */ && currentClass === Map) {
-      return this.parseMap(
-        id,
-        current
-      );
-    }
-    if (currentFeatures & 512 /* Set */ && currentClass === Set) {
-      return this.parseSet(
-        id,
-        current
-      );
-    }
-    if (currentFeatures & 8192 /* WebAPI */) {
-      switch (currentClass) {
-        case (typeof URL !== "undefined" ? URL : UNIVERSAL_SENTINEL):
-          return createURLNode(id, current);
-        case (typeof URLSearchParams !== "undefined" ? URLSearchParams : UNIVERSAL_SENTINEL):
-          return createURLSearchParamsNode(id, current);
-        case (typeof Headers !== "undefined" ? Headers : UNIVERSAL_SENTINEL):
-          return this.parseHeaders(id, current);
-        case (typeof FormData !== "undefined" ? FormData : UNIVERSAL_SENTINEL):
-          return this.parseFormData(id, current);
-        case (typeof Event !== "undefined" ? Event : UNIVERSAL_SENTINEL):
-          return this.parseEvent(id, current);
-        case (typeof CustomEvent !== "undefined" ? CustomEvent : UNIVERSAL_SENTINEL):
-          return this.parseCustomEvent(id, current);
-        case (typeof DOMException !== "undefined" ? DOMException : UNIVERSAL_SENTINEL):
-          return createDOMExceptionNode(id, current);
+          return this.parseBigIntTypedArray(
+            id,
+            current
+          );
         default:
           break;
       }
     }
-    const parsed = this.parsePlugin(id, current);
-    if (parsed) {
-      return parsed;
-    }
     if (currentFeatures & 1 /* AggregateError */ && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) {
       return this.parseAggregateError(id, current);
     }
     if (current instanceof Error) {
       return this.parseError(id, current);
     }
-    if (currentFeatures & 1024 /* Symbol */ && Symbol.iterator in current) {
+    if (Symbol.iterator in current || Symbol.asyncIterator in current) {
       return this.parsePlainObject(id, current, !!currentClass);
     }
     throw new UnsupportedTypeError(current);
   }
   parse(current) {
-    switch (current) {
-      case true:
-        return TRUE_NODE;
-      case false:
-        return FALSE_NODE;
-      case void 0:
-        return UNDEFINED_NODE;
-      case null:
-        return NULL_NODE;
-      default:
-        break;
-    }
     switch (typeof current) {
+      case "boolean":
+        return current ? TRUE_NODE : FALSE_NODE;
+      case "undefined":
+        return UNDEFINED_NODE;
       case "string":
         return createStringNode(current);
       case "number":
         return createNumberNode(current);
       case "bigint":
-        assert(this.features & 8 /* BigInt */, new UnsupportedTypeError(current));
         return createBigIntNode(current);
       case "object": {
-        const id = this.getReference(current);
-        return typeof id === "number" ? this.parseObject(id, current) : id;
-      }
-      case "symbol": {
-        assert(this.features & 1024 /* Symbol */, new UnsupportedTypeError(current));
-        const id = this.getReference(current);
-        return typeof id === "number" ? createWKSymbolNode(id, current) : id;
+        if (current) {
+          const ref = this.getReference(current);
+          return ref.type === 0 ? this.parseObject(ref.value, current) : ref.value;
+        }
+        return NULL_NODE;
       }
+      case "symbol":
+        return this.parseWellKnownSymbol(current);
       case "function":
-        assert(hasReferenceID(current), new Error("Cannot serialize function without reference ID."));
-        return this.getStrictReference(current);
+        return this.parseFunction(current);
       default:
         throw new UnsupportedTypeError(current);
     }
@@ -3502,26 +3066,28 @@ var SyncParserContext = class extends BaseSyncParserContext {
 
 // src/core/tree/index.ts
 function serialize(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new SyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures
   });
   const tree = ctx.parse(source);
   const serial = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     markedRefs: ctx.marked
   });
   return serial.serializeTop(tree);
 }
 async function serializeAsync(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new AsyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures
   });
   const tree = await ctx.parse(source);
   const serial = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     markedRefs: ctx.marked
   });
@@ -3531,8 +3097,9 @@ function deserialize(source) {
   return (0, eval)(source);
 }
 function toJSON(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new SyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures
   });
   return {
@@ -3542,8 +3109,9 @@ function toJSON(source, options = {}) {
   };
 }
 async function toJSONAsync(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new AsyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures
   });
   return {
@@ -3553,16 +3121,18 @@ async function toJSONAsync(source, options = {}) {
   };
 }
 function compileJSON(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: source.f,
     markedRefs: source.m
   });
   return ctx.serializeTop(source.t);
 }
 function fromJSON(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new VanillaDeserializerContext({
-    plugins: options.plugins,
+    plugins,
     markedRefs: source.m
   });
   return ctx.deserialize(source.t);
@@ -3598,9 +3168,6 @@ var CrossSerializerContext = class extends BaseSerializerContext {
     this.scopeId = options.scopeId;
   }
   getRefParam(id) {
-    if (typeof id === "string") {
-      return GLOBAL_CONTEXT_REFERENCES + "." + id;
-    }
     return GLOBAL_CONTEXT_REFERENCES + "[" + id + "]";
   }
   assignIndexedValue(index, value) {
@@ -3615,12 +3182,11 @@ var CrossSerializerContext = class extends BaseSerializerContext {
     const patches = this.resolvePatches();
     const ref = this.getRefParam(id);
     const params = this.scopeId == null ? "" : GLOBAL_CONTEXT_REFERENCES;
-    const mainBody = patches ? result + "," + patches : result;
+    const body = patches ? result + "," + patches + ref : result;
     if (params === "") {
-      return patches ? "(" + mainBody + ref + ")" : mainBody;
+      return patches ? "(" + body + ")" : body;
     }
     const args = this.scopeId == null ? "()" : "(" + GLOBAL_CONTEXT_REFERENCES + '["' + serializeString(this.scopeId) + '"])';
-    const body = mainBody + (patches ? ref : "");
     return "(" + this.createFunction([params], body) + ")" + args;
   }
 };
@@ -3633,17 +3199,31 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
     this.alive = true;
     // Amount of pending promises/streams
     this.pending = 0;
+    this.initial = true;
+    this.buffer = [];
     this.onParseCallback = options.onParse;
     this.onErrorCallback = options.onError;
     this.onDoneCallback = options.onDone;
   }
-  onParse(node, initial) {
+  onParseInternal(node, initial) {
     try {
       this.onParseCallback(node, initial);
     } catch (error) {
       this.onError(error);
     }
   }
+  flush() {
+    for (let i = 0, len = this.buffer.length; i < len; i++) {
+      this.onParseInternal(this.buffer[i], false);
+    }
+  }
+  onParse(node) {
+    if (this.initial) {
+      this.buffer.push(node);
+    } else {
+      this.onParseInternal(node, false);
+    }
+  }
   onError(error) {
     if (this.onErrorCallback) {
       this.onErrorCallback(error);
@@ -3656,12 +3236,6 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
       this.onDoneCallback();
     }
   }
-  push(value) {
-    this.onParse(
-      this.parse(value),
-      false
-    );
-  }
   pushPendingState() {
     this.pending++;
   }
@@ -3678,48 +3252,41 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
       keyNodes.push(serializeString(entries[i][0]));
       valueNodes.push(this.parse(entries[i][1]));
     }
-    if (this.features & 1024 /* Symbol */) {
-      let symbol = Symbol.iterator;
-      if (symbol in properties) {
-        keyNodes.push(
-          this.parseWKSymbol(symbol)
-        );
-        valueNodes.push(
-          createIteratorFactoryInstanceNode(
-            this.parseIteratorFactory(),
-            this.parse(
-              iteratorToSequence(properties)
-            )
+    let symbol = Symbol.iterator;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(
+        createIteratorFactoryInstanceNode(
+          this.parseIteratorFactory(),
+          this.parse(
+            iteratorToSequence(properties)
           )
-        );
-      }
-      symbol = Symbol.asyncIterator;
-      if (symbol in properties) {
-        keyNodes.push(
-          this.parseWKSymbol(symbol)
-        );
-        valueNodes.push(
-          createAsyncIteratorFactoryInstanceNode(
-            this.parseAsyncIteratorFactory(1),
-            this.parse(
-              asyncIteratorToReadableStream(
-                properties,
-                this
-              )
+        )
+      );
+    }
+    symbol = Symbol.asyncIterator;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(
+        createAsyncIteratorFactoryInstanceNode(
+          this.parseAsyncIteratorFactory(),
+          this.parse(
+            createStreamFromAsyncIterable(
+              properties
             )
           )
-        );
-      }
-      symbol = Symbol.toStringTag;
-      if (symbol in properties) {
-        keyNodes.push(this.parseWKSymbol(symbol));
-        valueNodes.push(createStringNode(properties[symbol]));
-      }
-      symbol = Symbol.isConcatSpreadable;
-      if (symbol in properties) {
-        keyNodes.push(this.parseWKSymbol(symbol));
-        valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
-      }
+        )
+      );
+    }
+    symbol = Symbol.toStringTag;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(createStringNode(properties[symbol]));
+    }
+    symbol = Symbol.isConcatSpreadable;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
     }
     return {
       k: keyNodes,
@@ -3727,141 +3294,13 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
       s: keyNodes.length
     };
   }
-  pushReadableStreamReader(id, reader) {
-    reader.read().then(
-      (data) => {
-        if (this.alive) {
-          if (data.done) {
-            this.onParse({
-              t: 33 /* ReadableStreamClose */,
-              i: id,
-              s: void 0,
-              l: void 0,
-              c: void 0,
-              m: void 0,
-              p: void 0,
-              e: void 0,
-              a: void 0,
-              f: this.parseSpecialReference(8 /* ReadableStreamClose */),
-              b: void 0,
-              o: void 0
-            }, false);
-            this.popPendingState();
-          } else {
-            const parsed = this.parseWithError(data.value);
-            if (parsed) {
-              this.onParse({
-                t: 32 /* ReadableStreamEnqueue */,
-                i: id,
-                s: void 0,
-                l: void 0,
-                c: void 0,
-                m: void 0,
-                p: void 0,
-                e: void 0,
-                a: [
-                  this.parseSpecialReference(6 /* ReadableStreamEnqueue */),
-                  parsed
-                ],
-                f: void 0,
-                b: void 0,
-                o: void 0
-              }, false);
-              this.pushReadableStreamReader(id, reader);
-            }
-          }
-        }
-      },
-      (value) => {
-        if (this.alive) {
-          const parsed = this.parseWithError(value);
-          if (parsed) {
-            this.onParse({
-              t: 34 /* ReadableStreamError */,
-              i: id,
-              s: void 0,
-              l: void 0,
-              c: void 0,
-              m: void 0,
-              p: void 0,
-              e: void 0,
-              a: [
-                this.parseSpecialReference(7 /* ReadableStreamError */),
-                parsed
-              ],
-              f: void 0,
-              b: void 0,
-              o: void 0
-            }, false);
-          }
-          this.popPendingState();
-        }
-      }
-    );
-  }
-  parseReadableStream(id, current) {
-    const reader = current.getReader();
-    this.pushPendingState();
-    this.pushReadableStreamReader(id, reader);
-    return {
-      t: 31 /* ReadableStreamConstructor */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: this.parseSpecialReference(5 /* ReadableStreamConstructor */),
-      b: void 0,
-      o: void 0
-    };
-  }
-  parseRequest(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: this.parse(
-        createRequestOptions(current, current.clone().body)
-      ),
-      a: void 0,
-      b: void 0,
-      o: void 0
-    };
-  }
-  parseResponse(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 ? this.parse(current.clone().body) : NULL_NODE,
-        this.parse(createResponseOptions(current))
-      ],
-      b: void 0,
-      o: void 0
-    };
-  }
   parsePromise(id, current) {
     current.then(
       (data) => {
         const parsed = this.parseWithError(data);
         if (parsed) {
           this.onParse({
-            t: 29 /* PromiseResolve */,
+            t: 23 /* PromiseResolve */,
             i: id,
             s: void 0,
             l: void 0,
@@ -3870,13 +3309,13 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
             p: void 0,
             e: void 0,
             a: [
-              this.parseSpecialReference(3 /* PromiseResolve */),
+              this.parseSpecialReference(2 /* PromiseResolve */),
               parsed
             ],
             f: void 0,
             b: void 0,
             o: void 0
-          }, false);
+          });
         }
         this.popPendingState();
       },
@@ -3885,7 +3324,7 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
           const parsed = this.parseWithError(data);
           if (parsed) {
             this.onParse({
-              t: 30 /* PromiseReject */,
+              t: 24 /* PromiseReject */,
               i: id,
               s: void 0,
               l: void 0,
@@ -3894,13 +3333,13 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
               p: void 0,
               e: void 0,
               a: [
-                this.parseSpecialReference(4 /* PromiseReject */),
+                this.parseSpecialReference(3 /* PromiseReject */),
                 parsed
               ],
               f: void 0,
               b: void 0,
               o: void 0
-            }, false);
+            });
           }
         }
         this.popPendingState();
@@ -3908,7 +3347,7 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
     );
     this.pushPendingState();
     return {
-      t: 28 /* PromiseConstructor */,
+      t: 22 /* PromiseConstructor */,
       i: id,
       s: void 0,
       l: void 0,
@@ -3917,7 +3356,7 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
       p: void 0,
       e: void 0,
       a: void 0,
-      f: this.parseSpecialReference(2 /* PromiseConstructor */),
+      f: this.parseSpecialReference(1 /* PromiseConstructor */),
       b: void 0,
       o: void 0
     };
@@ -3940,129 +3379,42 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
     }
     return void 0;
   }
-  parseObject(id, current) {
-    if (Array.isArray(current)) {
-      return this.parseArray(id, current);
-    }
-    const currentClass = current.constructor;
-    switch (currentClass) {
-      case Object:
-        return this.parsePlainObject(
-          id,
-          current,
-          false
-        );
-      case void 0:
-        return this.parsePlainObject(
-          id,
-          current,
-          true
-        );
-      case Date:
-        return createDateNode(id, current);
-      case RegExp:
-        return createRegExpNode(id, current);
-      case Error:
-      case EvalError:
-      case RangeError:
-      case ReferenceError:
-      case SyntaxError:
-      case TypeError:
-      case URIError:
-        return this.parseError(id, current);
-      case Number:
-      case Boolean:
-      case String:
-      case BigInt:
-        return this.parseBoxed(id, current);
-      default:
-        break;
-    }
-    const currentFeatures = this.features;
-    if (currentFeatures & 256 /* Promise */ && (currentClass === Promise || current instanceof Promise)) {
-      return this.parsePromise(id, current);
-    }
-    if (currentFeatures & 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 this.parseTypedArray(id, current);
-        case DataView:
-          return this.parseDataView(id, current);
-        default:
-          break;
-      }
-    }
-    if ((currentFeatures & BIGINT_FLAG) === BIGINT_FLAG) {
-      switch (currentClass) {
-        case BigInt64Array:
-        case BigUint64Array:
-          return this.parseBigIntTypedArray(id, current);
-        default:
-          break;
-      }
-    }
-    if (currentFeatures & 32 /* Map */ && currentClass === Map) {
-      return this.parseMap(
-        id,
-        current
-      );
-    }
-    if (currentFeatures & 512 /* Set */ && currentClass === Set) {
-      return this.parseSet(
-        id,
-        current
-      );
-    }
-    if (currentFeatures & 8192 /* WebAPI */) {
-      switch (currentClass) {
-        case (typeof URL !== "undefined" ? URL : UNIVERSAL_SENTINEL):
-          return createURLNode(id, current);
-        case (typeof URLSearchParams !== "undefined" ? URLSearchParams : UNIVERSAL_SENTINEL):
-          return createURLSearchParamsNode(id, current);
-        case (typeof Headers !== "undefined" ? Headers : UNIVERSAL_SENTINEL):
-          return this.parseHeaders(id, current);
-        case (typeof FormData !== "undefined" ? FormData : UNIVERSAL_SENTINEL):
-          return this.parseFormData(id, current);
-        case (typeof ReadableStream !== "undefined" ? ReadableStream : UNIVERSAL_SENTINEL):
-          return this.parseReadableStream(id, current);
-        case (typeof Request !== "undefined" ? Request : UNIVERSAL_SENTINEL):
-          return this.parseRequest(id, current);
-        case (typeof Response !== "undefined" ? Response : UNIVERSAL_SENTINEL):
-          return this.parseResponse(id, current);
-        case (typeof Event !== "undefined" ? Event : UNIVERSAL_SENTINEL):
-          return this.parseEvent(id, current);
-        case (typeof CustomEvent !== "undefined" ? CustomEvent : UNIVERSAL_SENTINEL):
-          return this.parseCustomEvent(id, current);
-        case (typeof DOMException !== "undefined" ? DOMException : UNIVERSAL_SENTINEL):
-          return createDOMExceptionNode(id, current);
-        default:
-          break;
+  parseStream(id, current) {
+    const result = createStreamConstructorNode(
+      id,
+      this.parseSpecialReference(4 /* StreamConstructor */),
+      []
+    );
+    this.pushPendingState();
+    current.on({
+      next: (value) => {
+        if (this.alive) {
+          const parsed = this.parseWithError(value);
+          if (parsed) {
+            this.onParse(createStreamNextNode(id, parsed));
+          }
+        }
+      },
+      throw: (value) => {
+        if (this.alive) {
+          const parsed = this.parseWithError(value);
+          if (parsed) {
+            this.onParse(createStreamThrowNode(id, parsed));
+          }
+        }
+        this.popPendingState();
+      },
+      return: (value) => {
+        if (this.alive) {
+          const parsed = this.parseWithError(value);
+          if (parsed) {
+            this.onParse(createStreamReturnNode(id, parsed));
+          }
+        }
+        this.popPendingState();
       }
-    }
-    const parsed = this.parsePlugin(id, current);
-    if (parsed) {
-      return parsed;
-    }
-    if (currentFeatures & 1 /* AggregateError */ && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) {
-      return this.parseAggregateError(id, current);
-    }
-    if (current instanceof Error) {
-      return this.parseError(id, current);
-    }
-    if (currentFeatures & 1024 /* Symbol */ && (Symbol.iterator in current || Symbol.asyncIterator in current)) {
-      return this.parsePlainObject(id, current, !!currentClass);
-    }
-    throw new UnsupportedTypeError(current);
+    });
+    return result;
   }
   parseWithError(current) {
     try {
@@ -4078,7 +3430,9 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
   start(current) {
     const parsed = this.parseWithError(current);
     if (parsed) {
-      this.onParse(parsed, true);
+      this.onParseInternal(parsed, true);
+      this.initial = false;
+      this.flush();
       if (this.pending <= 0) {
         this.destroy();
       }
@@ -4115,63 +3469,65 @@ var CrossSyncParserContext = class extends BaseSyncParserContext {
 };
 
 // src/core/cross/index.ts
-function insertCrossReferenceHeader(scopeId, value) {
-  return "(" + getCrossReferenceHeader(scopeId) + "," + value + ")";
-}
 function crossSerialize(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new CrossSyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs
   });
   const tree = ctx.parse(source);
   const serial = new CrossSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     scopeId: options.scopeId,
     markedRefs: ctx.marked
   });
-  return insertCrossReferenceHeader(options.scopeId, serial.serializeTop(tree));
+  return serial.serializeTop(tree);
 }
 async function crossSerializeAsync(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new CrossAsyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs
   });
   const tree = await ctx.parse(source);
   const serial = new CrossSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     scopeId: options.scopeId,
     markedRefs: ctx.marked
   });
-  return insertCrossReferenceHeader(options.scopeId, serial.serializeTop(tree));
+  return serial.serializeTop(tree);
 }
 function toCrossJSON(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new CrossSyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs
   });
   return ctx.parse(source);
 }
 async function toCrossJSONAsync(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new CrossAsyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs
   });
-  return ctx.parse(source);
+  return await ctx.parse(source);
 }
 function crossSerializeStream(source, options) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new CrossStreamParserContext({
-    plugins: options.plugins,
+    plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
     onParse(node, initial) {
       const serial = new CrossSerializerContext({
-        plugins: options.plugins,
+        plugins,
         features: ctx.features,
         scopeId: options.scopeId,
         markedRefs: ctx.marked
@@ -4185,13 +3541,7 @@ function crossSerializeStream(source, options) {
         }
         return;
       }
-      if (initial) {
-        serialized = insertCrossReferenceHeader(options.scopeId, serialized);
-      }
-      options.onSerialize(
-        serialized,
-        initial
-      );
+      options.onSerialize(serialized, initial);
     },
     onError: options.onError,
     onDone: options.onDone
@@ -4202,8 +3552,9 @@ function crossSerializeStream(source, options) {
   };
 }
 function toCrossJSONStream(source, options) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new CrossStreamParserContext({
-    plugins: options.plugins,
+    plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
     onParse: options.onParse,
@@ -4216,8 +3567,9 @@ function toCrossJSONStream(source, options) {
   };
 }
 function fromCrossJSON(source, options) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new CrossDeserializerContext({
-    plugins: options.plugins,
+    plugins,
     refs: options.refs
   });
   return ctx.deserialize(source);
@@ -4235,34 +3587,37 @@ var Serializer = class {
     this.refs = /* @__PURE__ */ new Map();
     this.keys = /* @__PURE__ */ new Set();
     this.ids = 0;
+    this.plugins = resolvePlugins(options.plugins);
   }
   write(key, value) {
     if (this.alive && !this.flushed) {
       this.pending++;
       this.keys.add(key);
-      this.cleanups.push(crossSerializeStream(value, {
-        plugins: this.options.plugins,
-        scopeId: this.options.scopeId,
-        refs: this.refs,
-        disabledFeatures: this.options.disabledFeatures,
-        onError: this.options.onError,
-        onSerialize: (data, initial) => {
-          if (this.alive) {
-            this.options.onData(
-              initial ? this.options.globalIdentifier + '["' + serializeString(key) + '"]=' + data : data
-            );
-          }
-        },
-        onDone: () => {
-          if (this.alive) {
-            this.pending--;
-            if (this.pending <= 0 && this.flushed && !this.done && this.options.onDone) {
-              this.options.onDone();
-              this.done = true;
+      this.cleanups.push(
+        crossSerializeStream(value, {
+          plugins: this.plugins,
+          scopeId: this.options.scopeId,
+          refs: this.refs,
+          disabledFeatures: this.options.disabledFeatures,
+          onError: this.options.onError,
+          onSerialize: (data, initial) => {
+            if (this.alive) {
+              this.options.onData(
+                initial ? this.options.globalIdentifier + '["' + serializeString(key) + '"]=' + data : data
+              );
+            }
+          },
+          onDone: () => {
+            if (this.alive) {
+              this.pending--;
+              if (this.pending <= 0 && this.flushed && !this.done && this.options.onDone) {
+                this.options.onDone();
+                this.done = true;
+              }
             }
           }
-        }
-      }));
+        })
+      );
     }
   }
   getNextID() {
@@ -4298,27 +3653,21 @@ var Serializer = class {
     }
   }
 };
-
-// src/core/plugin.ts
-function createPlugin(plugin) {
-  return plugin;
-}
-
-// src/index.ts
-var src_default = serialize;
 export {
   Feature,
   Serializer,
   compileJSON,
   createPlugin,
   createReference,
+  createStream,
   crossSerialize,
   crossSerializeAsync,
   crossSerializeStream,
-  src_default as default,
   deserialize,
   fromCrossJSON,
   fromJSON,
+  getCrossReferenceHeader,
+  resolvePlugins,
   serialize,
   serializeAsync,
   toCrossJSON,