seroval 0.12.4 → 0.13.0

package/dist/cjs/development/index.cjs

@@ -31,10 +31,14 @@ __export(src_exports, {
   crossSerializeStream: () => crossSerializeStream,
   default: () => src_default,
   deserialize: () => deserialize,
+  fromCrossJSON: () => fromCrossJSON,
   fromJSON: () => fromJSON,
   getCrossReferenceHeader: () => getCrossReferenceHeader,
   serialize: () => serialize,
   serializeAsync: () => serializeAsync,
+  toCrossJSON: () => toCrossJSON,
+  toCrossJSONAsync: () => toCrossJSONAsync,
+  toCrossJSONStream: () => toCrossJSONStream,
   toJSON: () => toJSON,
   toJSONAsync: () => toJSONAsync
 });
@@ -49,7 +53,7 @@ var UnsupportedTypeError = class extends Error {
   }
 };
 
-// src/core/assert.ts
+// src/core/utils/assert.ts
 function assert(cond, error) {
   if (!cond) {
     throw error;
@@ -140,7 +144,6 @@ var ERROR_CONSTRUCTOR = {
   [5 /* TypeError */]: TypeError,
   [6 /* URIError */]: URIError
 };
-var UNIVERSAL_SENTINEL = Symbol("why");
 
 // src/core/literals.ts
 function createConstantNode(value) {
@@ -228,9 +231,11 @@ var GLOBAL_CONTEXT_PROMISE_RESOLVE = "Ps";
 var GLOBAL_CONTEXT_PROMISE_REJECT = "Pf";
 var LOCAL_CONTEXT_STREAM_CONTROLLER = "c";
 var GLOBAL_CONTEXT_STREAM_CONSTRUCTOR = "S";
-var GLOBAL_CONTEXT_STREAM_EMIT = "Se";
+var GLOBAL_CONTEXT_STREAM_ENQUEUE = "Se";
+var GLOBAL_CONTEXT_STREAM_ERROR = "St";
+var GLOBAL_CONTEXT_STREAM_CLOSE = "Sc";
 var GLOBAL_CONTEXT_API_REF = `self.${GLOBAL_CONTEXT_API}`;
-var GLOBAL_CONTEXT_API_SCRIPT = `${GLOBAL_CONTEXT_API_REF}=${GLOBAL_CONTEXT_API_REF}||{${GLOBAL_CONTEXT_PROMISE_CONSTRUCTOR}:function(s,f,p){return(p=new Promise(function(a,b){s=a,f=b})).${LOCAL_CONTEXT_PROMISE_RESOLVE}=s,p.${LOCAL_CONTEXT_PROMISE_REJECT}=f,p},uP:function(p){delete p.${LOCAL_CONTEXT_PROMISE_RESOLVE};delete p.${LOCAL_CONTEXT_PROMISE_REJECT}},${GLOBAL_CONTEXT_PROMISE_RESOLVE}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_RESOLVE}(d),p.status="success",p.value=d,this.uP(p)},${GLOBAL_CONTEXT_PROMISE_REJECT}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_REJECT}(d),p.status="failure",p.value=d,this.uP(p)},uS:function(s){delete s.${LOCAL_CONTEXT_STREAM_CONTROLLER}},${GLOBAL_CONTEXT_STREAM_EMIT}:function(s,t,d,c){switch(c=s.${LOCAL_CONTEXT_STREAM_CONTROLLER},t){case 0:return c.enqueue(d);case 1:return(this.uS(s),c.error(d));case 2:return(this.uS(s),c.close())}},${GLOBAL_CONTEXT_STREAM_CONSTRUCTOR}:function(s,c){return(s=new ReadableStream({start:function(x){c=x}})).${LOCAL_CONTEXT_STREAM_CONTROLLER}=c,s}}`;
+var GLOBAL_CONTEXT_API_SCRIPT = `${GLOBAL_CONTEXT_API_REF}=${GLOBAL_CONTEXT_API_REF}||{${GLOBAL_CONTEXT_PROMISE_CONSTRUCTOR}:function(s,f,p){return(p=new Promise(function(a,b){s=a,f=b})).${LOCAL_CONTEXT_PROMISE_RESOLVE}=s,p.${LOCAL_CONTEXT_PROMISE_REJECT}=f,p},uP:function(p){delete p.${LOCAL_CONTEXT_PROMISE_RESOLVE};delete p.${LOCAL_CONTEXT_PROMISE_REJECT}},${GLOBAL_CONTEXT_PROMISE_RESOLVE}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_RESOLVE}(d),p.status="success",p.value=d,this.uP(p)},${GLOBAL_CONTEXT_PROMISE_REJECT}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_REJECT}(d),p.status="failure",p.value=d,this.uP(p)},uS:function(s){delete s.${LOCAL_CONTEXT_STREAM_CONTROLLER}},${GLOBAL_CONTEXT_STREAM_CLOSE}:function(s){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.close(),this.uS(s)},${GLOBAL_CONTEXT_STREAM_ERROR}:function(s,e){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.error(e),this.uS(s)},${GLOBAL_CONTEXT_STREAM_ENQUEUE}:function(s,d){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.enqueue(d)},${GLOBAL_CONTEXT_STREAM_CONSTRUCTOR}:function(s,c){return(s=new ReadableStream({start:function(x){c=x}})).${LOCAL_CONTEXT_STREAM_CONTROLLER}=c,s}}`;
 var GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`;
 function getCrossReferenceHeader(id) {
   if (id == null) {
@@ -291,6 +296,87 @@ 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/utils/error.ts
+function getErrorConstructor(error) {
+  if (error instanceof EvalError) {
+    return 1 /* EvalError */;
+  }
+  if (error instanceof RangeError) {
+    return 2 /* RangeError */;
+  }
+  if (error instanceof ReferenceError) {
+    return 3 /* ReferenceError */;
+  }
+  if (error instanceof SyntaxError) {
+    return 4 /* SyntaxError */;
+  }
+  if (error instanceof TypeError) {
+    return 5 /* TypeError */;
+  }
+  if (error instanceof URIError) {
+    return 6 /* URIError */;
+  }
+  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 };
+  }
+  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 */) {
+          options = options || {};
+          options[name] = error[name];
+        }
+      } else {
+        options = options || {};
+        options[name] = error[name];
+      }
+    }
+  }
+  return options;
+}
+
+// src/core/utils/get-object-flag.ts
+function getObjectFlag(obj) {
+  if (Object.isFrozen(obj)) {
+    return 3 /* Frozen */;
+  }
+  if (Object.isSealed(obj)) {
+    return 2 /* Sealed */;
+  }
+  if (Object.isExtensible(obj)) {
+    return 0 /* None */;
+  }
+  return 1 /* NonExtensible */;
+}
+
 // src/core/base-primitives.ts
 function createNumberNode(value) {
   switch (value) {
@@ -472,29 +558,174 @@ function createPluginNode(id, tag, value) {
     o: void 0
   };
 }
+function createArrayNode(id, current, parsedItems) {
+  return {
+    t: 9 /* Array */,
+    i: id,
+    s: void 0,
+    l: current.length,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: parsedItems,
+    f: void 0,
+    b: void 0,
+    o: getObjectFlag(current)
+  };
+}
+function createBoxedNode(id, boxed) {
+  return {
+    t: 27 /* Boxed */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: boxed,
+    b: void 0,
+    o: void 0
+  };
+}
+function createTypedArrayNode(id, current, buffer) {
+  return {
+    t: 15 /* TypedArray */,
+    i: id,
+    s: void 0,
+    l: current.length,
+    c: current.constructor.name,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: buffer,
+    b: current.byteOffset,
+    o: void 0
+  };
+}
+function createBigIntTypedArrayNode(id, current, buffer) {
+  return {
+    t: 16 /* BigIntTypedArray */,
+    i: id,
+    s: void 0,
+    l: current.length,
+    c: current.constructor.name,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: buffer,
+    b: current.byteOffset,
+    o: void 0
+  };
+}
+function createDataViewNode(id, current, buffer) {
+  return {
+    t: 22 /* DataView */,
+    i: id,
+    s: void 0,
+    l: current.byteLength,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: void 0,
+    f: buffer,
+    b: current.byteOffset,
+    o: void 0
+  };
+}
+function createErrorNode(id, current, options) {
+  return {
+    t: 13 /* Error */,
+    i: id,
+    s: getErrorConstructor(current),
+    l: void 0,
+    c: void 0,
+    m: serializeString(current.message),
+    p: options,
+    e: void 0,
+    a: void 0,
+    f: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
+function createAggregateErrorNode(id, current, options) {
+  return {
+    t: 14 /* AggregateError */,
+    i: id,
+    s: getErrorConstructor(current),
+    l: void 0,
+    c: void 0,
+    m: serializeString(current.message),
+    p: options,
+    e: void 0,
+    a: void 0,
+    f: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
+function createSetNode(id, size, items) {
+  return {
+    t: 7 /* Set */,
+    i: id,
+    s: void 0,
+    l: size,
+    c: void 0,
+    m: void 0,
+    p: void 0,
+    e: void 0,
+    a: items,
+    f: void 0,
+    b: void 0,
+    o: void 0
+  };
+}
+function createIteratorFactoryInstanceNode(factory, items) {
+  return {
+    t: 43 /* IteratorFactoryInstance */,
+    i: void 0,
+    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 createAsyncIteratorFactoryInstanceNode(factory, items) {
+  return {
+    t: 45 /* AsyncIteratorFactoryInstance */,
+    i: void 0,
+    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
+  };
+}
 
-// src/core/compat.ts
-var Feature = /* @__PURE__ */ ((Feature2) => {
-  Feature2[Feature2["AggregateError"] = 1] = "AggregateError";
-  Feature2[Feature2["ArrayPrototypeValues"] = 2] = "ArrayPrototypeValues";
-  Feature2[Feature2["ArrowFunction"] = 4] = "ArrowFunction";
-  Feature2[Feature2["BigInt"] = 8] = "BigInt";
-  Feature2[Feature2["ErrorPrototypeStack"] = 16] = "ErrorPrototypeStack";
-  Feature2[Feature2["Map"] = 32] = "Map";
-  Feature2[Feature2["MethodShorthand"] = 64] = "MethodShorthand";
-  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/constructors.ts
+// src/core/utils/constructors.ts
 function createRequestOptions(current, body) {
   return {
     body,
@@ -533,210 +764,399 @@ function createCustomEventOptions(current) {
   };
 }
 
-// src/core/parser-context.ts
-var BaseParserContext = class {
-  constructor(options) {
-    this.marked = /* @__PURE__ */ new Set();
-    this.plugins = options.plugins;
-    this.features = ALL_ENABLED ^ (options.disabledFeatures || 0);
-    this.refs = options.refs || /* @__PURE__ */ new Map();
-  }
-  markRef(id) {
-    this.marked.add(id);
-  }
-  isMarked(id) {
-    return this.marked.has(id);
-  }
-  getReference(current) {
-    const registeredID = this.refs.get(current);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+// src/core/utils/iterator-to-sequence.ts
+function iteratorToSequence(source) {
+  const values = [];
+  let throwsAt = -1;
+  let doneAt = -1;
+  const iterator = source[Symbol.iterator]();
+  while (true) {
+    try {
+      const value = iterator.next();
+      values.push(value.value);
+      if (value.done) {
+        doneAt = values.length - 1;
+        break;
+      }
+    } catch (error) {
+      throwsAt = values.length;
+      values.push(error);
     }
-    const id = this.refs.size;
-    this.refs.set(current, id);
-    if (hasReferenceID(current)) {
-      return createReferenceNode(id, current);
+  }
+  return {
+    v: values,
+    t: throwsAt,
+    d: doneAt
+  };
+}
+function sequenceToIterator(sequence) {
+  return () => {
+    let index = 0;
+    return {
+      [Symbol.iterator]() {
+        return this;
+      },
+      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 {
+          done: currentIndex === sequence.d,
+          value: currentItem
+        };
+      }
+    };
+  };
+}
+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 id;
   }
-  getStrictReference(current) {
-    const registeredID = this.refs.get(current);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
-    }
-    const id = this.refs.size;
-    this.refs.set(current, id);
-    return createReferenceNode(id, current);
-  }
-  /**
-   * @private
-   */
-  isIterable(value) {
-    if (!value || typeof value !== "object") {
-      return false;
-    }
-    if (Array.isArray(value)) {
-      return false;
-    }
-    const currentClass = value.constructor;
-    const currentFeatures = this.features;
-    if (currentFeatures & 2048 /* TypedArray */) {
-      switch (currentClass) {
-        case Int8Array:
-        case Int16Array:
-        case Int32Array:
-        case Uint8Array:
-        case Uint16Array:
-        case Uint32Array:
-        case Uint8ClampedArray:
-        case Float32Array:
-        case Float64Array:
-          return false;
-        default:
-          break;
+  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
+        });
       }
-    }
-    if ((currentFeatures & BIGINT_FLAG) === BIGINT_FLAG) {
-      switch (currentClass) {
-        case BigInt64Array:
-        case BigUint64Array:
-          return false;
-        default:
-          break;
+    };
+  };
+}
+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();
     }
-    if (currentFeatures & 32 /* Map */ && currentClass === Map) {
-      return false;
-    }
-    if (currentFeatures & 512 /* Set */ && currentClass === Set) {
-      return false;
-    }
-    if (currentFeatures & 8192 /* WebAPI */) {
-      if (typeof Headers !== "undefined" && currentClass === Headers) {
-        return false;
+  });
+}
+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
+        };
       }
-      if (typeof File !== "undefined" && currentClass === File) {
-        return false;
+    };
+  };
+}
+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;
     }
-    const currentPlugins = this.plugins;
-    if (currentPlugins) {
-      for (let i = 0, len = currentPlugins.length; i < len; i++) {
-        const plugin = currentPlugins[i];
-        if (plugin.test(value) && plugin.isIterable && plugin.isIterable(value)) {
-          return false;
-        }
+  }
+  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]);
       }
     }
-    if (currentFeatures & 1024 /* Symbol */) {
-      return Symbol.iterator in value;
-    }
-    return false;
-  }
-};
-
-// src/core/promise-to-result.ts
-async function promiseToResult(current) {
-  try {
-    return [1, await current];
-  } catch (e) {
-    return [0, e];
-  }
+  });
 }
 
-// src/core/shared.ts
-function getErrorConstructor(error) {
-  if (error instanceof EvalError) {
-    return 1 /* EvalError */;
+// src/core/special-reference.ts
+var MAP_SENTINEL = {};
+var ITERATOR = {};
+var ASYNC_ITERATOR = {};
+var READABLE_STREAM = {};
+var UNIVERSAL_SENTINEL = {};
+
+// src/core/context/parser.ts
+var BaseParserContext = class {
+  constructor(options) {
+    this.marked = /* @__PURE__ */ new Set();
+    this.plugins = options.plugins;
+    this.features = ALL_ENABLED ^ (options.disabledFeatures || 0);
+    this.refs = options.refs || /* @__PURE__ */ new Map();
   }
-  if (error instanceof RangeError) {
-    return 2 /* RangeError */;
+  markRef(id) {
+    this.marked.add(id);
   }
-  if (error instanceof ReferenceError) {
-    return 3 /* ReferenceError */;
+  isMarked(id) {
+    return this.marked.has(id);
   }
-  if (error instanceof SyntaxError) {
-    return 4 /* SyntaxError */;
+  getReference(current) {
+    const registeredID = this.refs.get(current);
+    if (registeredID != null) {
+      this.markRef(registeredID);
+      return createIndexedValueNode(registeredID);
+    }
+    const id = this.refs.size;
+    this.refs.set(current, id);
+    if (hasReferenceID(current)) {
+      return createReferenceNode(id, current);
+    }
+    return id;
   }
-  if (error instanceof TypeError) {
-    return 5 /* TypeError */;
+  getStrictReference(current) {
+    const registeredID = this.refs.get(current);
+    if (registeredID != null) {
+      this.markRef(registeredID);
+      return createIndexedValueNode(registeredID);
+    }
+    const id = this.refs.size;
+    this.refs.set(current, id);
+    return createReferenceNode(id, current);
   }
-  if (error instanceof URIError) {
-    return 6 /* URIError */;
+  // 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);
   }
-  return 0 /* Error */;
-}
-function getTypedArrayConstructor(name) {
-  switch (name) {
-    case "Int8Array":
-      return Int8Array;
-    case "Int16Array":
-      return Int16Array;
-    case "Int32Array":
-      return Int32Array;
-    case "Uint8Array":
-      return Uint8Array;
-    case "Uint16Array":
-      return Uint16Array;
-    case "Uint32Array":
-      return Uint32Array;
-    case "Uint8ClampedArray":
-      return Uint8ClampedArray;
-    case "Float32Array":
-      return Float32Array;
-    case "Float64Array":
-      return Float64Array;
-    case "BigInt64Array":
-      return BigInt64Array;
-    case "BigUint64Array":
-      return BigUint64Array;
-    default:
-      throw new Error(`Unknown TypedArray "${name}"`);
+  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);
+    }
+    return createReferenceNode(id, current);
   }
-}
-var IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;
-function isValidIdentifier(name) {
-  const char = name[0];
-  return (char === "$" || char === "_" || char >= "A" && char <= "Z" || char >= "a" && char <= "z") && IDENTIFIER_CHECK.test(name);
-}
-function getObjectFlag(obj) {
-  if (Object.isFrozen(obj)) {
-    return 3 /* Frozen */;
+  parseMapSentinel() {
+    const registeredID = this.refs.get(MAP_SENTINEL);
+    if (registeredID != null) {
+      this.markRef(registeredID);
+      return createIndexedValueNode(registeredID);
+    }
+    const id = this.refs.size;
+    this.refs.set(MAP_SENTINEL, id);
+    return {
+      t: 41 /* MapSentinel */,
+      i: id,
+      s: void 0,
+      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
+    };
   }
-  if (Object.isSealed(obj)) {
-    return 2 /* Sealed */;
+  parseIteratorFactory() {
+    const registeredID = this.refs.get(ITERATOR);
+    if (registeredID != null) {
+      this.markRef(registeredID);
+      return createIndexedValueNode(registeredID);
+    }
+    const id = this.refs.size;
+    this.refs.set(ITERATOR, id);
+    return {
+      t: 42 /* IteratorFactory */,
+      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.parseWKSymbol(Symbol.iterator),
+      b: void 0,
+      o: void 0
+    };
   }
-  if (Object.isExtensible(obj)) {
-    return 0 /* None */;
+  parseAsyncIteratorFactory() {
+    const registeredID = this.refs.get(ASYNC_ITERATOR);
+    if (registeredID != null) {
+      this.markRef(registeredID);
+      return createIndexedValueNode(registeredID);
+    }
+    const id = this.refs.size;
+    this.refs.set(ASYNC_ITERATOR, id);
+    return {
+      t: 44 /* AsyncIteratorFactory */,
+      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.parseWKSymbol(Symbol.asyncIterator),
+      b: void 0,
+      o: void 0
+    };
   }
-  return 1 /* NonExtensible */;
-}
-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 };
+  createObjectNode(id, current, empty, record) {
+    return {
+      t: empty ? 11 /* NullConstructor */ : 10 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: record,
+      e: void 0,
+      a: void 0,
+      f: void 0,
+      b: void 0,
+      o: getObjectFlag(current)
+    };
   }
-  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 */) {
-          options = options || {};
-          options[name] = error[name];
-        }
-      } else {
-        options = options || {};
-        options[name] = error[name];
-      }
+  createMapNode(id, k, v, s) {
+    return {
+      t: 8 /* Map */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: void 0,
+      e: { k, v, s },
+      a: void 0,
+      f: this.parseMapSentinel(),
+      b: void 0,
+      o: void 0
+    };
+  }
+  parseReadableStreamFactory() {
+    const registeredID = this.refs.get(READABLE_STREAM);
+    if (registeredID != null) {
+      this.markRef(registeredID);
+      return createIndexedValueNode(registeredID);
     }
+    const id = this.refs.size;
+    this.refs.set(READABLE_STREAM, id);
+    return {
+      t: 47 /* ReadableStreamFactory */,
+      i: id,
+      s: void 0,
+      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
+    };
+  }
+};
+
+// src/core/utils/promise-to-result.ts
+async function promiseToResult(current) {
+  try {
+    return [1, await current];
+  } catch (e) {
+    return [0, e];
   }
-  return options;
 }
 
 // src/core/web-api.ts
@@ -788,135 +1208,122 @@ function createDOMExceptionNode(id, current) {
     o: void 0
   };
 }
+function createEventNode(id, type, options) {
+  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
+  };
+}
+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 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
+  };
+}
 
-// src/core/base/async.ts
+// src/core/context/parser/async.ts
 var BaseAsyncParserContext = class extends BaseParserContext {
   async parseItems(current) {
-    const size = current.length;
     const nodes = [];
-    const deferred = [];
-    for (let i = 0, item; i < size; i++) {
+    for (let i = 0, len = current.length; i < len; i++) {
       if (i in current) {
-        item = current[i];
-        if (this.isIterable(item)) {
-          deferred[i] = item;
-        } else {
-          nodes[i] = await this.parse(item);
-        }
-      }
-    }
-    for (let i = 0; i < size; i++) {
-      if (i in deferred) {
-        nodes[i] = await this.parse(deferred[i]);
+        nodes[i] = await this.parse(current[i]);
       }
     }
     return nodes;
   }
   async parseArray(id, current) {
-    return {
-      t: 9 /* Array */,
-      i: id,
-      s: void 0,
-      l: current.length,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: await this.parseItems(current),
-      f: void 0,
-      b: void 0,
-      o: getObjectFlag(current)
-    };
-  }
-  async parseBoxed(id, current) {
-    return {
-      t: 27 /* Boxed */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: await this.parse(current.valueOf()),
-      b: void 0,
-      o: void 0
-    };
-  }
-  async parseTypedArray(id, current) {
-    return {
-      t: 15 /* TypedArray */,
-      i: id,
-      s: void 0,
-      l: current.length,
-      c: current.constructor.name,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: await this.parse(current.buffer),
-      b: current.byteOffset,
-      o: void 0
-    };
-  }
-  async parseBigIntTypedArray(id, current) {
-    return {
-      t: 16 /* BigIntTypedArray */,
-      i: id,
-      s: void 0,
-      l: current.length,
-      c: current.constructor.name,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: await this.parse(current.buffer),
-      b: current.byteOffset,
-      o: void 0
-    };
-  }
-  async parseDataView(id, current) {
-    return {
-      t: 22 /* DataView */,
-      i: id,
-      s: void 0,
-      l: current.byteLength,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: await this.parse(current.buffer),
-      b: current.byteOffset,
-      o: void 0
-    };
+    return createArrayNode(
+      id,
+      current,
+      await this.parseItems(current)
+    );
   }
   async parseProperties(properties) {
     const entries = Object.entries(properties);
     const keyNodes = [];
     const valueNodes = [];
-    const deferredKeys = [];
-    const deferredValues = [];
-    for (let i = 0, len = entries.length, key, item; i < len; i++) {
-      key = serializeString(entries[i][0]);
-      item = entries[i][1];
-      if (this.isIterable(item)) {
-        deferredKeys.push(key);
-        deferredValues.push(item);
-      } else {
-        keyNodes.push(key);
-        valueNodes.push(await this.parse(item));
-      }
-    }
-    for (let i = 0, len = deferredKeys.length; i < len; i++) {
-      keyNodes.push(deferredKeys[i]);
-      valueNodes.push(await this.parse(deferredValues[i]));
+    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 */) {
-      if (Symbol.iterator in properties) {
-        keyNodes.push(0 /* SymbolIterator */);
-        valueNodes.push(await this.parse(Array.from(properties)));
+      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(),
+            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 {
@@ -926,99 +1333,61 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     };
   }
   async parsePlainObject(id, current, empty) {
-    return {
-      t: empty ? 11 /* NullConstructor */ : 10 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: await this.parseProperties(current),
-      e: void 0,
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: getObjectFlag(current)
-    };
+    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);
-    const optionsNode = options ? await this.parseProperties(options) : void 0;
-    return {
-      t: 13 /* Error */,
-      i: id,
-      s: getErrorConstructor(current),
-      l: void 0,
-      c: void 0,
-      m: serializeString(current.message),
-      p: optionsNode,
-      e: void 0,
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
+    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 = [];
-    const deferredKey = [];
-    const deferredValue = [];
     for (const [key, value] of current.entries()) {
-      if (this.isIterable(key) || this.isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
-      } else {
-        keyNodes.push(await this.parse(key));
-        valueNodes.push(await this.parse(value));
-      }
-    }
-    for (let i = 0, len = deferredKey.length; i < len; i++) {
-      keyNodes.push(await this.parse(deferredKey[i]));
-      valueNodes.push(await this.parse(deferredValue[i]));
-    }
-    return {
-      t: 8 /* Map */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: { k: keyNodes, v: valueNodes, s: current.size },
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
+      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 nodes = [];
-    const deferred = [];
+    const items = [];
     for (const item of current.keys()) {
-      if (this.isIterable(item)) {
-        deferred.push(item);
-      } else {
-        nodes.push(await this.parse(item));
-      }
-    }
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(await this.parse(deferred[i]));
+      items.push(await this.parse(item));
     }
-    return {
-      t: 7 /* Set */,
-      i: id,
-      s: void 0,
-      l: current.size,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: nodes,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
+    return createSetNode(id, current.size, items);
   }
   async parseBlob(id, current) {
     return {
@@ -1056,22 +1425,9 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     const size = entries.length;
     const keyNodes = [];
     const valueNodes = [];
-    const deferredKeys = [];
-    const deferredValues = [];
-    for (let i = 0, key, item; i < size; i++) {
-      key = serializeString(entries[i][0]);
-      item = entries[i][1];
-      if (this.isIterable(item)) {
-        deferredKeys.push(key);
-        deferredValues.push(item);
-      } else {
-        keyNodes.push(key);
-        valueNodes.push(await this.parse(item));
-      }
-    }
-    for (let i = 0, len = deferredKeys.length; i < len; i++) {
-      keyNodes.push(deferredKeys[i]);
-      valueNodes.push(await this.parse(deferredValues[i]));
+    for (let i = 0; i < size; i++) {
+      keyNodes.push(serializeString(entries[i][0]));
+      valueNodes.push(await this.parse(entries[i][1]));
     }
     return {
       k: keyNodes,
@@ -1099,113 +1455,73 @@ var BaseAsyncParserContext = class extends BaseParserContext {
       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
-    };
-  }
-  async 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: await this.parse(
-        createRequestOptions(current, current.body ? await current.clone().arrayBuffer() : null)
-      ),
-      a: void 0,
-      b: void 0,
-      o: void 0
-    };
-  }
-  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 parseEvent(id, current) {
+  async parseFormData(id, current) {
+    const items = [];
+    current.forEach((value, key) => {
+      items.push([key, value]);
+    });
     return {
-      t: 37 /* Event */,
+      t: 26 /* FormData */,
       i: id,
-      s: serializeString(current.type),
+      s: void 0,
       l: void 0,
       c: void 0,
       m: void 0,
       p: void 0,
-      e: void 0,
+      e: await this.parsePlainProperties(items),
       a: void 0,
-      f: await this.parse(createEventOptions(current)),
+      f: void 0,
       b: void 0,
       o: void 0
     };
   }
-  async parseCustomEvent(id, current) {
+  async parseRequest(id, current) {
     return {
-      t: 38 /* CustomEvent */,
+      t: 35 /* Request */,
       i: id,
-      s: serializeString(current.type),
+      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,
-      f: await this.parse(createCustomEventOptions(current)),
       b: void 0,
       o: void 0
     };
   }
-  async parseAggregateError(id, current) {
-    const options = getErrorOptions(current, this.features);
-    const optionsNode = options ? await this.parseProperties(options) : void 0;
+  async parseResponse(id, current) {
     return {
-      t: 14 /* AggregateError */,
+      t: 36 /* Response */,
       i: id,
       s: void 0,
       l: void 0,
       c: void 0,
-      m: serializeString(current.message),
-      p: optionsNode,
+      m: void 0,
+      p: void 0,
       e: void 0,
-      a: 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 parseEvent(id, current) {
+    return createEventNode(id, current.type, await this.parse(createEventOptions(current)));
+  }
+  async parseCustomEvent(id, current) {
+    return createCustomEventNode(
+      id,
+      current.type,
+      await this.parse(createCustomEventOptions(current))
+    );
+  }
   async parsePromise(id, current) {
     const [status, result] = await promiseToResult(current);
     return {
@@ -1241,6 +1557,15 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     }
     return void 0;
   }
+  async parseReadableStream(id, current) {
+    return createReadableStreamNode(
+      id,
+      this.parseReadableStreamFactory(),
+      await this.parse(
+        await readableStreamToSequence(current)
+      )
+    );
+  }
   async parseObject(id, current) {
     if (Array.isArray(current)) {
       return this.parseArray(id, current);
@@ -1348,6 +1673,8 @@ var BaseAsyncParserContext = class extends BaseParserContext {
           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);
         default:
           break;
       }
@@ -1362,7 +1689,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     if (current instanceof Error) {
       return this.parseError(id, current);
     }
-    if (currentFeatures & 1024 /* Symbol */ && Symbol.iterator in current) {
+    if (currentFeatures & 1024 /* Symbol */ && (Symbol.iterator in current || Symbol.asyncIterator in current)) {
       return this.parsePlainObject(id, current, !!currentClass);
     }
     throw new UnsupportedTypeError(current);
@@ -1392,14 +1719,10 @@ var BaseAsyncParserContext = class extends BaseParserContext {
         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;
-      }
+      case "symbol":
+        return this.parseWKSymbol(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);
     }
@@ -1414,50 +1737,90 @@ var AsyncParserContext = class extends BaseAsyncParserContext {
   }
 };
 
-// src/core/tree/deserialize.ts
-function applyObjectFlag(obj, flag) {
-  switch (flag) {
-    case 3 /* Frozen */:
-      return Object.freeze(obj);
-    case 1 /* NonExtensible */:
-      return Object.preventExtensions(obj);
-    case 2 /* Sealed */:
-      return Object.seal(obj);
+// src/core/utils/typed-array.ts
+function getTypedArrayConstructor(name) {
+  switch (name) {
+    case "Int8Array":
+      return Int8Array;
+    case "Int16Array":
+      return Int16Array;
+    case "Int32Array":
+      return Int32Array;
+    case "Uint8Array":
+      return Uint8Array;
+    case "Uint16Array":
+      return Uint16Array;
+    case "Uint32Array":
+      return Uint32Array;
+    case "Uint8ClampedArray":
+      return Uint8ClampedArray;
+    case "Float32Array":
+      return Float32Array;
+    case "Float64Array":
+      return Float64Array;
+    case "BigInt64Array":
+      return BigInt64Array;
+    case "BigUint64Array":
+      return BigUint64Array;
     default:
-      return obj;
+      throw new Error(`Unknown TypedArray "${name}"`);
   }
 }
+
+// src/core/utils/deferred.ts
 function createDeferred() {
   let resolve;
   let reject;
   return {
-    resolve(v) {
-      resolve(v);
-    },
-    reject(v) {
-      reject(v);
-    },
     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);
+    }
   };
 }
-var VanillaDeserializerContext = class {
+
+// src/core/context/deserializer.ts
+function applyObjectFlag(obj, flag) {
+  switch (flag) {
+    case 3 /* Frozen */:
+      return Object.freeze(obj);
+    case 1 /* NonExtensible */:
+      return Object.preventExtensions(obj);
+    case 2 /* Sealed */:
+      return Object.seal(obj);
+    default:
+      return obj;
+  }
+}
+var BaseDeserializerContext = class {
   constructor(options) {
-    /**
-     * Mapping ids to values
-     * @private
-     */
-    this.values = /* @__PURE__ */ new Map();
     this.plugins = options.plugins;
-    this.refs = new Set(options.markedRefs);
-  }
-  assignIndexedValue(index, value) {
-    if (this.refs.has(index)) {
-      this.values.set(index, value);
-    }
-    return value;
+    this.refs = options.refs || /* @__PURE__ */ new Map();
   }
   deserializeReference(node) {
     return this.assignIndexedValue(node.i, getReference(deserializeString(node.s)));
@@ -1481,23 +1844,14 @@ var VanillaDeserializerContext = class {
   deserializeProperties(node, result) {
     const len = node.s;
     if (len) {
-      let key;
-      let value;
       const keys = node.k;
       const vals = node.v;
-      for (let i = 0; i < len; i++) {
+      for (let i = 0, key; i < len; i++) {
         key = keys[i];
-        value = this.deserialize(vals[i]);
-        switch (key) {
-          case 0 /* SymbolIterator */:
-            {
-              const current = value;
-              result[Symbol.iterator] = () => current.values();
-            }
-            break;
-          default:
-            result[deserializeString(key)] = value;
-            break;
+        if (typeof key === "string") {
+          result[deserializeString(key)] = this.deserialize(vals[i]);
+        } else {
+          result[this.deserialize(key)] = this.deserialize(vals[i]);
         }
       }
     }
@@ -1589,14 +1943,14 @@ var VanillaDeserializerContext = class {
   }
   async deserializePromise(node) {
     const deferred = createDeferred();
-    const result = this.assignIndexedValue(node.i, deferred.promise);
+    const result = this.assignIndexedValue(node.i, deferred);
     const deserialized = this.deserialize(node.f);
     if (node.s) {
       deferred.resolve(deserialized);
     } else {
       deferred.reject(deserialized);
     }
-    return result;
+    return result.promise;
   }
   deserializeURL(node) {
     return this.assignIndexedValue(node.i, new URL(deserializeString(node.s)));
@@ -1699,14 +2053,88 @@ var VanillaDeserializerContext = class {
       for (let i = 0, len = currentPlugins.length; i < len; i++) {
         const plugin = currentPlugins[i];
         if (plugin.tag === node.c) {
-          return plugin.deserialize(node.s, this, {
-            id: node.i
-          });
+          return this.assignIndexedValue(
+            node.i,
+            plugin.deserialize(node.s, this, {
+              id: node.i
+            })
+          );
         }
       }
     }
     throw new Error('Missing plugin for tag "' + node.c + '".');
   }
+  deserializePromiseConstructor(node) {
+    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.f)
+    );
+    return void 0;
+  }
+  deserializePromiseReject(node) {
+    const deferred = this.refs.get(node.i);
+    assert(deferred, new Error("Missing Promise instance."));
+    deferred.reject(
+      this.deserialize(node.f)
+    );
+    return void 0;
+  }
+  deserializeReadableStreamConstructor(node) {
+    return this.assignIndexedValue(
+      node.i,
+      createDeferredStream()
+    ).stream;
+  }
+  deserializeReadableStreamEnqueue(node) {
+    const deferred = this.refs.get(node.i);
+    assert(deferred, new Error("Missing ReadableStream instance."));
+    deferred.enqueue(
+      this.deserialize(node.f)
+    );
+    return void 0;
+  }
+  deserializeReadableStreamError(node) {
+    const deferred = this.refs.get(node.i);
+    assert(deferred, new Error("Missing Promise instance."));
+    deferred.error(
+      this.deserialize(node.f)
+    );
+    return void 0;
+  }
+  deserializeReadableStreamClose(node) {
+    const deferred = this.refs.get(node.i);
+    assert(deferred, new Error("Missing Promise instance."));
+    deferred.close();
+    return void 0;
+  }
+  deserializeIteratorFactoryInstance(node) {
+    const source = this.deserialize(node.a[1]);
+    return sequenceToIterator(source);
+  }
+  deserializeAsyncIteratorFactoryInstance(node) {
+    const source = this.deserialize(node.a[1]);
+    if (source.constructor === ReadableStream) {
+      return readableStreamToAsyncIterator(
+        source
+      );
+    }
+    return sequenceToAsyncIterator(source);
+  }
+  deserializeReadableStream(node) {
+    return this.assignIndexedValue(
+      node.i,
+      sequenceToReadableStream(
+        this.deserialize(node.a[1])
+      )
+    );
+  }
   deserialize(node) {
     switch (node.t) {
       case 2 /* Constant */:
@@ -1718,7 +2146,7 @@ var VanillaDeserializerContext = class {
       case 3 /* BigInt */:
         return BigInt(node.s);
       case 4 /* IndexedValue */:
-        return this.values.get(node.i);
+        return this.refs.get(node.i);
       case 20 /* Reference */:
         return this.deserializeReference(node);
       case 9 /* Array */:
@@ -1775,13 +2203,62 @@ var VanillaDeserializerContext = class {
         return this.deserializeDOMException(node);
       case 40 /* Plugin */:
         return this.deserializePlugin(node);
+      case 28 /* PromiseConstructor */:
+        return this.deserializePromiseConstructor(node);
+      case 29 /* PromiseResolve */:
+        return this.deserializePromiseResolve(node);
+      case 30 /* 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 */:
+        return this.deserializeIteratorFactoryInstance(node);
+      case 45 /* AsyncIteratorFactoryInstance */:
+        return this.deserializeAsyncIteratorFactoryInstance(node);
+      case 46 /* ReadableStream */:
+        return this.deserializeReadableStream(node);
+      case 41 /* MapSentinel */:
+      case 42 /* IteratorFactory */:
+      case 44 /* AsyncIteratorFactory */:
+      case 47 /* ReadableStreamFactory */:
       default:
         throw new Error("invariant");
     }
   }
 };
 
-// src/core/serializer-context.old.ts
+// src/core/tree/deserializer.ts
+var VanillaDeserializerContext = class extends BaseDeserializerContext {
+  constructor(options) {
+    super({
+      plugins: options.plugins,
+      refs: void 0
+    });
+    this.mode = "vanilla";
+    this.marked = new Set(options.markedRefs);
+  }
+  assignIndexedValue(index, value) {
+    if (this.marked.has(index)) {
+      this.refs.set(index, value);
+    }
+    return value;
+  }
+};
+
+// src/core/utils/is-valid-identifier.ts
+var IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;
+function isValidIdentifier(name) {
+  const char = name[0];
+  return (char === "$" || char === "_" || char >= "A" && char <= "Z" || char >= "a" && char <= "z") && IDENTIFIER_CHECK.test(name);
+}
+
+// src/core/context/serializer.ts
 function getAssignmentExpression(assignment) {
   switch (assignment.t) {
     case "index":
@@ -1854,10 +2331,6 @@ var SET_CONSTRUCTOR = "new Set";
 var MAP_CONSTRUCTOR = "new Map";
 var PROMISE_RESOLVE = "Promise.resolve";
 var PROMISE_REJECT = "Promise.reject";
-var SYMBOL_ITERATOR = "Symbol.iterator";
-var SPECIAL_REFERENCE_VALUE = {
-  [0 /* Sentinel */]: "[]"
-};
 var OBJECT_FLAG_CONSTRUCTOR = {
   [3 /* Frozen */]: "Object.freeze",
   [2 /* Sealed */]: "Object.seal",
@@ -1881,11 +2354,24 @@ var BaseSerializerContext = class {
      * @private
      */
     this.assignments = [];
-    this.specials = /* @__PURE__ */ new Set();
     this.plugins = options.plugins;
     this.features = options.features;
     this.marked = new Set(options.markedRefs);
   }
+  createFunction(parameters, body) {
+    if (this.features & 4 /* 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 */) {
+      const joined = parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")";
+      return joined + "=>{" + body + "}";
+    }
+    return "function(" + parameters.join(",") + "){" + body + "}";
+  }
   /**
    * A tiny function that tells if a reference
    * is to be accessed. This is a requirement for
@@ -1898,18 +2384,6 @@ var BaseSerializerContext = class {
   isMarked(id) {
     return this.marked.has(id);
   }
-  /**
-   * Generates special references that isn't provided by the user
-   * but by the script.
-   */
-  getSpecialReference(ref) {
-    const param = this.getRefParam("_" + ref);
-    if (this.specials.has(ref)) {
-      return param;
-    }
-    this.specials.add(ref);
-    return param + "=" + SPECIAL_REFERENCE_VALUE[ref];
-  }
   pushObjectFlag(flag, id) {
     if (flag !== 0 /* None */) {
       this.markRef(id);
@@ -1991,24 +2465,6 @@ var BaseSerializerContext = class {
   serializeReference(node) {
     return this.assignIndexedValue(node.i, REFERENCES_KEY + '.get("' + node.s + '")');
   }
-  getIterableAccess() {
-    return this.features & 2 /* ArrayPrototypeValues */ ? ".values()" : "[" + SYMBOL_ITERATOR + "]()";
-  }
-  serializeIterable(node) {
-    const key = "[" + SYMBOL_ITERATOR + "]";
-    const parent = this.stack;
-    this.stack = [];
-    let serialized = this.serialize(node) + this.getIterableAccess();
-    this.stack = parent;
-    if (this.features & 4 /* ArrowFunction */) {
-      serialized = ":()=>" + serialized;
-    } else if (this.features & 64 /* MethodShorthand */) {
-      serialized = "(){return " + serialized + "}";
-    } else {
-      serialized = ":function(){return " + serialized + "}";
-    }
-    return key + serialized;
-  }
   serializeArrayItem(id, item, index) {
     if (item) {
       if (this.isIndexedValueInStack(item)) {
@@ -2038,36 +2494,33 @@ var BaseSerializerContext = class {
     }
     return this.assignIndexedValue(id, "[]");
   }
-  serializeProperty(id, key, val) {
-    switch (key) {
-      case 0 /* SymbolIterator */:
-        return this.serializeIterable(val);
-      default: {
-        const check = Number(key);
-        const isIdentifier = check >= 0 || isValidIdentifier(key);
-        if (this.isIndexedValueInStack(val)) {
-          const refParam = this.getRefParam(val.i);
-          this.markRef(id);
-          if (isIdentifier && check !== check) {
-            this.createObjectAssign(id, key, refParam);
-          } else {
-            this.createArrayAssign(id, isIdentifier ? key : '"' + key + '"', refParam);
-          }
-          return "";
+  serializeProperty(source, key, val) {
+    if (typeof key === "string") {
+      const check = Number(key);
+      const isIdentifier = check >= 0 || isValidIdentifier(key);
+      if (this.isIndexedValueInStack(val)) {
+        const refParam = this.getRefParam(val.i);
+        this.markRef(source.i);
+        if (isIdentifier && check !== check) {
+          this.createObjectAssign(source.i, key, refParam);
+        } else {
+          this.createArrayAssign(source.i, isIdentifier ? key : '"' + key + '"', refParam);
         }
-        return (isIdentifier ? key : '"' + key + '"') + ":" + this.serialize(val);
+        return "";
       }
+      return (isIdentifier ? key : '"' + key + '"') + ":" + this.serialize(val);
     }
+    return "[" + this.serialize(key) + "]:" + this.serialize(val);
   }
-  serializeProperties(sourceID, node) {
-    const len = node.s;
+  serializeProperties(source, record) {
+    const len = record.s;
     if (len) {
-      this.stack.push(sourceID);
-      const keys = node.k;
-      const values = node.v;
-      let result = this.serializeProperty(sourceID, keys[0], values[0]);
+      this.stack.push(source.i);
+      const keys = record.k;
+      const values = record.v;
+      let result = this.serializeProperty(source, keys[0], values[0]);
       for (let i = 1, item = result; i < len; i++) {
-        item = this.serializeProperty(sourceID, keys[i], values[i]);
+        item = this.serializeProperty(source, keys[i], values[i]);
         result += (item && result && ",") + item;
       }
       this.stack.pop();
@@ -2077,88 +2530,83 @@ var BaseSerializerContext = class {
   }
   serializeObject(node) {
     this.pushObjectFlag(node.o, node.i);
-    return this.assignIndexedValue(node.i, this.serializeProperties(node.i, node.p));
+    return this.assignIndexedValue(node.i, this.serializeProperties(node, node.p));
   }
-  serializeWithObjectAssign(value, id, serialized) {
-    const fields = this.serializeProperties(id, value);
+  serializeWithObjectAssign(source, value, serialized) {
+    const fields = this.serializeProperties(source, value);
     if (fields !== "{}") {
       return "Object.assign(" + serialized + "," + fields + ")";
     }
     return serialized;
   }
-  serializeAssignment(sourceID, mainAssignments, key, value) {
-    switch (key) {
-      case 0 /* SymbolIterator */:
-        {
-          const parent = this.stack;
-          this.stack = [];
-          const serialized = this.serialize(value) + this.getIterableAccess();
-          this.stack = parent;
-          const parentAssignment = this.assignments;
-          this.assignments = mainAssignments;
-          this.createArrayAssign(
-            sourceID,
-            this.getSpecialReference(0 /* Sentinel */),
-            this.features & 4 /* ArrowFunction */ ? "()=>" + serialized : "function(){return " + serialized + "}"
-          );
-          this.assignments = parentAssignment;
+  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);
         }
-        break;
-      default: {
-        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(sourceID, key, serialized);
-          } else {
-            this.createArrayAssign(sourceID, isIdentifier ? key : '"' + key + '"', serialized);
-          }
+      } else {
+        const parentAssignment = this.assignments;
+        this.assignments = mainAssignments;
+        if (isIdentifier) {
+          this.createObjectAssign(source.i, key, serialized);
         } else {
-          const parentAssignment = this.assignments;
-          this.assignments = mainAssignments;
-          if (isIdentifier) {
-            this.createObjectAssign(sourceID, key, serialized);
-          } else {
-            this.createArrayAssign(sourceID, isIdentifier ? key : '"' + key + '"', serialized);
-          }
-          this.assignments = parentAssignment;
+          this.createArrayAssign(source.i, isIdentifier ? key : '"' + key + '"', serialized);
         }
+        this.assignments = parentAssignment;
       }
+    } else {
+      const parent = this.stack;
+      this.stack = [];
+      const serialized = this.serialize(value);
+      this.stack = parent;
+      const parentAssignment = this.assignments;
+      this.assignments = mainAssignments;
+      this.createArrayAssign(
+        source.i,
+        this.serialize(key),
+        serialized
+      );
+      this.assignments = parentAssignment;
     }
   }
-  serializeAssignments(sourceID, node) {
+  serializeAssignments(source, node) {
     const len = node.s;
     if (len) {
-      this.stack.push(sourceID);
+      this.stack.push(source.i);
       const mainAssignments = [];
       const keys = node.k;
       const values = node.v;
       for (let i = 0; i < len; i++) {
-        this.serializeAssignment(sourceID, mainAssignments, keys[i], values[i]);
+        this.serializeAssignment(source, mainAssignments, keys[i], values[i]);
       }
       this.stack.pop();
       return resolveAssignments(mainAssignments);
     }
     return void 0;
   }
-  serializeDictionary(i, p, init) {
-    if (p) {
+  serializeDictionary(node, init) {
+    if (node.p) {
       if (this.features & 128 /* ObjectAssign */) {
-        init = this.serializeWithObjectAssign(p, i, init);
+        init = this.serializeWithObjectAssign(node, node.p, init);
       } else {
-        this.markRef(i);
-        const assignments = this.serializeAssignments(i, p);
+        this.markRef(node.i);
+        const assignments = this.serializeAssignments(node, node.p);
         if (assignments) {
-          return "(" + this.assignIndexedValue(i, init) + "," + assignments + this.getRefParam(i) + ")";
+          return "(" + this.assignIndexedValue(node.i, init) + "," + assignments + this.getRefParam(node.i) + ")";
         }
       }
     }
-    return this.assignIndexedValue(i, init);
+    return this.assignIndexedValue(node.i, init);
   }
   serializeNullConstructor(node) {
     this.pushObjectFlag(node.o, node.i);
-    return this.serializeDictionary(node.i, node.p, NULL_CONSTRUCTOR);
+    return this.serializeDictionary(node, NULL_CONSTRUCTOR);
   }
   serializeDate(node) {
     return this.assignIndexedValue(node.i, 'new Date("' + node.s + '")');
@@ -2193,7 +2641,7 @@ var BaseSerializerContext = class {
     }
     return this.assignIndexedValue(id, serialized);
   }
-  serializeMapEntry(id, key, val) {
+  serializeMapEntry(id, key, val, sentinel) {
     if (this.isIndexedValueInStack(key)) {
       const keyRef = this.getRefParam(key.i);
       this.markRef(id);
@@ -2203,9 +2651,9 @@ var BaseSerializerContext = class {
         return "";
       }
       if (val.t !== 4 /* IndexedValue */ && val.i != null && this.isMarked(val.i)) {
-        const serialized = "(" + this.serialize(val) + ",[" + this.getSpecialReference(0 /* Sentinel */) + "," + this.getSpecialReference(0 /* Sentinel */) + "])";
+        const serialized = "(" + this.serialize(val) + ",[" + sentinel + "," + sentinel + "])";
         this.createSetAssignment(id, keyRef, this.getRefParam(val.i));
-        this.createDeleteAssignment(id, this.getSpecialReference(0 /* Sentinel */));
+        this.createDeleteAssignment(id, sentinel);
         return serialized;
       }
       const parent = this.stack;
@@ -2218,9 +2666,9 @@ var BaseSerializerContext = class {
       const valueRef = this.getRefParam(val.i);
       this.markRef(id);
       if (key.t !== 4 /* IndexedValue */ && key.i != null && this.isMarked(key.i)) {
-        const serialized = "(" + this.serialize(key) + ",[" + this.getSpecialReference(0 /* Sentinel */) + "," + this.getSpecialReference(0 /* Sentinel */) + "])";
+        const serialized = "(" + this.serialize(key) + ",[" + sentinel + "," + sentinel + "])";
         this.createSetAssignment(id, this.getRefParam(key.i), valueRef);
-        this.createDeleteAssignment(id, this.getSpecialReference(0 /* Sentinel */));
+        this.createDeleteAssignment(id, sentinel);
         return serialized;
       }
       const parent = this.stack;
@@ -2235,13 +2683,15 @@ var BaseSerializerContext = class {
     let serialized = MAP_CONSTRUCTOR;
     const size = node.e.s;
     const id = node.i;
+    const sentinel = node.f;
+    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]);
+      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]);
+        item = this.serializeMapEntry(id, keys[i], vals[i], sentinelID);
         result += (item && result && ",") + item;
       }
       this.stack.pop();
@@ -2249,6 +2699,10 @@ var BaseSerializerContext = class {
         serialized += "([" + result + "])";
       }
     }
+    if (sentinel.t === 41 /* MapSentinel */) {
+      this.markRef(sentinel.i);
+      serialized = "(" + this.serialize(sentinel) + "," + serialized + ")";
+    }
     return this.assignIndexedValue(id, serialized);
   }
   serializeArrayBuffer(node) {
@@ -2281,10 +2735,10 @@ var BaseSerializerContext = class {
     this.stack.push(id);
     const serialized = 'new AggregateError([],"' + node.m + '")';
     this.stack.pop();
-    return this.serializeDictionary(id, node.p, serialized);
+    return this.serializeDictionary(node, serialized);
   }
   serializeError(node) {
-    return this.serializeDictionary(node.i, node.p, "new " + ERROR_CONSTRUCTOR_STRING[node.s] + '("' + node.m + '")');
+    return this.serializeDictionary(node, "new " + ERROR_CONSTRUCTOR_STRING[node.s] + '("' + node.m + '")');
   }
   serializePromise(node) {
     let serialized;
@@ -2293,17 +2747,7 @@ var BaseSerializerContext = class {
     const constructor = node.s ? PROMISE_RESOLVE : PROMISE_REJECT;
     if (this.isIndexedValueInStack(fulfilled)) {
       const ref = this.getRefParam(fulfilled.i);
-      if (this.features & 4 /* ArrowFunction */) {
-        if (node.s) {
-          serialized = constructor + "().then(()=>" + ref + ")";
-        } else {
-          serialized = constructor + "().catch(()=>{throw " + ref + "})";
-        }
-      } else if (node.s) {
-        serialized = constructor + "().then(function(){return " + ref + "})";
-      } else {
-        serialized = constructor + "().catch(function(){throw " + ref + "})";
-      }
+      serialized = constructor + (node.s ? "().then(" + this.createFunction([], ref) + ")" : "().catch(" + this.createEffectfulFunction([], "throw " + ref) + ")");
     } else {
       this.stack.push(id);
       const result = this.serialize(fulfilled);
@@ -2339,7 +2783,7 @@ var BaseSerializerContext = class {
   serializeHeaders(node) {
     return this.assignIndexedValue(
       node.i,
-      "new Headers(" + this.serializeProperties(node.i, node.e) + ")"
+      "new Headers(" + this.serializeProperties(node, node.e) + ")"
     );
   }
   serializeFormDataEntry(id, key, value) {
@@ -2383,35 +2827,104 @@ var BaseSerializerContext = class {
   serializeEvent(node) {
     return this.assignIndexedValue(
       node.i,
-      'new Event("' + node.s + '",' + this.serialize(node.f) + ")"
+      '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 + '")'
+    );
+  }
+  serializePlugin(node) {
+    const currentPlugins = this.plugins;
+    if (currentPlugins) {
+      for (let i = 0, len = currentPlugins.length; i < len; i++) {
+        const plugin = currentPlugins[i];
+        if (plugin.tag === node.c) {
+          return this.assignIndexedValue(
+            node.i,
+            plugin.serialize(node.s, this, {
+              id: node.i
+            })
+          );
+        }
+      }
+    }
+    throw new Error('Missing plugin for tag "' + node.c + '".');
+  }
+  serializeMapSentinel(node) {
+    return this.assignIndexedValue(
+      node.i,
+      "[]"
+    );
+  }
+  serializeIteratorFactory(node) {
+    return 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}") + "})"
+        )
+      )
+    );
+  }
+  serializeIteratorFactoryInstance(node) {
+    return "(" + this.serialize(node.a[0]) + ")(" + this.serialize(node.a[1]) + ")";
+  }
+  serializeAsyncIteratorFactory(node) {
+    return this.assignIndexedValue(
+      node.i,
+      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}"
+            ) + ")"
+          ) + "})"
+        )
+      )
     );
   }
-  serializeCustomEvent(node) {
+  serializeAsyncIteratorFactoryInstance(node) {
+    return "(" + this.serialize(node.a[0]) + ")(" + this.serialize(node.a[1]) + ")";
+  }
+  serializeReadableStream(node) {
+    this.stack.push(node.i);
+    const result = "(" + this.serialize(node.a[0]) + ")(" + this.serialize(node.a[1]) + ")";
+    this.stack.pop();
     return this.assignIndexedValue(
       node.i,
-      'new CustomEvent("' + node.s + '",' + this.serialize(node.f) + ")"
+      result
     );
   }
-  serializeDOMException(node) {
+  serializeReadableStreamFactory(node) {
     return this.assignIndexedValue(
       node.i,
-      'new DOMException("' + node.s + '","' + node.c + '")'
+      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])"
+          ) + ")"
+        ) + "})"
+      )
     );
   }
-  serializePlugin(node) {
-    const currentPlugins = this.plugins;
-    if (currentPlugins) {
-      for (let i = 0, len = currentPlugins.length; i < len; i++) {
-        const plugin = currentPlugins[i];
-        if (plugin.tag === node.c) {
-          return plugin.serialize(node.s, this, {
-            id: node.i
-          });
-        }
-      }
-    }
-    throw new Error('Missing plugin for tag "' + node.c + '".');
-  }
   serialize(node) {
     switch (node.t) {
       case 2 /* Constant */:
@@ -2495,13 +3008,27 @@ var BaseSerializerContext = class {
         return this.serializeDOMException(node);
       case 40 /* Plugin */:
         return this.serializePlugin(node);
+      case 41 /* MapSentinel */:
+        return this.serializeMapSentinel(node);
+      case 42 /* IteratorFactory */:
+        return this.serializeIteratorFactory(node);
+      case 43 /* IteratorFactoryInstance */:
+        return this.serializeIteratorFactoryInstance(node);
+      case 44 /* AsyncIteratorFactory */:
+        return this.serializeAsyncIteratorFactory(node);
+      case 45 /* AsyncIteratorFactoryInstance */:
+        return this.serializeAsyncIteratorFactoryInstance(node);
+      case 46 /* ReadableStream */:
+        return this.serializeReadableStream(node);
+      case 47 /* ReadableStreamFactory */:
+        return this.serializeReadableStreamFactory(node);
       default:
         throw new Error("invariant");
     }
   }
 };
 
-// src/core/get-identifier.ts
+// src/core/utils/get-identifier.ts
 var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
 var REF_START_CHARS_LEN = REF_START_CHARS.length;
 var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
@@ -2518,7 +3045,7 @@ function getIdentifier(index) {
   return ref;
 }
 
-// src/core/tree/serialize.ts
+// src/core/tree/serializer.ts
 var VanillaSerializerContext = class extends BaseSerializerContext {
   constructor() {
     super(...arguments);
@@ -2596,12 +3123,7 @@ var VanillaSerializerContext = class extends BaseSerializerContext {
           body = index + "=" + body;
         }
       }
-      let params = this.vars.length > 1 ? this.vars.join(",") : this.vars[0];
-      if (this.features & 4 /* ArrowFunction */) {
-        params = this.vars.length > 1 || this.vars.length === 0 ? "(" + params + ")" : params;
-        return "(" + params + "=>(" + body + "))()";
-      }
-      return "(function(" + params + "){return " + body + "})()";
+      return "(" + this.createFunction(this.vars, "(" + body + ")") + ")()";
     }
     if (tree.t === 10 /* Object */) {
       return "(" + result + ")";
@@ -2610,70 +3132,56 @@ var VanillaSerializerContext = class extends BaseSerializerContext {
   }
 };
 
-// src/core/base/sync.ts
+// src/core/context/parser/sync.ts
 var BaseSyncParserContext = class extends BaseParserContext {
   parseItems(current) {
-    const size = current.length;
     const nodes = [];
-    const deferred = [];
-    for (let i = 0, item; i < size; i++) {
+    for (let i = 0, len = current.length; i < len; i++) {
       if (i in current) {
-        item = current[i];
-        if (this.isIterable(item)) {
-          deferred[i] = item;
-        } else {
-          nodes[i] = this.parse(item);
-        }
-      }
-    }
-    for (let i = 0; i < size; i++) {
-      if (i in deferred) {
-        nodes[i] = this.parse(deferred[i]);
+        nodes[i] = this.parse(current[i]);
       }
     }
     return nodes;
   }
   parseArray(id, current) {
-    return {
-      t: 9 /* Array */,
-      i: id,
-      s: void 0,
-      l: current.length,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: this.parseItems(current),
-      f: void 0,
-      b: void 0,
-      o: getObjectFlag(current)
-    };
+    return createArrayNode(
+      id,
+      current,
+      this.parseItems(current)
+    );
   }
   parseProperties(properties) {
     const entries = Object.entries(properties);
     const keyNodes = [];
     const valueNodes = [];
-    const deferredKeys = [];
-    const deferredValues = [];
-    for (let i = 0, len = entries.length, key, item; i < len; i++) {
-      key = serializeString(entries[i][0]);
-      item = entries[i][1];
-      if (this.isIterable(item)) {
-        deferredKeys.push(key);
-        deferredValues.push(item);
-      } else {
-        keyNodes.push(key);
-        valueNodes.push(this.parse(item));
-      }
-    }
-    for (let i = 0, len = deferredKeys.length; i < len; i++) {
-      keyNodes.push(deferredKeys[i]);
-      valueNodes.push(this.parse(deferredValues[i]));
+    for (let i = 0, len = entries.length; i < len; i++) {
+      keyNodes.push(serializeString(entries[i][0]));
+      valueNodes.push(this.parse(entries[i][1]));
     }
     if (this.features & 1024 /* Symbol */) {
-      if (Symbol.iterator in properties) {
-        keyNodes.push(0 /* SymbolIterator */);
-        valueNodes.push(this.parse(Array.from(properties)));
+      let symbol = Symbol.iterator;
+      if (symbol in properties) {
+        keyNodes.push(
+          this.parseWKSymbol(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);
       }
     }
     return {
@@ -2683,184 +3191,69 @@ var BaseSyncParserContext = class extends BaseParserContext {
     };
   }
   parsePlainObject(id, current, empty) {
-    return {
-      t: empty ? 11 /* NullConstructor */ : 10 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: this.parseProperties(current),
-      e: void 0,
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: getObjectFlag(current)
-    };
+    return this.createObjectNode(
+      id,
+      current,
+      empty,
+      this.parseProperties(current)
+    );
   }
   parseBoxed(id, current) {
-    return {
-      t: 27 /* Boxed */,
-      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.parse(current.valueOf()),
-      b: void 0,
-      o: void 0
-    };
+    return createBoxedNode(id, this.parse(current.valueOf()));
   }
   parseTypedArray(id, current) {
-    return {
-      t: 15 /* TypedArray */,
-      i: id,
-      s: void 0,
-      l: current.length,
-      c: current.constructor.name,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: this.parse(current.buffer),
-      b: current.byteOffset,
-      o: void 0
-    };
+    return createTypedArrayNode(id, current, this.parse(current.buffer));
   }
   parseBigIntTypedArray(id, current) {
-    return {
-      t: 16 /* BigIntTypedArray */,
-      i: id,
-      s: void 0,
-      l: current.length,
-      c: current.constructor.name,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: this.parse(current.buffer),
-      b: current.byteOffset,
-      o: void 0
-    };
+    return createBigIntTypedArrayNode(id, current, this.parse(current.buffer));
   }
   parseDataView(id, current) {
-    return {
-      t: 22 /* DataView */,
-      i: id,
-      s: void 0,
-      l: current.byteLength,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: this.parse(current.buffer),
-      b: current.byteOffset,
-      o: void 0
-    };
+    return createDataViewNode(id, current, this.parse(current.buffer));
   }
   parseError(id, current) {
     const options = getErrorOptions(current, this.features);
-    const optionsNode = options ? this.parseProperties(options) : void 0;
-    return {
-      t: 13 /* Error */,
-      i: id,
-      s: getErrorConstructor(current),
-      l: void 0,
-      c: void 0,
-      m: serializeString(current.message),
-      p: optionsNode,
-      e: void 0,
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
+    return createErrorNode(
+      id,
+      current,
+      options ? this.parseProperties(options) : void 0
+    );
+  }
+  parseAggregateError(id, current) {
+    const options = getErrorOptions(current, this.features);
+    return createAggregateErrorNode(
+      id,
+      current,
+      options ? this.parseProperties(options) : void 0
+    );
   }
   parseMap(id, current) {
     const keyNodes = [];
     const valueNodes = [];
-    const deferredKey = [];
-    const deferredValue = [];
     for (const [key, value] of current.entries()) {
-      if (this.isIterable(key) || this.isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
-      } else {
-        keyNodes.push(this.parse(key));
-        valueNodes.push(this.parse(value));
-      }
-    }
-    for (let i = 0, len = deferredKey.length; i < len; i++) {
-      keyNodes.push(this.parse(deferredKey[i]));
-      valueNodes.push(this.parse(deferredValue[i]));
-    }
-    return {
-      t: 8 /* Map */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: { k: keyNodes, v: valueNodes, s: current.size },
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
+      keyNodes.push(this.parse(key));
+      valueNodes.push(this.parse(value));
+    }
+    return this.createMapNode(
+      id,
+      keyNodes,
+      valueNodes,
+      current.size
+    );
   }
   parseSet(id, current) {
-    const nodes = [];
-    const deferred = [];
+    const items = [];
     for (const item of current.keys()) {
-      if (this.isIterable(item)) {
-        deferred.push(item);
-      } else {
-        nodes.push(this.parse(item));
-      }
+      items.push(this.parse(item));
     }
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(this.parse(deferred[i]));
-    }
-    return {
-      t: 7 /* Set */,
-      i: id,
-      s: void 0,
-      l: current.size,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: nodes,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
+    return createSetNode(id, current.size, items);
   }
   parsePlainProperties(entries) {
     const size = entries.length;
     const keyNodes = [];
     const valueNodes = [];
-    const deferredKeys = [];
-    const deferredValues = [];
-    for (let i = 0, key, item; i < size; i++) {
-      key = serializeString(entries[i][0]);
-      item = entries[i][1];
-      if (this.isIterable(item)) {
-        deferredKeys.push(key);
-        deferredValues.push(item);
-      } else {
-        keyNodes.push(key);
-        valueNodes.push(this.parse(item));
-      }
-    }
-    for (let i = 0, len = deferredKeys.length; i < len; i++) {
-      keyNodes.push(deferredKeys[i]);
-      valueNodes.push(this.parse(deferredValues[i]));
+    for (let i = 0; i < size; i++) {
+      keyNodes.push(serializeString(entries[i][0]));
+      valueNodes.push(this.parse(entries[i][1]));
     }
     return {
       k: keyNodes,
@@ -2909,54 +3302,10 @@ var BaseSyncParserContext = class extends BaseParserContext {
     };
   }
   parseEvent(id, current) {
-    return {
-      t: 37 /* Event */,
-      i: id,
-      s: serializeString(current.type),
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: this.parse(createEventOptions(current)),
-      b: void 0,
-      o: void 0
-    };
+    return createEventNode(id, current.type, this.parse(createEventOptions(current)));
   }
   parseCustomEvent(id, current) {
-    return {
-      t: 38 /* CustomEvent */,
-      i: id,
-      s: serializeString(current.type),
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: this.parse(createCustomEventOptions(current)),
-      b: void 0,
-      o: void 0
-    };
-  }
-  parseAggregateError(id, current) {
-    const options = getErrorOptions(current, this.features);
-    const optionsNode = options ? this.parseProperties(options) : void 0;
-    return {
-      t: 14 /* AggregateError */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: serializeString(current.message),
-      p: optionsNode,
-      e: void 0,
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
+    return createCustomEventNode(id, current.type, this.parse(createCustomEventOptions(current)));
   }
   parsePlugin(id, current) {
     const currentPlugins = this.plugins;
@@ -3214,7 +3563,21 @@ var CrossAsyncParserContext = class extends BaseAsyncParserContext {
   }
 };
 
-// src/core/cross/serialize.ts
+// src/core/cross/deserializer.ts
+var CrossDeserializerContext = class extends BaseDeserializerContext {
+  constructor() {
+    super(...arguments);
+    this.mode = "cross";
+  }
+  assignIndexedValue(index, value) {
+    if (!this.refs.has(index)) {
+      this.refs.set(index, value);
+    }
+    return value;
+  }
+};
+
+// src/core/cross/serializer.ts
 var CrossSerializerContext = class extends BaseSerializerContext {
   constructor(options) {
     super(options);
@@ -3243,13 +3606,31 @@ var CrossSerializerContext = class extends BaseSerializerContext {
     return this.assignIndexedValue(node.i, GLOBAL_CONTEXT_API + "." + GLOBAL_CONTEXT_STREAM_CONSTRUCTOR + "()");
   }
   serializeReadableStreamEnqueue(node) {
-    return GLOBAL_CONTEXT_API + "." + GLOBAL_CONTEXT_STREAM_EMIT + "(" + this.getRefParam(node.i) + ",0," + this.serialize(node.f) + ")";
+    return GLOBAL_CONTEXT_API + "." + GLOBAL_CONTEXT_STREAM_ENQUEUE + "(" + this.getRefParam(node.i) + "," + this.serialize(node.f) + ")";
   }
   serializeReadableStreamError(node) {
-    return GLOBAL_CONTEXT_API + "." + GLOBAL_CONTEXT_STREAM_EMIT + "(" + this.getRefParam(node.i) + ",1," + this.serialize(node.f) + ")";
+    return GLOBAL_CONTEXT_API + "." + GLOBAL_CONTEXT_STREAM_ERROR + "(" + this.getRefParam(node.i) + "," + this.serialize(node.f) + ")";
   }
   serializeReadableStreamClose(node) {
-    return GLOBAL_CONTEXT_API + "." + GLOBAL_CONTEXT_STREAM_EMIT + "(" + this.getRefParam(node.i) + ",2)";
+    return GLOBAL_CONTEXT_API + "." + GLOBAL_CONTEXT_STREAM_CLOSE + "(" + this.getRefParam(node.i) + ")";
+  }
+  serializeAsyncIteratorFactory(node) {
+    return this.assignIndexedValue(
+      node.i,
+      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]}"
+            ) + ")"
+          ) + "})"
+        )
+      )
+    );
   }
   serializeTop(tree) {
     const result = this.serialize(tree);
@@ -3266,14 +3647,11 @@ var CrossSerializerContext = class extends BaseSerializerContext {
     }
     const args = this.scopeId == null ? "()" : "(" + GLOBAL_CONTEXT_REFERENCES + '["' + serializeString(this.scopeId) + '"])';
     const body = mainBody + (patches ? ref : "");
-    if (this.features & 4 /* ArrowFunction */) {
-      return "(" + params + "=>(" + body + "))" + args;
-    }
-    return "(function(" + params + "){return " + body + "})" + args;
+    return "(" + this.createFunction([params], body) + ")" + args;
   }
 };
 
-// src/core/base/stream.ts
+// src/core/context/parser/stream.ts
 var BaseStreamParserContext = class extends BaseSyncParserContext {
   constructor(options) {
     super(options);
@@ -3314,6 +3692,63 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
       this.onDone();
     }
   }
+  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(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)
+            )
+          )
+        );
+      }
+      symbol = Symbol.asyncIterator;
+      if (symbol in properties) {
+        keyNodes.push(
+          this.parseWKSymbol(symbol)
+        );
+        valueNodes.push(
+          createAsyncIteratorFactoryInstanceNode(
+            this.parseAsyncIteratorFactory(),
+            this.parse(
+              asyncIteratorToReadableStream(
+                properties,
+                this
+              )
+            )
+          )
+        );
+      }
+      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
+    };
+  }
   pushReadableStreamReader(id, reader) {
     reader.read().then(
       (data) => {
@@ -3634,7 +4069,7 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
     if (current instanceof Error) {
       return this.parseError(id, current);
     }
-    if (currentFeatures & 1024 /* Symbol */ && Symbol.iterator in current) {
+    if (currentFeatures & 1024 /* Symbol */ && (Symbol.iterator in current || Symbol.asyncIterator in current)) {
       return this.parsePlainObject(id, current, !!currentClass);
     }
     throw new UnsupportedTypeError(current);
@@ -3720,8 +4155,25 @@ async function crossSerializeAsync(source, options = {}) {
   });
   return serial.serializeTop(tree);
 }
+function toCrossJSON(source, options = {}) {
+  const ctx = new CrossSyncParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs
+  });
+  return ctx.parse(source);
+}
+async function toCrossJSONAsync(source, options = {}) {
+  const ctx = new CrossAsyncParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs
+  });
+  return ctx.parse(source);
+}
 function crossSerializeStream(source, options) {
   const ctx = new CrossStreamParserContext({
+    plugins: options.plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
     onParse(node, initial) {
@@ -3753,6 +4205,27 @@ function crossSerializeStream(source, options) {
     ctx.destroy();
   };
 }
+function toCrossJSONStream(source, options) {
+  const ctx = new CrossStreamParserContext({
+    plugins: options.plugins,
+    refs: options.refs,
+    disabledFeatures: options.disabledFeatures,
+    onParse: options.onParse,
+    onError: options.onError,
+    onDone: options.onDone
+  });
+  ctx.start(source);
+  return () => {
+    ctx.destroy();
+  };
+}
+function fromCrossJSON(source, options) {
+  const ctx = new CrossDeserializerContext({
+    plugins: options.plugins,
+    refs: options.refs
+  });
+  return ctx.deserialize(source);
+}
 
 // src/core/Serializer.ts
 var Serializer = class {