seroval 1.2.1 → 1.3.0

package/dist/cjs/development/index.cjs

@@ -63,10 +63,9 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
   Feature2[Feature2["ErrorPrototypeStack"] = 4] = "ErrorPrototypeStack";
   Feature2[Feature2["ObjectAssign"] = 8] = "ObjectAssign";
   Feature2[Feature2["BigIntTypedArray"] = 16] = "BigIntTypedArray";
-  Feature2[Feature2["AbortSignal"] = 32] = "AbortSignal";
   return Feature2;
 })(Feature || {});
-var ALL_ENABLED = 47;
+var ALL_ENABLED = 1 /* AggregateError */ | 2 /* ArrowFunction */ | 4 /* ErrorPrototypeStack */ | 8 /* ObjectAssign */ | 16 /* BigIntTypedArray */;
 
 // src/core/string.ts
 function serializeChar(str) {
@@ -242,19 +241,6 @@ function resolvePlugins(plugins) {
   return void 0;
 }
 
-// src/core/abort-signal.ts
-function resolveAbortSignalResult(resolve) {
-  resolve(this.reason);
-}
-function resolveAbortSignal(resolve) {
-  this.addEventListener("abort", resolveAbortSignalResult.bind(this, resolve), {
-    once: true
-  });
-}
-function abortSignalToPromise(signal) {
-  return new Promise(resolveAbortSignal.bind(signal));
-}
-
 // src/core/constants.ts
 var SYMBOL_STRING = {
   [0 /* AsyncIterator */]: "Symbol.asyncIterator",
@@ -543,10 +529,11 @@ function createIndexedValueNode(id) {
   );
 }
 function createDateNode(id, current) {
+  const timestamp = current.valueOf();
   return createSerovalNode(
     5 /* Date */,
     id,
-    current.toISOString(),
+    timestamp !== timestamp ? "" : current.toISOString(),
     NIL,
     NIL,
     NIL,
@@ -962,18 +949,96 @@ var OpaqueReference = class {
   }
 };
 
+// src/core/function-string.ts
+function createFunction(features, parameters, body) {
+  if (features & 2 /* ArrowFunction */) {
+    const joined = parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")";
+    return joined + "=>" + (body.startsWith("{") ? "(" + body + ")" : body);
+  }
+  return "function(" + parameters.join(",") + "){return " + body + "}";
+}
+function createEffectfulFunction(features, parameters, body) {
+  if (features & 2 /* ArrowFunction */) {
+    const joined = parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")";
+    return joined + "=>{" + body + "}";
+  }
+  return "function(" + parameters.join(",") + "){" + body + "}";
+}
+
 // src/core/special-reference.ts
 var ITERATOR = {};
 var ASYNC_ITERATOR = {};
 var SPECIAL_REFS = {
   [0 /* MapSentinel */]: {},
   [1 /* PromiseConstructor */]: {},
-  [2 /* PromiseResolve */]: {},
-  [3 /* PromiseReject */]: {},
-  [4 /* StreamConstructor */]: {},
-  [5 /* AbortSignalConstructor */]: {},
-  [6 /* AbortSignalAbort */]: {}
+  [2 /* PromiseSuccess */]: {},
+  [3 /* PromiseFailure */]: {},
+  [4 /* StreamConstructor */]: {}
 };
+function serializePromiseConstructor(features) {
+  return createFunction(
+    features,
+    ["r"],
+    "(r.p=new Promise(" + createEffectfulFunction(features, ["s", "f"], "r.s=s,r.f=f") + "))"
+  );
+}
+function serializePromiseSuccess(features) {
+  return createEffectfulFunction(
+    features,
+    ["r", "d"],
+    "r.s(d),r.p.s=1,r.p.v=d"
+  );
+}
+function serializePromiseFailure(features) {
+  return createEffectfulFunction(
+    features,
+    ["r", "d"],
+    "r.f(d),r.p.s=2,r.p.v=d"
+  );
+}
+function serializeStreamConstructor(features) {
+  return createFunction(
+    features,
+    ["b", "a", "s", "l", "p", "f", "e", "n"],
+    "(b=[],a=!0,s=!1,l=[],p=0,f=" + createEffectfulFunction(
+      features,
+      ["v", "m", "x"],
+      "for(x=0;x<p;x++)l[x]&&l[x][m](v)"
+    ) + ",n=" + createEffectfulFunction(
+      features,
+      ["o", "x", "z", "c"],
+      'for(x=0,z=b.length;x<z;x++)(c=b[x],(!a&&x===z-1)?o[s?"return":"throw"](c):o.next(c))'
+    ) + ",e=" + createFunction(
+      features,
+      ["o", "t"],
+      "(a&&(l[t=p++]=o),n(o)," + createEffectfulFunction(features, [], "a&&(l[t]=void 0)") + ")"
+    ) + ",{__SEROVAL_STREAM__:!0,on:" + createFunction(features, ["o"], "e(o)") + ",next:" + createEffectfulFunction(features, ["v"], 'a&&(b.push(v),f(v,"next"))') + ",throw:" + createEffectfulFunction(
+      features,
+      ["v"],
+      'a&&(b.push(v),f(v,"throw"),a=s=!1,l.length=0)'
+    ) + ",return:" + createEffectfulFunction(
+      features,
+      ["v"],
+      'a&&(b.push(v),f(v,"return"),a=!1,s=!0,l.length=0)'
+    ) + "})"
+  );
+}
+function serializeSpecialReferenceValue(features, ref) {
+  switch (ref) {
+    case 0 /* MapSentinel */:
+      return "[]";
+    case 1 /* PromiseConstructor */:
+      return serializePromiseConstructor(features);
+    case 2 /* PromiseSuccess */:
+      return serializePromiseSuccess(features);
+    case 3 /* PromiseFailure */:
+      return serializePromiseFailure(features);
+    case 4 /* StreamConstructor */:
+      return serializeStreamConstructor(features);
+    default:
+      return "";
+  }
+}
 
 // src/core/utils/deferred.ts
 function createDeferred() {
@@ -1237,6 +1302,11 @@ var BaseParserContext = class {
   isMarked(id) {
     return this.marked.has(id);
   }
+  createIndex(current) {
+    const id = this.refs.size;
+    this.refs.set(current, id);
+    return id;
+  }
   getIndexedValue(current) {
     const registeredId = this.refs.get(current);
     if (registeredId != null) {
@@ -1246,11 +1316,9 @@ var BaseParserContext = class {
         value: createIndexedValueNode(registeredId)
       };
     }
-    const id = this.refs.size;
-    this.refs.set(current, id);
     return {
       type: 0 /* Fresh */,
-      value: id
+      value: this.createIndex(current)
     };
   }
   getReference(current) {
@@ -1369,11 +1437,11 @@ var BaseParserContext = class {
       NIL
     );
   }
-  createPromiseConstructorNode(id) {
+  createPromiseConstructorNode(id, resolver) {
     return createSerovalNode(
       22 /* PromiseConstructor */,
       id,
-      NIL,
+      resolver,
       NIL,
       NIL,
       NIL,
@@ -1385,22 +1453,6 @@ var BaseParserContext = class {
       NIL
     );
   }
-  createAbortSignalConstructorNode(id) {
-    return createSerovalNode(
-      35 /* AbortSignalConstructor */,
-      id,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      this.parseSpecialReference(5 /* AbortSignalConstructor */),
-      NIL,
-      NIL
-    );
-  }
 };
 
 // src/core/context/parser/async.ts
@@ -1409,7 +1461,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     const nodes = [];
     for (let i = 0, len = current.length; i < len; i++) {
       if (i in current) {
-        nodes[i] = await this.parse(current[i]);
+        nodes[i] = await this.parseTop(current[i]);
       }
     }
     return nodes;
@@ -1423,7 +1475,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     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]));
+      valueNodes.push(await this.parseTop(entries[i][1]));
     }
     let symbol = Symbol.iterator;
     if (symbol in properties) {
@@ -1431,7 +1483,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
       valueNodes.push(
         createIteratorFactoryInstanceNode(
           this.parseIteratorFactory(),
-          await this.parse(
+          await this.parseTop(
             iteratorToSequence(properties)
           )
         )
@@ -1443,7 +1495,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
       valueNodes.push(
         createAsyncIteratorFactoryInstanceNode(
           this.parseAsyncIteratorFactory(),
-          await this.parse(
+          await this.parseTop(
             createStreamFromAsyncIterable(
               properties
             )
@@ -1476,20 +1528,24 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     );
   }
   async parseBoxed(id, current) {
-    return createBoxedNode(id, await this.parse(current.valueOf()));
+    return createBoxedNode(id, await this.parseTop(current.valueOf()));
   }
   async parseTypedArray(id, current) {
-    return createTypedArrayNode(id, current, await this.parse(current.buffer));
+    return createTypedArrayNode(
+      id,
+      current,
+      await this.parseTop(current.buffer)
+    );
   }
   async parseBigIntTypedArray(id, current) {
     return createBigIntTypedArrayNode(
       id,
       current,
-      await this.parse(current.buffer)
+      await this.parseTop(current.buffer)
     );
   }
   async parseDataView(id, current) {
-    return createDataViewNode(id, current, await this.parse(current.buffer));
+    return createDataViewNode(id, current, await this.parseTop(current.buffer));
   }
   async parseError(id, current) {
     const options = getErrorOptions(current, this.features);
@@ -1511,15 +1567,15 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     const keyNodes = [];
     const valueNodes = [];
     for (const [key, value] of current.entries()) {
-      keyNodes.push(await this.parse(key));
-      valueNodes.push(await this.parse(value));
+      keyNodes.push(await this.parseTop(key));
+      valueNodes.push(await this.parseTop(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));
+      items.push(await this.parseTop(item));
     }
     return createSetNode(id, current.size, items);
   }
@@ -1535,7 +1591,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
       NIL,
       NIL,
       NIL,
-      await this.parse(result),
+      await this.parseTop(result),
       NIL,
       NIL
     );
@@ -1567,7 +1623,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
         const cleanup = current.on({
           next: (value) => {
             this.markRef(id);
-            this.parse(value).then(
+            this.parseTop(value).then(
               (data) => {
                 sequence.push(createStreamNextNode(id, data));
               },
@@ -1579,7 +1635,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
           },
           throw: (value) => {
             this.markRef(id);
-            this.parse(value).then(
+            this.parseTop(value).then(
               (data) => {
                 sequence.push(createStreamThrowNode(id, data));
                 resolve(sequence);
@@ -1593,7 +1649,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
           },
           return: (value) => {
             this.markRef(id);
-            this.parse(value).then(
+            this.parseTop(value).then(
               (data) => {
                 sequence.push(createStreamReturnNode(id, data));
                 resolve(sequence);
@@ -1609,28 +1665,6 @@ var BaseAsyncParserContext = class extends BaseParserContext {
       })
     );
   }
-  async parseAbortSignalSync(id, current) {
-    return createSerovalNode(
-      37 /* AbortSignalSync */,
-      id,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      await this.parse(current.reason),
-      NIL,
-      NIL
-    );
-  }
-  async parseAbortSignal(id, current) {
-    if (!current.aborted) {
-      await abortSignalToPromise(current);
-    }
-    return this.parseAbortSignalSync(id, current);
-  }
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ehh
   async parseObject(id, current) {
     if (Array.isArray(current)) {
@@ -1641,7 +1675,7 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     }
     const currentClass = current.constructor;
     if (currentClass === OpaqueReference) {
-      return this.parse(
+      return this.parseTop(
         current.replacement
       );
     }
@@ -1704,9 +1738,6 @@ var BaseAsyncParserContext = class extends BaseParserContext {
       return this.parsePromise(id, current);
     }
     const currentFeatures = this.features;
-    if (currentFeatures & 32 /* AbortSignal */ && typeof AbortSignal !== "undefined" && currentClass === AbortSignal) {
-      return this.parseAbortSignal(id, current);
-    }
     if (currentFeatures & 16 /* BigIntTypedArray */) {
       switch (currentClass) {
         case BigInt64Array:
@@ -1741,35 +1772,38 @@ var BaseAsyncParserContext = class extends BaseParserContext {
     }
     throw new SerovalUnsupportedTypeError(current);
   }
-  async parse(current) {
-    try {
-      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":
-          return createBigIntNode(current);
-        case "object": {
-          if (current) {
-            const ref = this.getReference(current);
-            return ref.type === 0 ? await this.parseObject(ref.value, current) : ref.value;
-          }
-          return NULL_NODE;
+  async parseTop(current) {
+    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":
+        return createBigIntNode(current);
+      case "object": {
+        if (current) {
+          const ref = this.getReference(current);
+          return ref.type === 0 ? await this.parseObject(ref.value, current) : ref.value;
         }
-        case "symbol":
-          return this.parseWellKnownSymbol(current);
-        case "function":
-          return this.parseFunction(current);
-        default:
-          throw new SerovalUnsupportedTypeError(current);
+        return NULL_NODE;
       }
+      case "symbol":
+        return this.parseWellKnownSymbol(current);
+      case "function":
+        return this.parseFunction(current);
+      default:
+        throw new SerovalUnsupportedTypeError(current);
+    }
+  }
+  async parse(current) {
+    try {
+      return await this.parseTop(current);
     } catch (error) {
-      throw new SerovalParserError(error);
+      throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
     }
   }
 };
@@ -2040,21 +2074,6 @@ var BaseDeserializerContext = class {
     this.deserialize(node.a[1]);
     return void 0;
   }
-  deserializeAbortSignalConstructor(node) {
-    return this.assignIndexedValue(node.i, new AbortController()).signal;
-  }
-  deserializeAbortSignalAbort(node) {
-    const controller = this.refs.get(node.i);
-    assert(controller, new SerovalMissingInstanceError("AbortSignal"));
-    controller.abort(this.deserialize(node.a[1]));
-    return void 0;
-  }
-  deserializeAbortSignalSync(node) {
-    return this.assignIndexedValue(
-      node.i,
-      AbortSignal.abort(this.deserialize(node.f))
-    );
-  }
   deserialize(node) {
     try {
       switch (node.t) {
@@ -2104,9 +2123,9 @@ var BaseDeserializerContext = class {
           return this.deserializePlugin(node);
         case 22 /* PromiseConstructor */:
           return this.deserializePromiseConstructor(node);
-        case 23 /* PromiseResolve */:
+        case 23 /* PromiseSuccess */:
           return this.deserializePromiseResolve(node);
-        case 24 /* PromiseReject */:
+        case 24 /* PromiseFailure */:
           return this.deserializePromiseReject(node);
         case 28 /* IteratorFactoryInstance */:
           return this.deserializeIteratorFactoryInstance(node);
@@ -2124,12 +2143,6 @@ var BaseDeserializerContext = class {
           return this.deserializeIteratorFactory(node);
         case 29 /* AsyncIteratorFactory */:
           return this.deserializeAsyncIteratorFactory(node);
-        case 36 /* AbortSignalAbort */:
-          return this.deserializeAbortSignalAbort(node);
-        case 35 /* AbortSignalConstructor */:
-          return this.deserializeAbortSignalConstructor(node);
-        case 37 /* AbortSignalSync */:
-          return this.deserializeAbortSignalSync(node);
         // case SerovalNodeType.SpecialReference:
         default:
           throw new SerovalUnsupportedNodeError(node);
@@ -2260,18 +2273,10 @@ var BaseSerializerContext = class {
     this.marked = new Set(options.markedRefs);
   }
   createFunction(parameters, body) {
-    if (this.features & 2 /* ArrowFunction */) {
-      const joined = parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")";
-      return joined + "=>" + (body.startsWith("{") ? "(" + body + ")" : body);
-    }
-    return "function(" + parameters.join(",") + "){return " + body + "}";
+    return createFunction(this.features, parameters, body);
   }
   createEffectfulFunction(parameters, body) {
-    if (this.features & 2 /* ArrowFunction */) {
-      const joined = parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")";
-      return joined + "=>{" + body + "}";
-    }
-    return "function(" + parameters.join(",") + "){" + body + "}";
+    return createEffectfulFunction(this.features, parameters, body);
   }
   /**
    * A tiny function that tells if a reference
@@ -2740,7 +2745,11 @@ var BaseSerializerContext = class {
     return current === this.getRefParam(node.i) ? current : "(" + current + ")";
   }
   serializePromiseConstructor(node) {
-    return this.assignIndexedValue(node.i, this.getConstructor(node.f) + "()");
+    const resolver = this.assignIndexedValue(node.s, "{p:0,s:0,f:0}");
+    return this.assignIndexedValue(
+      node.i,
+      this.getConstructor(node.f) + "(" + resolver + ")"
+    );
   }
   serializePromiseResolve(node) {
     return this.getConstructor(node.a[0]) + "(" + this.getRefParam(node.i) + "," + this.serialize(node.a[1]) + ")";
@@ -2748,63 +2757,10 @@ var BaseSerializerContext = class {
   serializePromiseReject(node) {
     return this.getConstructor(node.a[0]) + "(" + this.getRefParam(node.i) + "," + this.serialize(node.a[1]) + ")";
   }
-  serializeSpecialReferenceValue(ref) {
-    switch (ref) {
-      case 0 /* MapSentinel */:
-        return "[]";
-      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 2 /* PromiseResolve */:
-        return this.createEffectfulFunction(
-          ["p", "d"],
-          'p.s(d),p.status="success",p.value=d;delete p.s;delete p.f'
-        );
-      case 3 /* PromiseReject */:
-        return this.createEffectfulFunction(
-          ["p", "d"],
-          'p.f(d),p.status="failure",p.value=d;delete p.s;delete p.f'
-        );
-      case 4 /* StreamConstructor */:
-        return this.createFunction(
-          ["b", "a", "s", "l", "p", "f", "e", "n"],
-          "(b=[],a=!0,s=!1,l=[],p=0,f=" + this.createEffectfulFunction(
-            ["v", "m", "x"],
-            "for(x=0;x<p;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],(!a&&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)'
-          ) + "})"
-        );
-      case 5 /* AbortSignalConstructor */:
-        return this.createFunction(
-          ["a", "s"],
-          "((s=(a=new AbortController).signal).a=a,s)"
-        );
-      case 6 /* AbortSignalAbort */:
-        return this.createEffectfulFunction(
-          ["s", "r"],
-          "s.a.abort(r);delete s.a"
-        );
-      default:
-        return "";
-    }
-  }
   serializeSpecialReference(node) {
     return this.assignIndexedValue(
       node.i,
-      this.serializeSpecialReferenceValue(node.s)
+      serializeSpecialReferenceValue(this.features, node.s)
     );
   }
   serializeIteratorFactory(node) {
@@ -2908,18 +2864,6 @@ var BaseSerializerContext = class {
   serializeStreamReturn(node) {
     return this.getRefParam(node.i) + ".return(" + this.serialize(node.f) + ")";
   }
-  serializeAbortSignalSync(node) {
-    return this.assignIndexedValue(
-      node.i,
-      "AbortSignal.abort(" + this.serialize(node.f) + ")"
-    );
-  }
-  serializeAbortSignalConstructor(node) {
-    return this.assignIndexedValue(node.i, this.getConstructor(node.f) + "()");
-  }
-  serializeAbortSignalAbort(node) {
-    return this.getConstructor(node.a[0]) + "(" + this.getRefParam(node.i) + "," + this.serialize(node.a[1]) + ")";
-  }
   serialize(node) {
     try {
       switch (node.t) {
@@ -2968,9 +2912,9 @@ var BaseSerializerContext = class {
           return this.serializeBoxed(node);
         case 22 /* PromiseConstructor */:
           return this.serializePromiseConstructor(node);
-        case 23 /* PromiseResolve */:
+        case 23 /* PromiseSuccess */:
           return this.serializePromiseResolve(node);
-        case 24 /* PromiseReject */:
+        case 24 /* PromiseFailure */:
           return this.serializePromiseReject(node);
         case 25 /* Plugin */:
           return this.serializePlugin(node);
@@ -2992,12 +2936,6 @@ var BaseSerializerContext = class {
           return this.serializeStreamThrow(node);
         case 34 /* StreamReturn */:
           return this.serializeStreamReturn(node);
-        case 36 /* AbortSignalAbort */:
-          return this.serializeAbortSignalAbort(node);
-        case 35 /* AbortSignalConstructor */:
-          return this.serializeAbortSignalConstructor(node);
-        case 37 /* AbortSignalSync */:
-          return this.serializeAbortSignalSync(node);
         default:
           throw new SerovalUnsupportedNodeError(node);
       }
@@ -3047,7 +2985,7 @@ var BaseSyncParserContext = class extends BaseParserContext {
     const nodes = [];
     for (let i = 0, len = current.length; i < len; i++) {
       if (i in current) {
-        nodes[i] = this.parse(current[i]);
+        nodes[i] = this.parseTop(current[i]);
       }
     }
     return nodes;
@@ -3061,7 +2999,7 @@ var BaseSyncParserContext = class extends BaseParserContext {
     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]));
+      valueNodes.push(this.parseTop(entries[i][1]));
     }
     let symbol = Symbol.iterator;
     if (symbol in properties) {
@@ -3069,7 +3007,7 @@ var BaseSyncParserContext = class extends BaseParserContext {
       valueNodes.push(
         createIteratorFactoryInstanceNode(
           this.parseIteratorFactory(),
-          this.parse(
+          this.parseTop(
             iteratorToSequence(properties)
           )
         )
@@ -3081,7 +3019,7 @@ var BaseSyncParserContext = class extends BaseParserContext {
       valueNodes.push(
         createAsyncIteratorFactoryInstanceNode(
           this.parseAsyncIteratorFactory(),
-          this.parse(createStream())
+          this.parseTop(createStream())
         )
       );
     }
@@ -3110,16 +3048,20 @@ var BaseSyncParserContext = class extends BaseParserContext {
     );
   }
   parseBoxed(id, current) {
-    return createBoxedNode(id, this.parse(current.valueOf()));
+    return createBoxedNode(id, this.parseTop(current.valueOf()));
   }
   parseTypedArray(id, current) {
-    return createTypedArrayNode(id, current, this.parse(current.buffer));
+    return createTypedArrayNode(id, current, this.parseTop(current.buffer));
   }
   parseBigIntTypedArray(id, current) {
-    return createBigIntTypedArrayNode(id, current, this.parse(current.buffer));
+    return createBigIntTypedArrayNode(
+      id,
+      current,
+      this.parseTop(current.buffer)
+    );
   }
   parseDataView(id, current) {
-    return createDataViewNode(id, current, this.parse(current.buffer));
+    return createDataViewNode(id, current, this.parseTop(current.buffer));
   }
   parseError(id, current) {
     const options = getErrorOptions(current, this.features);
@@ -3141,15 +3083,15 @@ var BaseSyncParserContext = class extends BaseParserContext {
     const keyNodes = [];
     const valueNodes = [];
     for (const [key, value] of current.entries()) {
-      keyNodes.push(this.parse(key));
-      valueNodes.push(this.parse(value));
+      keyNodes.push(this.parseTop(key));
+      valueNodes.push(this.parseTop(value));
     }
     return this.createMapNode(id, keyNodes, valueNodes, current.size);
   }
   parseSet(id, current) {
     const items = [];
     for (const item of current.keys()) {
-      items.push(this.parse(item));
+      items.push(this.parseTop(item));
     }
     return createSetNode(id, current.size, items);
   }
@@ -3179,29 +3121,7 @@ var BaseSyncParserContext = class extends BaseParserContext {
     );
   }
   parsePromise(id, _current) {
-    return this.createPromiseConstructorNode(id);
-  }
-  parseAbortSignalSync(id, current) {
-    return createSerovalNode(
-      37 /* AbortSignalSync */,
-      id,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      this.parse(current.reason),
-      NIL,
-      NIL
-    );
-  }
-  parseAbortSignal(id, current) {
-    if (current.aborted) {
-      return this.parseAbortSignalSync(id, current);
-    }
-    return this.createAbortSignalConstructorNode(id);
+    return this.createPromiseConstructorNode(id, this.createIndex({}));
   }
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ehh
   parseObject(id, current) {
@@ -3213,7 +3133,7 @@ var BaseSyncParserContext = class extends BaseParserContext {
     }
     const currentClass = current.constructor;
     if (currentClass === OpaqueReference) {
-      return this.parse(
+      return this.parseTop(
         current.replacement
       );
     }
@@ -3276,9 +3196,6 @@ var BaseSyncParserContext = class extends BaseParserContext {
       return this.parsePromise(id, current);
     }
     const currentFeatures = this.features;
-    if (currentFeatures & 32 /* AbortSignal */ && typeof AbortSignal !== "undefined" && currentClass === AbortSignal) {
-      return this.parseAbortSignal(id, current);
-    }
     if (currentFeatures & 16 /* BigIntTypedArray */) {
       switch (currentClass) {
         case BigInt64Array:
@@ -3313,36 +3230,39 @@ var BaseSyncParserContext = class extends BaseParserContext {
     }
     throw new SerovalUnsupportedTypeError(current);
   }
-  parse(current) {
-    try {
-      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":
-          return createBigIntNode(current);
-        case "object": {
-          if (current) {
-            const ref = this.getReference(current);
-            return ref.type === 0 /* Fresh */ ? this.parseObject(ref.value, current) : ref.value;
-          }
-          return NULL_NODE;
-        }
-        case "symbol":
-          return this.parseWellKnownSymbol(current);
-        case "function": {
-          return this.parseFunction(current);
+  parseTop(current) {
+    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":
+        return createBigIntNode(current);
+      case "object": {
+        if (current) {
+          const ref = this.getReference(current);
+          return ref.type === 0 /* Fresh */ ? this.parseObject(ref.value, current) : ref.value;
         }
-        default:
-          throw new SerovalUnsupportedTypeError(current);
+        return NULL_NODE;
+      }
+      case "symbol":
+        return this.parseWellKnownSymbol(current);
+      case "function": {
+        return this.parseFunction(current);
       }
+      default:
+        throw new SerovalUnsupportedTypeError(current);
+    }
+  }
+  parse(current) {
+    try {
+      return this.parseTop(current);
     } catch (error) {
-      throw new SerovalParserError(error);
+      throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
     }
   }
 };
@@ -3406,7 +3326,7 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
     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]));
+      valueNodes.push(this.parseTop(entries[i][1]));
     }
     let symbol = Symbol.iterator;
     if (symbol in properties) {
@@ -3414,7 +3334,7 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
       valueNodes.push(
         createIteratorFactoryInstanceNode(
           this.parseIteratorFactory(),
-          this.parse(
+          this.parseTop(
             iteratorToSequence(properties)
           )
         )
@@ -3426,7 +3346,7 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
       valueNodes.push(
         createAsyncIteratorFactoryInstanceNode(
           this.parseAsyncIteratorFactory(),
-          this.parse(
+          this.parseTop(
             createStreamFromAsyncIterable(
               properties
             )
@@ -3450,63 +3370,63 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
       s: keyNodes.length
     };
   }
+  handlePromiseSuccess(id, data) {
+    const parsed = this.parseWithError(data);
+    if (parsed) {
+      this.onParse(
+        createSerovalNode(
+          23 /* PromiseSuccess */,
+          id,
+          NIL,
+          NIL,
+          NIL,
+          NIL,
+          NIL,
+          NIL,
+          [this.parseSpecialReference(2 /* PromiseSuccess */), parsed],
+          NIL,
+          NIL,
+          NIL
+        )
+      );
+    }
+    this.popPendingState();
+  }
+  handlePromiseFailure(id, data) {
+    if (this.alive) {
+      const parsed = this.parseWithError(data);
+      if (parsed) {
+        this.onParse(
+          createSerovalNode(
+            24 /* PromiseFailure */,
+            id,
+            NIL,
+            NIL,
+            NIL,
+            NIL,
+            NIL,
+            NIL,
+            [
+              this.parseSpecialReference(3 /* PromiseFailure */),
+              parsed
+            ],
+            NIL,
+            NIL,
+            NIL
+          )
+        );
+      }
+    }
+    this.popPendingState();
+  }
   parsePromise(id, current) {
+    const resolver = this.createIndex({});
     current.then(
-      (data) => {
-        const parsed = this.parseWithError(data);
-        if (parsed) {
-          this.onParse(
-            createSerovalNode(
-              23 /* PromiseResolve */,
-              id,
-              NIL,
-              NIL,
-              NIL,
-              NIL,
-              NIL,
-              NIL,
-              [
-                this.parseSpecialReference(2 /* PromiseResolve */),
-                parsed
-              ],
-              NIL,
-              NIL,
-              NIL
-            )
-          );
-        }
-        this.popPendingState();
-      },
-      (data) => {
-        if (this.alive) {
-          const parsed = this.parseWithError(data);
-          if (parsed) {
-            this.onParse(
-              createSerovalNode(
-                24 /* PromiseReject */,
-                id,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                [
-                  this.parseSpecialReference(3 /* PromiseReject */),
-                  parsed
-                ],
-                NIL,
-                NIL,
-                NIL
-              )
-            );
-          }
-        }
-        this.popPendingState();
-      }
+      this.handlePromiseSuccess.bind(this, resolver),
+      this.handlePromiseFailure.bind(this, resolver)
     );
     this.pushPendingState();
-    return this.createPromiseConstructorNode(id);
+    return this.createPromiseConstructorNode(id, resolver);
   }
   parsePlugin(id, current) {
     const currentPlugins = this.plugins;
@@ -3563,48 +3483,9 @@ var BaseStreamParserContext = class extends BaseSyncParserContext {
     });
     return result;
   }
-  handleAbortSignal(id, current) {
-    if (this.alive) {
-      const parsed = this.parseWithError(current.reason);
-      if (parsed) {
-        this.onParse(
-          createSerovalNode(
-            36 /* AbortSignalAbort */,
-            id,
-            NIL,
-            NIL,
-            NIL,
-            NIL,
-            NIL,
-            NIL,
-            [
-              this.parseSpecialReference(6 /* AbortSignalAbort */),
-              parsed
-            ],
-            NIL,
-            NIL,
-            NIL
-          )
-        );
-      }
-    }
-    this.popPendingState();
-  }
-  parseAbortSignal(id, current) {
-    if (current.aborted) {
-      return this.parseAbortSignalSync(id, current);
-    }
-    this.pushPendingState();
-    current.addEventListener(
-      "abort",
-      this.handleAbortSignal.bind(this, id, current),
-      { once: true }
-    );
-    return this.createAbortSignalConstructorNode(id);
-  }
   parseWithError(current) {
     try {
-      return this.parse(current);
+      return this.parseTop(current);
     } catch (err) {
       this.onError(err);
       return NIL;
@@ -3845,9 +3726,6 @@ var VanillaSerializerContext = class extends BaseSerializerContext {
   serializePromiseReject(node) {
     throw new SerovalUnsupportedNodeError(node);
   }
-  serializeAbortSignalAbort(node) {
-    throw new SerovalUnsupportedNodeError(node);
-  }
   serializeTop(tree) {
     const result = this.serialize(tree);
     if (tree.i != null && this.vars.length) {