seroval 1.6.12 → 1.7.1

package/dist/dev/index.js

@@ -1,11 +1,14 @@
 //#region src/core/compat.ts
 /**
-* References
-* - https://compat-table.github.io/compat-table/es6/
-* - MDN
+* Public feature bits for `disabledFeatures`. Stays a runtime `enum` so the
+* published declaration is unchanged for consumers. Its values must match
+* the internal bits (checked by test/feature.test.ts).
 */
 let Feature = /* @__PURE__ */ function(Feature) {
 	Feature[Feature["AggregateError"] = 1] = "AggregateError";
+	/**
+	* @deprecated Has no effect. Output always uses arrow functions.
+	*/
 	Feature[Feature["ArrowFunction"] = 2] = "ArrowFunction";
 	Feature[Feature["ErrorPrototypeStack"] = 4] = "ErrorPrototypeStack";
 	Feature[Feature["ObjectAssign"] = 8] = "ObjectAssign";
@@ -31,35 +34,15 @@ const SYM_TO_STRING_TAG = Symbol.toStringTag;
 const SYM_UNSCOPABLES = Symbol.unscopables;
 //#endregion
 //#region src/core/constants.ts
-const SYMBOL_STRING = {
-	[0]: "Symbol.asyncIterator",
-	[1]: "Symbol.hasInstance",
-	[2]: "Symbol.isConcatSpreadable",
-	[3]: "Symbol.iterator",
-	[4]: "Symbol.match",
-	[5]: "Symbol.matchAll",
-	[6]: "Symbol.replace",
-	[7]: "Symbol.search",
-	[8]: "Symbol.species",
-	[9]: "Symbol.split",
-	[10]: "Symbol.toPrimitive",
-	[11]: "Symbol.toStringTag",
-	[12]: "Symbol.unscopables"
-};
-const INV_SYMBOL_REF = {
-	[SYM_ASYNC_ITERATOR]: 0,
-	[SYM_HAS_INSTANCE]: 1,
-	[SYM_IS_CONCAT_SPREADABLE]: 2,
-	[SYM_ITERATOR]: 3,
-	[SYM_MATCH]: 4,
-	[SYM_MATCH_ALL]: 5,
-	[SYM_REPLACE]: 6,
-	[SYM_SEARCH]: 7,
-	[SYM_SPECIES]: 8,
-	[SYM_SPLIT]: 9,
-	[SYM_TO_PRIMITIVE]: 10,
-	[SYM_TO_STRING_TAG]: 11,
-	[SYM_UNSCOPABLES]: 12
+const TEMPORAL_TYPE_NAME = {
+	[0]: "Instant",
+	[1]: "Duration",
+	[2]: "PlainDate",
+	[3]: "PlainDateTime",
+	[4]: "PlainMonthDay",
+	[5]: "PlainTime",
+	[6]: "PlainYearMonth",
+	[7]: "ZonedDateTime"
 };
 const SYMBOL_REF = {
 	[0]: SYM_ASYNC_ITERATOR,
@@ -76,6 +59,18 @@ const SYMBOL_REF = {
 	[11]: SYM_TO_STRING_TAG,
 	[12]: SYM_UNSCOPABLES
 };
+function createSymbolStringTable() {
+	const result = {};
+	for (let i = 0; i <= 12; i++) result[i] = SYMBOL_REF[i].description;
+	return result;
+}
+const SYMBOL_STRING = /* @__PURE__ */ createSymbolStringTable();
+function createInverseSymbolTable() {
+	const result = {};
+	for (let i = 0; i <= 12; i++) result[SYMBOL_REF[i]] = i;
+	return result;
+}
+const INV_SYMBOL_REF = /* @__PURE__ */ createInverseSymbolTable();
 const CONSTANT_STRING = {
 	[2]: "!0",
 	[3]: "!1",
@@ -92,19 +87,10 @@ const CONSTANT_VAL = {
 	[1]: void 0,
 	[0]: null,
 	[4]: -0,
-	[5]: Number.POSITIVE_INFINITY,
-	[6]: Number.NEGATIVE_INFINITY,
+	[5]: Infinity,
+	[6]: -Infinity,
 	[7]: NaN
 };
-const ERROR_CONSTRUCTOR_STRING = {
-	[0]: "Error",
-	[1]: "EvalError",
-	[2]: "RangeError",
-	[3]: "ReferenceError",
-	[4]: "SyntaxError",
-	[5]: "TypeError",
-	[6]: "URIError"
-};
 const ERROR_CONSTRUCTOR = {
 	[0]: Error,
 	[1]: EvalError,
@@ -114,9 +100,20 @@ const ERROR_CONSTRUCTOR = {
 	[5]: TypeError,
 	[6]: URIError
 };
+function createErrorConstructorStringTable() {
+	const result = {};
+	for (let i = 0; i <= 6; i++) result[i] = ERROR_CONSTRUCTOR[i].name;
+	return result;
+}
+const ERROR_CONSTRUCTOR_STRING = /* @__PURE__ */ createErrorConstructorStringTable();
 //#endregion
 //#region src/core/node.ts
 function createSerovalNode(t, i, s, c, m, p, e, a, f, b, o, l) {
+	if (c === void 0 && m === void 0 && p === void 0 && e === void 0 && a === void 0 && f === void 0 && b === void 0 && o === void 0 && l === void 0) return {
+		t,
+		i,
+		s
+	};
 	return {
 		t,
 		i,
@@ -135,7 +132,7 @@ function createSerovalNode(t, i, s, c, m, p, e, a, f, b, o, l) {
 //#endregion
 //#region src/core/literals.ts
 function createConstantNode(value) {
-	return createSerovalNode(2, void 0, value, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(2, void 0, value);
 }
 const TRUE_NODE = /* @__PURE__ */ createConstantNode(2);
 const FALSE_NODE = /* @__PURE__ */ createConstantNode(3);
@@ -148,60 +145,109 @@ const NAN_NODE = /* @__PURE__ */ createConstantNode(7);
 //#endregion
 //#region src/core/string.ts
 const MIN_JSON_STRINGIFY_LENGTH = 64;
-const JSON_ESCAPE_DIFFERENCES = /[\x00-\x07\x0b\x0e-\x1f<\u2028\u2029\ud800-\udfff]/;
-function serializeChar(str) {
-	switch (str) {
-		case "\"": return "\\\"";
-		case "\\": return "\\\\";
-		case "\n": return "\\n";
-		case "\r": return "\\r";
-		case "\b": return "\\b";
-		case "	": return "\\t";
-		case "\f": return "\\f";
-		case "<": return "\\x3C";
-		case "\u2028": return "\\u2028";
-		case "\u2029": return "\\u2029";
+const NEEDS_ESCAPE = /["\\\n\r\b\t\f<\u2028\u2029]/;
+const JSON_ESCAPE_DIFFERENCES = /[\x00-\x07\x0b\x0e-\x1f\ud800-\udfff]/;
+const LESS_THAN = /</g;
+const LINE_SEPARATOR = /\u2028/g;
+const PARAGRAPH_SEPARATOR = /\u2029/g;
+function escapeCharCode(code) {
+	switch (code) {
+		case 34: return "\\\"";
+		case 92: return "\\\\";
+		case 10: return "\\n";
+		case 13: return "\\r";
+		case 8: return "\\b";
+		case 9: return "\\t";
+		case 12: return "\\f";
+		case 60: return "\\x3C";
+		case 8232: return "\\u2028";
+		case 8233: return "\\u2029";
 		default: return;
 	}
 }
 function serializeString(str) {
-	if (str.length >= MIN_JSON_STRINGIFY_LENGTH && !JSON_ESCAPE_DIFFERENCES.test(str)) return JSON.stringify(str).slice(1, -1);
+	if (!NEEDS_ESCAPE.test(str)) return str;
+	if (str.length >= MIN_JSON_STRINGIFY_LENGTH && !JSON_ESCAPE_DIFFERENCES.test(str)) {
+		let result = JSON.stringify(str).slice(1, -1);
+		if (result.includes("<")) result = result.replace(LESS_THAN, "\\x3C");
+		if (result.includes("\u2028")) result = result.replace(LINE_SEPARATOR, "\\u2028");
+		if (result.includes("\u2029")) result = result.replace(PARAGRAPH_SEPARATOR, "\\u2029");
+		return result;
+	}
 	let result = "";
 	let lastPos = 0;
 	let replacement;
 	for (let i = 0, len = str.length; i < len; i++) {
-		replacement = serializeChar(str[i]);
+		replacement = escapeCharCode(str.charCodeAt(i));
 		if (replacement) {
 			result += str.slice(lastPos, i) + replacement;
 			lastPos = i + 1;
 		}
 	}
-	if (lastPos === 0) result = str;
-	else result += str.slice(lastPos);
-	return result;
-}
-function deserializeReplacer(str) {
-	switch (str) {
-		case "\\\\": return "\\";
-		case "\\\"": return "\"";
-		case "\\n": return "\n";
-		case "\\r": return "\r";
-		case "\\b": return "\b";
-		case "\\t": return "	";
-		case "\\f": return "\f";
-		case "\\x3C": return "<";
-		case "\\u2028": return "\u2028";
-		case "\\u2029": return "\u2029";
-		default: return str;
-	}
+	return result + str.slice(lastPos);
 }
+const JSON_COMPATIBLE = /^(?:[^"\\\x00-\x1f]|\\["\\nrbtf])*$/;
+const ESCAPE_SEQUENCE = /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g;
 function deserializeString(str) {
-	if (typeof str === "string" && !str.includes("\\")) return str;
-	return str.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g, deserializeReplacer);
+	if (typeof str !== "string") return str.replace(ESCAPE_SEQUENCE, deserializeString);
+	let index = str.indexOf("\\");
+	if (index === -1) return str;
+	if (JSON_COMPATIBLE.test(str)) return JSON.parse("\"" + str + "\"");
+	let result = "";
+	let lastPos = 0;
+	const last = str.length - 1;
+	while (index !== -1 && index < last) {
+		let replacement;
+		let length = 2;
+		switch (str.charCodeAt(index + 1)) {
+			case 92:
+				replacement = "\\";
+				break;
+			case 34:
+				replacement = "\"";
+				break;
+			case 110:
+				replacement = "\n";
+				break;
+			case 114:
+				replacement = "\r";
+				break;
+			case 98:
+				replacement = "\b";
+				break;
+			case 116:
+				replacement = "	";
+				break;
+			case 102:
+				replacement = "\f";
+				break;
+			case 120:
+				if (str.startsWith("3C", index + 2)) {
+					replacement = "<";
+					length = 4;
+				}
+				break;
+			case 117: if (str.startsWith("2028", index + 2)) {
+				replacement = "\u2028";
+				length = 6;
+			} else if (str.startsWith("2029", index + 2)) {
+				replacement = "\u2029";
+				length = 6;
+			}
+		}
+		if (replacement) {
+			result += str.slice(lastPos, index) + replacement;
+			lastPos = index + length;
+			index = str.indexOf("\\", lastPos);
+		} else index = str.indexOf("\\", index + 1);
+	}
+	return result + str.slice(lastPos);
 }
 //#endregion
 //#region src/core/errors.ts
-const { toString: objectToString } = Object.prototype;
+function objectToString(value) {
+	return Object.prototype.toString.call(value);
+}
 function getErrorMessageDev(type, cause) {
 	if (cause instanceof Error) return `Seroval caught an error during the ${type} process.
 
@@ -212,14 +258,13 @@ ${cause.message}
 - If you believe this is an error in Seroval, please submit an issue at https://github.com/lxsmnsyc/seroval/issues/new`;
 	return `Seroval caught an error during the ${type} process.
 
-"${objectToString.call(cause)}"
+"${objectToString(cause)}"
 
 For more information, please check the "cause" property of this error.`;
 }
-const getErrorMessage = (type, cause) => getErrorMessageDev(type, cause);
 var SerovalError = class extends Error {
 	constructor(type, cause) {
-		super(getErrorMessage(type, cause));
+		super(getErrorMessageDev(type, cause));
 		this.cause = cause;
 	}
 };
@@ -240,7 +285,7 @@ var SerovalDeserializationError = class extends SerovalError {
 };
 var SerovalUnsupportedTypeError = class extends Error {
 	constructor(value) {
-		super(`The value ${objectToString.call(value)} of type "${typeof value}" cannot be parsed/serialized.
+		super(`The value ${objectToString(value)} of type "${typeof value}" cannot be parsed/serialized.
       
 There are few workarounds for this problem:
 - Transform the value in a way that it can be serialized.
@@ -263,9 +308,13 @@ var SerovalMissingInstanceError = class extends Error {
 		super("Missing \"" + tag + "\" instance.");
 	}
 };
+/**
+* @deprecated Not thrown by seroval. A missing `createReference` key throws
+* {@link SerovalMissingReferenceForIdError} instead.
+*/
 var SerovalMissingReferenceError = class extends Error {
 	constructor(value) {
-		super("Missing reference for the value \"" + objectToString.call(value) + "\" of type \"" + typeof value + "\"");
+		super("Missing reference for the value \"" + objectToString(value) + "\" of type \"" + typeof value + "\"");
 		this.value = value;
 	}
 };
@@ -294,103 +343,43 @@ var SerovalDepthLimitError = class extends Error {
 		super("Depth limit of " + limit + " reached");
 	}
 };
-//#endregion
-//#region src/core/keys.ts
-const REFERENCES_KEY = "__SEROVAL_REFS__";
-const GLOBAL_CONTEXT_R = `self.\$R`;
-function getCrossReferenceHeader(id) {
-	if (id == null) return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
-	return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(id)}"]=[]`;
-}
-//#endregion
-//#region src/core/reference.ts
-const REFERENCE = /* @__PURE__ */ new Map();
-const INV_REFERENCE = /* @__PURE__ */ new Map();
-function createReference(id, value) {
-	REFERENCE.set(value, id);
-	INV_REFERENCE.set(id, value);
-	return value;
-}
-function hasReferenceID(value) {
-	return REFERENCE.has(value);
-}
-function hasReference(id) {
-	return INV_REFERENCE.has(id);
-}
-function getReferenceID(value) {
-	if (hasReferenceID(value)) return REFERENCE.get(value);
-	throw new SerovalMissingReferenceError(value);
-}
-function getReference(id) {
-	if (hasReference(id)) return INV_REFERENCE.get(id);
-	throw new SerovalMissingReferenceForIdError(id);
-}
-if (typeof globalThis !== "undefined") Object.defineProperty(globalThis, REFERENCES_KEY, {
-	value: INV_REFERENCE,
-	configurable: true,
-	writable: false,
-	enumerable: false
-});
-else if (typeof window !== "undefined") Object.defineProperty(window, REFERENCES_KEY, {
-	value: INV_REFERENCE,
-	configurable: true,
-	writable: false,
-	enumerable: false
-});
-else if (typeof self !== "undefined") Object.defineProperty(self, REFERENCES_KEY, {
-	value: INV_REFERENCE,
-	configurable: true,
-	writable: false,
-	enumerable: false
-});
-else if (typeof global !== "undefined") Object.defineProperty(global, REFERENCES_KEY, {
-	value: INV_REFERENCE,
-	configurable: true,
-	writable: false,
-	enumerable: false
-});
+var SerovalAbortedError = class extends Error {
+	constructor() {
+		super("Cross deserializer has been aborted.");
+	}
+};
+const LIVE_STREAM_ERROR_MESSAGES = {
+	consumed: "Live stream already has a consumer",
+	pending: "Live stream already has a pending event",
+	reading: "Live stream already has a pending read",
+	closed: "Live stream is closed"
+};
+var SerovalLiveStreamError = class extends Error {
+	constructor(reason) {
+		super(LIVE_STREAM_ERROR_MESSAGES[reason]);
+		this.reason = reason;
+	}
+};
 //#endregion
 //#region src/core/utils/error.ts
 function getErrorConstructor(error) {
-	if (error instanceof EvalError) return 1;
-	if (error instanceof RangeError) return 2;
-	if (error instanceof ReferenceError) return 3;
-	if (error instanceof SyntaxError) return 4;
-	if (error instanceof TypeError) return 5;
-	if (error instanceof URIError) return 6;
+	for (let i = 1; i <= 6; i++) if (error instanceof ERROR_CONSTRUCTOR[i]) return i;
 	return 0;
 }
-function getInitialErrorOptions(error) {
-	const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
-	if (error.name !== construct) return { name: error.name };
-	if (error.constructor.name !== construct) return { name: error.constructor.name };
-	return {};
-}
 function getErrorOptions(error, features) {
-	let options = getInitialErrorOptions(error);
-	const names = Object.getOwnPropertyNames(error);
-	for (let i = 0, len = names.length, name; i < len; i++) {
-		name = names[i];
-		if (name !== "name" && name !== "message") {
-			if (name === "stack") {
-				if (features & 4) {
-					options = options || {};
-					options[name] = error[name];
-				}
-			} else {
-				options = options || {};
-				options[name] = error[name];
-			}
-		}
-	}
+	const options = Object.create(null);
+	const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
+	if (error.name !== construct) options.name = error.name;
+	else if (error.constructor.name !== construct) options.name = error.constructor.name;
+	for (const name of Object.getOwnPropertyNames(error)) if (name !== "name" && name !== "message" && (name !== "stack" || features & 4)) options[name] = error[name];
 	return options;
 }
 //#endregion
 //#region src/core/utils/get-object-flag.ts
 function getObjectFlag(obj) {
+	if (Object.isExtensible(obj)) return 0;
 	if (Object.isFrozen(obj)) return 3;
 	if (Object.isSealed(obj)) return 2;
-	if (Object.isExtensible(obj)) return 0;
 	return 1;
 }
 //#endregion
@@ -425,86 +414,265 @@ function createNumberNode(value) {
 	}
 	if (value !== value) return NAN_NODE;
 	if (Object.is(value, -0)) return NEG_ZERO_NODE;
-	return createSerovalNode(0, void 0, value, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(0, void 0, value);
 }
 function createStringNode(value) {
-	return createSerovalNode(1, void 0, serializeString(value), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(1, void 0, serializeString(value));
 }
 function createBigIntNode(current) {
-	return createSerovalNode(3, void 0, "" + current, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(3, void 0, "" + current);
 }
 function createIndexedValueNode(id) {
-	return createSerovalNode(4, id, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(4, id);
 }
 function createDateNode(id, current) {
 	const timestamp = current.valueOf();
-	return createSerovalNode(5, id, timestamp !== timestamp ? "" : current.toISOString(), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(5, id, timestamp === timestamp ? current.toISOString() : "");
 }
 function createTemporalNode(id, type, current) {
-	return createSerovalNode(36, id, current.toString(), type, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(36, id, current.toString(), type);
 }
 function createRegExpNode(id, current) {
-	return createSerovalNode(6, id, void 0, serializeString(current.source), current.flags, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(6, id, void 0, serializeString(current.source), current.flags);
 }
 function createWKSymbolNode(id, current) {
-	return createSerovalNode(17, id, INV_SYMBOL_REF[current], void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(17, id, INV_SYMBOL_REF[current]);
 }
-function createReferenceNode(id, ref) {
-	return createSerovalNode(18, id, serializeString(getReferenceID(ref)), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+function createReferenceNode(id, referenceId) {
+	return createSerovalNode(18, id, serializeString(referenceId));
 }
 function createPluginNode(id, tag, value) {
-	return createSerovalNode(25, id, value, serializeString(tag), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	return createSerovalNode(25, id, value, serializeString(tag));
 }
 function createArrayNode(id, current, parsedItems) {
-	return createSerovalNode(9, id, void 0, void 0, void 0, void 0, void 0, parsedItems, void 0, void 0, getObjectFlag(current), void 0);
+	return createSerovalNode(9, id, void 0, void 0, void 0, void 0, void 0, parsedItems, void 0, void 0, getObjectFlag(current));
 }
 function createBoxedNode(id, boxed) {
-	return createSerovalNode(21, id, void 0, void 0, void 0, void 0, void 0, void 0, boxed, void 0, void 0, void 0);
+	return createSerovalNode(21, id, void 0, void 0, void 0, void 0, void 0, void 0, boxed);
 }
 const MAX_TYPED_ARRAY_LENGTH = 1e6;
-function createTypedArrayNode(id, current, buffer) {
-	if (current.length > MAX_TYPED_ARRAY_LENGTH) throw new SerovalUnsupportedTypeError(current);
-	return createSerovalNode(15, id, void 0, getTypedArrayName(current), void 0, void 0, void 0, void 0, buffer, current.byteOffset, void 0, current.length);
-}
-function createBigIntTypedArrayNode(id, current, buffer) {
-	if (current.length > MAX_TYPED_ARRAY_LENGTH) throw new SerovalUnsupportedTypeError(current);
-	return createSerovalNode(16, id, void 0, getTypedArrayName(current), void 0, void 0, void 0, void 0, buffer, current.byteOffset, void 0, current.length);
-}
-function createDataViewNode(id, current, buffer) {
-	if (current.byteLength > MAX_TYPED_ARRAY_LENGTH) throw new SerovalUnsupportedTypeError(current);
-	return createSerovalNode(20, id, void 0, void 0, void 0, void 0, void 0, void 0, buffer, current.byteOffset, void 0, current.byteLength);
+function createViewNode(type, id, current, buffer) {
+	const isDataView = type === 20;
+	const size = isDataView ? current.byteLength : current.length;
+	if (size > MAX_TYPED_ARRAY_LENGTH) throw new SerovalUnsupportedTypeError(current);
+	return createSerovalNode(type, id, void 0, isDataView ? void 0 : getTypedArrayName(current), void 0, void 0, void 0, void 0, buffer, current.byteOffset, void 0, size);
 }
-function createErrorNode(id, current, options) {
-	return createSerovalNode(13, id, getErrorConstructor(current), void 0, serializeString(current.message), options, void 0, void 0, void 0, void 0, void 0, void 0);
-}
-function createAggregateErrorNode(id, current, options) {
-	return createSerovalNode(14, id, getErrorConstructor(current), void 0, serializeString(current.message), options, void 0, void 0, void 0, void 0, void 0, void 0);
+function createErrorNode(type, id, current, options) {
+	return createSerovalNode(type, id, getErrorConstructor(current), void 0, serializeString(current.message), options);
 }
 function createSetNode(id, items) {
-	return createSerovalNode(7, id, void 0, void 0, void 0, void 0, void 0, items, void 0, void 0, void 0, void 0);
-}
-function createIteratorFactoryInstanceNode(factory, items) {
-	return createSerovalNode(28, void 0, void 0, void 0, void 0, void 0, void 0, [factory, items], void 0, void 0, void 0, void 0);
-}
-function createAsyncIteratorFactoryInstanceNode(factory, items) {
-	return createSerovalNode(30, void 0, void 0, void 0, void 0, void 0, void 0, [factory, items], void 0, void 0, void 0, void 0);
-}
-function createStreamConstructorNode(id, factory, sequence) {
-	return createSerovalNode(31, id, void 0, void 0, void 0, void 0, void 0, sequence, factory, void 0, void 0, void 0);
+	return createSerovalNode(7, id, void 0, void 0, void 0, void 0, void 0, items);
 }
-function createStreamNextNode(id, parsed) {
-	return createSerovalNode(32, id, void 0, void 0, void 0, void 0, void 0, void 0, parsed, void 0, void 0, void 0);
+function createIteratorFactoryInstanceNode(type, factory, items) {
+	return createSerovalNode(type, void 0, void 0, void 0, void 0, void 0, void 0, [factory, items]);
 }
-function createStreamThrowNode(id, parsed) {
-	return createSerovalNode(33, id, void 0, void 0, void 0, void 0, void 0, void 0, parsed, void 0, void 0, void 0);
+function createStreamConstructorNode(id, factory, sequence, live) {
+	return createSerovalNode(31, id, void 0, void 0, void 0, void 0, void 0, sequence, factory, void 0, void 0, live);
 }
-function createStreamReturnNode(id, parsed) {
-	return createSerovalNode(34, id, void 0, void 0, void 0, void 0, void 0, void 0, parsed, void 0, void 0, void 0);
+function createStreamEventNode(type, id, parsed) {
+	return createSerovalNode(type, id, void 0, void 0, void 0, void 0, void 0, void 0, parsed);
 }
 function createSequenceNode(id, sequence, throwAt, doneAt) {
 	return createSerovalNode(35, id, throwAt, void 0, void 0, void 0, void 0, sequence, void 0, void 0, void 0, doneAt);
 }
 //#endregion
+//#region src/core/live-stream.ts
+function isLiveStream(value) {
+	return value instanceof LiveStream;
+}
+/**
+* A single-consumer stream for incremental serialization. Unlike
+* `createStream`, it keeps no history: at most one event is held, and the
+* producer operation that sent it settles only when the consumer accepts it.
+*
+* An internal class rather than a tagged POJO: identity is checked with
+* `instanceof`, which untrusted input cannot forge. The class is exported
+* because bundlers cannot drop an unexported top-level class.
+*/
+var LiveStream = class {
+	constructor(options) {
+		this.consumed = false;
+		this.closed = false;
+		this.cancelled = false;
+		this.options = options;
+	}
+	deliver(reader, record) {
+		record.delivered = true;
+		reader.resolve({
+			event: record.event,
+			accept: () => {
+				if (this.pending === record && record.delivered) {
+					const terminal = record.event.type !== "next";
+					record.event = void 0;
+					this.pending = void 0;
+					const resolve = record.resolve;
+					record.resolve = void 0;
+					record.reject = void 0;
+					if (terminal) {
+						this.closed = true;
+						this.options = void 0;
+						const waiter = this.waiting;
+						this.waiting = void 0;
+						waiter?.reject(new SerovalLiveStreamError("closed"));
+					}
+					resolve?.();
+				}
+			}
+		});
+	}
+	/** @internal */
+	push(event) {
+		if (this.cancelled) return Promise.reject(this.cancelReason);
+		if (this.closed) return Promise.reject(new SerovalLiveStreamError("closed"));
+		if (this.pending) return Promise.reject(new SerovalLiveStreamError("pending"));
+		return new Promise((resolve, reject) => {
+			const record = {
+				event,
+				delivered: false,
+				resolve,
+				reject
+			};
+			this.pending = record;
+			if (this.waiting) {
+				const waiter = this.waiting;
+				this.waiting = void 0;
+				this.deliver(waiter, record);
+			}
+		});
+	}
+	cancel(reason) {
+		if (this.cancelled || this.closed) return;
+		this.cancelled = true;
+		this.cancelReason = reason;
+		const record = this.pending;
+		const waiter = this.waiting;
+		this.pending = void 0;
+		this.waiting = void 0;
+		const callbackOwner = this.options;
+		this.options = void 0;
+		if (record) {
+			record.event = void 0;
+			const reject = record.reject;
+			record.resolve = void 0;
+			record.reject = void 0;
+			reject?.(reason);
+		}
+		if (waiter) waiter.reject(reason);
+		callbackOwner?.onCancel?.(reason);
+	}
+	read() {
+		if (this.cancelled) return Promise.reject(this.cancelReason);
+		if (this.closed) return Promise.reject(new SerovalLiveStreamError("closed"));
+		if (this.waiting) return Promise.reject(new SerovalLiveStreamError("reading"));
+		return new Promise((resolve, reject) => {
+			const next = {
+				resolve,
+				reject
+			};
+			if (this.pending && !this.pending.delivered) this.deliver(next, this.pending);
+			else this.waiting = next;
+		});
+	}
+	consume() {
+		if (this.consumed) throw new SerovalLiveStreamError("consumed");
+		this.consumed = true;
+		return {
+			read: () => this.read(),
+			cancel: (reason) => this.cancel(reason)
+		};
+	}
+	/**
+	* Consumes the stream through a replay-style listener, accepting each
+	* event as soon as it has been delivered. Use `consume` or `pump` when
+	* acceptance must wait for processing.
+	*/
+	on(listener) {
+		const wrap = (key) => (value, accept) => {
+			listener[key](value);
+			accept();
+		};
+		return this.pump({
+			next: wrap("next"),
+			throw: wrap("throw"),
+			return: wrap("return")
+		});
+	}
+	/**
+	* Consumes the stream into a sink that controls acceptance. Returns the
+	* cancel function.
+	* @internal
+	*/
+	pump(sink) {
+		const consumer = this.consume();
+		let current = sink;
+		function next() {
+			consumer.read().then((delivery) => {
+				const target = current;
+				if (!target) return;
+				const event = delivery.event;
+				let failure;
+				let failed = false;
+				try {
+					failure = target[event.type](event.type === "throw" ? event.error : event.value, delivery.accept);
+				} catch (error) {
+					failed = true;
+					failure = error;
+				}
+				if (failed || failure !== void 0) {
+					current = void 0;
+					try {
+						consumer.cancel(failure);
+					} finally {
+						target.done?.();
+					}
+					return;
+				}
+				if (event.type === "next") {
+					next();
+					return;
+				}
+				current = void 0;
+				target.done?.();
+			}, (reason) => {
+				const target = current;
+				current = void 0;
+				target?.error?.(reason);
+			});
+		}
+		next();
+		return consumer.cancel;
+	}
+};
+/**
+* Creates a live stream and the producer that writes to it.
+*/
+function createLiveStream(options) {
+	const stream = new LiveStream(options);
+	return {
+		stream,
+		producer: {
+			write(value) {
+				return stream.push({
+					type: "next",
+					value
+				});
+			},
+			close(value) {
+				return stream.push({
+					type: "return",
+					value
+				});
+			},
+			fail(error) {
+				return stream.push({
+					type: "throw",
+					error
+				});
+			}
+		}
+	};
+}
+//#endregion
 //#region src/core/opaque-reference.ts
 /**
 * An opaque reference allows hiding values from the serializer.
@@ -542,7 +710,7 @@ const PROMISE_FAILURE = (resolver, data) => {
 const SERIALIZED_PROMISE_CONSTRUCTOR = /* @__PURE__ */ PROMISE_CONSTRUCTOR.toString();
 const SERIALIZED_PROMISE_SUCCESS = /* @__PURE__ */ PROMISE_SUCCESS.toString();
 const SERIALIZED_PROMISE_FAILURE = /* @__PURE__ */ PROMISE_FAILURE.toString();
-const STREAM_CONSTRUCTOR = () => {
+const STREAM_CONSTRUCTOR = (live) => {
 	const buffer = [];
 	const listeners = [];
 	let alive = true;
@@ -550,6 +718,7 @@ const STREAM_CONSTRUCTOR = () => {
 	let count = 0;
 	const internal = {
 		flush(value, mode, x) {
+			live > 1 || buffer.push(value);
 			for (x = 0; x < count; x++) {
 				const listener = listeners[x];
 				if (listener) listener[mode](value);
@@ -563,6 +732,7 @@ const STREAM_CONSTRUCTOR = () => {
 			}
 		},
 		on(listener, temp = 0) {
+			if (live > 1) throw new Error("Stream consumed");
 			let subscribed = alive;
 			if (alive) {
 				for (temp = 0; temp < count; temp++) if (!listeners[temp]) break;
@@ -570,6 +740,10 @@ const STREAM_CONSTRUCTOR = () => {
 				listeners[temp] = listener;
 			}
 			internal.up(listener);
+			if (live) {
+				live = 2;
+				buffer.length = 0;
+			}
 			return () => {
 				if (alive && subscribed) {
 					subscribed = false;
@@ -586,14 +760,10 @@ const STREAM_CONSTRUCTOR = () => {
 			return internal.on(listener);
 		},
 		next(value) {
-			if (alive) {
-				buffer.push(value);
-				internal.flush(value, "next");
-			}
+			if (alive) internal.flush(value, "next");
 		},
 		throw(value) {
 			if (alive) {
-				buffer.push(value);
 				internal.flush(value, "throw");
 				alive = false;
 				success = false;
@@ -602,7 +772,6 @@ const STREAM_CONSTRUCTOR = () => {
 		},
 		return(value) {
 			if (alive) {
-				buffer.push(value);
 				internal.flush(value, "return");
 				alive = false;
 				success = true;
@@ -724,7 +893,8 @@ const SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR = /* @__PURE__ */ ARRAY_BUFFER_CONSTRU
 //#region src/core/sequence.ts
 /**
 * An internal class rather than a tagged POJO: identity is checked with
-* `instanceof`, which untrusted input cannot forge (the class is not exported).
+* `instanceof`, which untrusted input cannot forge. The class is exported
+* because bundlers cannot drop an unexported top-level class.
 * The eval-based `deserialize` path still rebuilds a `{__SEROVAL_SEQUENCE__…}`
 * POJO from embedded source - it has no access to this class - so a value read
 * back through `deserialize` is not an instance and, by design, is not treated
@@ -748,7 +918,7 @@ function createSequenceFromIterable(source) {
 	let throwsAt = -1;
 	let doneAt = -1;
 	const iterator = source[SYM_ITERATOR]();
-	while (true) try {
+	for (;;) try {
 		const value = iterator.next();
 		values.push(value.value);
 		if (value.done) {
@@ -763,7 +933,7 @@ function createSequenceFromIterable(source) {
 	}
 	return createSequence(values, throwsAt, doneAt);
 }
-const createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
+const createIterator = /* @__PURE__ */ ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
 function sequenceToIterator(sequence) {
 	return createIterator(sequence);
 }
@@ -794,7 +964,8 @@ const SPECIAL_REF_STRING = {
 //#region src/core/stream.ts
 /**
 * An internal class rather than a tagged POJO: identity is checked with
-* `instanceof`, which untrusted input cannot forge (the class is not exported).
+* `instanceof`, which untrusted input cannot forge. The class is exported
+* because bundlers cannot drop an unexported top-level class.
 *
 * The behavior is intentionally duplicated from `STREAM_CONSTRUCTOR`. That
 * constructor's source is embedded verbatim into the eval-based `deserialize`
@@ -804,18 +975,17 @@ const SPECIAL_REF_STRING = {
 * implementations in sync.
 */
 var Stream = class {
-	constructor() {
+	constructor(live) {
 		this.buffer = [];
 		this.listeners = [];
 		this.alive = true;
 		this.success = false;
 		this.count = 0;
+		this.live = live;
 	}
 	flush(value, mode) {
-		for (let x = 0; x < this.count; x++) {
-			var _this$listeners$x;
-			(_this$listeners$x = this.listeners[x]) === null || _this$listeners$x === void 0 || _this$listeners$x[mode](value);
-		}
+		this.live > 1 || this.buffer.push(value);
+		for (let x = 0; x < this.count; x++) this.listeners[x]?.[mode](value);
 	}
 	replay(listener) {
 		for (let x = 0, z = this.buffer.length; x < z; x++) {
@@ -825,6 +995,7 @@ var Stream = class {
 		}
 	}
 	on(listener) {
+		if (this.live > 1) throw new Error("Stream consumed");
 		let subscribed = this.alive;
 		let temp = 0;
 		if (subscribed) {
@@ -833,6 +1004,10 @@ var Stream = class {
 			this.listeners[temp] = listener;
 		}
 		this.replay(listener);
+		if (this.live) {
+			this.live = 2;
+			this.buffer.length = 0;
+		}
 		return () => {
 			if (this.alive && subscribed) {
 				subscribed = false;
@@ -842,15 +1017,25 @@ var Stream = class {
 			}
 		};
 	}
+	/**
+	* Returns the events of a stream that has ended, without subscribing, so a
+	* live receiver is not consumed. The last value is the `return` or `throw`
+	* value. Returns `undefined` while the stream is open, or when a live
+	* receiver was already consumed and has no events left.
+	* @internal
+	*/
+	endedEvents() {
+		if (this.alive || this.live > 1) return void 0;
+		return {
+			values: this.buffer.slice(),
+			success: this.success
+		};
+	}
 	next(value) {
-		if (this.alive) {
-			this.buffer.push(value);
-			this.flush(value, "next");
-		}
+		if (this.alive) this.flush(value, "next");
 	}
 	throw(value) {
 		if (this.alive) {
-			this.buffer.push(value);
 			this.flush(value, "throw");
 			this.alive = false;
 			this.success = false;
@@ -859,7 +1044,6 @@ var Stream = class {
 	}
 	return(value) {
 		if (this.alive) {
-			this.buffer.push(value);
 			this.flush(value, "return");
 			this.alive = false;
 			this.success = true;
@@ -868,46 +1052,12 @@ var Stream = class {
 	}
 };
 function isStream(value) {
-	return value instanceof Stream;
+	return value instanceof Stream || isLiveStream(value);
 }
 function createStream() {
 	return new Stream();
 }
-function createStreamFromAsyncIterable(iterable, cleanups) {
-	const stream = createStream();
-	const iterator = iterable[SYM_ASYNC_ITERATOR]();
-	let cancelled = false;
-	let done = false;
-	cleanups === null || cleanups === void 0 || cleanups.push(() => {
-		if (!(done || cancelled)) {
-			cancelled = true;
-			Promise.resolve().then(() => {
-				var _iterator$return;
-				return (_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator);
-			}).catch(() => {});
-		}
-	});
-	async function push() {
-		try {
-			while (!cancelled) {
-				const value = await iterator.next();
-				if (cancelled) return;
-				if (value.done) {
-					done = true;
-					stream.return(value.value);
-					break;
-				}
-				stream.next(value.value);
-			}
-		} catch (error) {
-			done = true;
-			if (!cancelled) stream.throw(error);
-		}
-	}
-	push().catch(() => {});
-	return stream;
-}
-const createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(SYM_ASYNC_ITERATOR, PROMISE_CONSTRUCTOR);
+const createAsyncIterable = /* @__PURE__ */ ASYNC_ITERATOR_CONSTRUCTOR(SYM_ASYNC_ITERATOR, PROMISE_CONSTRUCTOR);
 function streamToAsyncIterable(stream) {
 	return createAsyncIterable(stream);
 }
@@ -921,20 +1071,158 @@ async function promiseToResult(current) {
 	}
 }
 //#endregion
+//#region src/core/binary-browser.ts
+function encodeArrayBuffer$1(current) {
+	const bytes = new Uint8Array(current);
+	if (typeof bytes.toBase64 === "function") return bytes.toBase64();
+	let result = "";
+	for (let i = 0, len = bytes.length; i < len; i++) result += String.fromCharCode(bytes[i]);
+	return btoa(result);
+}
+//#endregion
+//#region src/core/binary-neutral.ts
+const MIN_NATIVE_BASE64_LENGTH = 512;
+function encodeArrayBuffer(current) {
+	if (typeof Buffer !== "undefined") return Buffer.from(current).toString("base64");
+	return encodeArrayBuffer$1(current);
+}
+function decodeArrayBuffer(source) {
+	if (source.length < MIN_NATIVE_BASE64_LENGTH || typeof Buffer === "undefined") return ARRAY_BUFFER_CONSTRUCTOR(source);
+	const decoded = atob(source);
+	const buffer = new ArrayBuffer(decoded.length);
+	Buffer.from(buffer).write(decoded, "latin1");
+	return buffer;
+}
+//#endregion
+//#region src/core/plugin.ts
+let SerovalMode = /* @__PURE__ */ function(SerovalMode) {
+	SerovalMode[SerovalMode["Vanilla"] = 1] = "Vanilla";
+	SerovalMode[SerovalMode["Cross"] = 2] = "Cross";
+	return SerovalMode;
+}({});
+function createPlugin(plugin) {
+	return plugin;
+}
+function dedupePlugins(deduped, plugins) {
+	for (let i = 0, len = plugins.length; i < len; i++) {
+		const current = plugins[i];
+		if (!deduped.has(current)) {
+			deduped.add(current);
+			if (current.extends) dedupePlugins(deduped, current.extends);
+		}
+	}
+}
+const RESOLVED_PLUGINS = /* @__PURE__ */ new WeakMap();
+function matchResolved(resolved, plugins, added) {
+	for (let i = 0, len = plugins.length; i < len; i++) {
+		const current = plugins[i];
+		if (current === resolved[added]) {
+			added++;
+			if (current.extends) {
+				added = matchResolved(resolved, current.extends, added);
+				if (added === -1) return -1;
+			}
+		} else {
+			const index = resolved.indexOf(current);
+			if (index === -1 || index >= added) return -1;
+		}
+	}
+	return added;
+}
+function resolvePlugins(plugins) {
+	if (plugins) {
+		const cached = RESOLVED_PLUGINS.get(plugins);
+		if (cached && matchResolved(cached, plugins, 0) === cached.length) return cached;
+		const deduped = /* @__PURE__ */ new Set();
+		dedupePlugins(deduped, plugins);
+		const resolved = [...deduped];
+		RESOLVED_PLUGINS.set(plugins, resolved);
+		return resolved;
+	}
+}
+/**
+* Returns the plugins that are tested for plain objects. It is the same array
+* when no plugin sets `skipPlainObjects`.
+*/
+function getPlainObjectPlugins(plugins) {
+	if (plugins) {
+		for (let i = 0, len = plugins.length; i < len; i++) if (plugins[i].skipPlainObjects) {
+			const result = plugins.filter((plugin) => !plugin.skipPlainObjects);
+			return result.length ? result : void 0;
+		}
+	}
+	return plugins;
+}
+//#endregion
+//#region src/core/keys.ts
+const REFERENCES_KEY = "__SEROVAL_REFS__";
+const GLOBAL_CONTEXT_R = `self.\$R`;
+function getCrossReferenceHeader(id) {
+	if (id == null) return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
+	return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(id)}"]=[]`;
+}
+//#endregion
+//#region src/core/reference.ts
+const REFERENCE = /* @__PURE__ */ new Map();
+const INV_REFERENCE = /* @__PURE__ */ new Map();
+let installed = false;
+function getGlobalObject() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof window !== "undefined") return window;
+	if (typeof self !== "undefined") return self;
+	if (typeof global !== "undefined") return global;
+}
+function installReferenceStore() {
+	if (!installed) {
+		installed = true;
+		const globalObject = getGlobalObject();
+		if (globalObject) Object.defineProperty(globalObject, REFERENCES_KEY, {
+			value: INV_REFERENCE,
+			configurable: true,
+			writable: false,
+			enumerable: false
+		});
+	}
+}
+function createReference(id, value) {
+	installReferenceStore();
+	REFERENCE.set(value, id);
+	INV_REFERENCE.set(id, value);
+	return value;
+}
+function hasReference(id) {
+	return INV_REFERENCE.has(id);
+}
+function getReferenceID(value) {
+	return REFERENCE.get(value);
+}
+function getReference(id) {
+	if (hasReference(id)) return INV_REFERENCE.get(id);
+	throw new SerovalMissingReferenceForIdError(id);
+}
+//#endregion
 //#region src/core/context/parser.ts
-function createBaseParserContext(mode, options) {
-	var _options$compactArray;
+function createBaseParserContext(options) {
 	return {
 		plugins: options.plugins,
-		mode,
+		plainObjectPlugins: getPlainObjectPlugins(options.plugins),
 		marked: /* @__PURE__ */ new Set(),
-		features: 127 ^ (options.disabledFeatures || 0),
-		refs: options.refs || /* @__PURE__ */ new Map(),
+		features: 127 ^ (options.disabledFeatures ?? 0),
+		refs: options.refs ?? /* @__PURE__ */ new Map(),
 		depthLimit: options.depthLimit || 1e3,
-		compactArrayBufferViews: (_options$compactArray = options.compactArrayBufferViews) !== null && _options$compactArray !== void 0 ? _options$compactArray : false
+		compactArrayBufferViews: options.compactArrayBufferViews ?? false
 	};
 }
 /**
+* Returns the plugins to test for an object. Plain objects, whose prototype is
+* `Object.prototype`, skip the plugins that set `skipPlainObjects`. Checking
+* the prototype as well as `constructor` keeps instances whose prototype has
+* no own `constructor` property from skipping those plugins.
+*/
+function getObjectPlugins(ctx, current, currentClass) {
+	return currentClass === Object && Object.getPrototypeOf(current) === Object.prototype ? ctx.plainObjectPlugins : ctx.plugins;
+}
+/**
 * Ensures that the value (based on an identifier) has been visited by the parser.
 * @param ctx
 * @param id
@@ -956,125 +1244,166 @@ function getNodeForIndexedValue(ctx, current) {
 	const registeredId = ctx.refs.get(current);
 	if (registeredId != null) {
 		markParserRef(ctx, registeredId);
-		return {
-			type: 1,
-			value: createIndexedValueNode(registeredId)
-		};
+		return createIndexedValueNode(registeredId);
 	}
-	return {
-		type: 0,
-		value: createIndexForValue(ctx, current)
-	};
+	return createIndexForValue(ctx, current);
 }
 function getReferenceNode(ctx, current) {
 	const indexed = getNodeForIndexedValue(ctx, current);
-	if (indexed.type === 1) return indexed;
-	if (hasReferenceID(current)) return {
-		type: 2,
-		value: createReferenceNode(indexed.value, current)
-	};
-	return indexed;
+	if (typeof indexed !== "number") return indexed;
+	const referenceId = getReferenceID(current);
+	return referenceId === void 0 ? indexed : createReferenceNode(indexed, referenceId);
 }
 /**
 * Parsing methods
 */
 function parseWellKnownSymbol(ctx, current) {
 	const ref = getReferenceNode(ctx, current);
-	if (ref.type !== 0) return ref.value;
-	if (current in INV_SYMBOL_REF) return createWKSymbolNode(ref.value, current);
+	if (typeof ref !== "number") return ref;
+	if (current in INV_SYMBOL_REF) return createWKSymbolNode(ref, current);
 	throw new SerovalUnsupportedTypeError(current);
 }
 function parseSpecialReference(ctx, ref) {
 	const result = getNodeForIndexedValue(ctx, SPECIAL_REFS[ref]);
-	if (result.type === 1) return result.value;
-	return createSerovalNode(26, result.value, ref, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+	if (typeof result !== "number") return result;
+	return createSerovalNode(26, result, ref);
 }
 function parseIteratorFactory(ctx) {
 	const result = getNodeForIndexedValue(ctx, ITERATOR);
-	if (result.type === 1) return result.value;
-	return createSerovalNode(27, result.value, void 0, void 0, void 0, void 0, void 0, void 0, parseWellKnownSymbol(ctx, SYM_ITERATOR), void 0, void 0, void 0);
+	if (typeof result !== "number") return result;
+	return createSerovalNode(27, result, void 0, void 0, void 0, void 0, void 0, void 0, parseWellKnownSymbol(ctx, SYM_ITERATOR));
 }
 function parseAsyncIteratorFactory(ctx) {
 	const result = getNodeForIndexedValue(ctx, ASYNC_ITERATOR);
-	if (result.type === 1) return result.value;
-	return createSerovalNode(29, result.value, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(ctx, 1), parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR)], void 0, void 0, void 0, void 0);
+	if (typeof result !== "number") return result;
+	return createSerovalNode(29, result, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(ctx, 1), parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR)]);
 }
-function createObjectNode(id, current, empty, record) {
-	return createSerovalNode(empty ? 11 : 10, id, void 0, void 0, void 0, record, void 0, void 0, void 0, void 0, getObjectFlag(current), void 0);
+function getTemporalType(currentClass) {
+	switch (currentClass) {
+		case Temporal.Instant: return 0;
+		case Temporal.Duration: return 1;
+		case Temporal.PlainDate: return 2;
+		case Temporal.PlainDateTime: return 3;
+		case Temporal.PlainMonthDay: return 4;
+		case Temporal.PlainTime: return 5;
+		case Temporal.PlainYearMonth: return 6;
+		case Temporal.ZonedDateTime: return 7;
+		default: return;
+	}
+}
+function getObjectClass(current) {
+	const currentClass = current.constructor;
+	if (currentClass !== void 0 && typeof currentClass !== "function") {
+		const proto = Object.getPrototypeOf(current);
+		return proto === null ? void 0 : proto.constructor;
+	}
+	return currentClass;
 }
 /**
-* Gets the sentinel node for a Map. Call it before parsing the entries, so
-* that an outer Map declares the sentinel before any Map inside it uses it.
+* Decides how an object is parsed. Shared by the sync, stream and async
+* parsers so the class checks and feature gates live in one place.
 */
-function parseMapSentinel(ctx) {
-	return parseSpecialReference(ctx, 0);
-}
+function getObjectKind(current, currentClass, features) {
+	switch (currentClass) {
+		case Object: return 1;
+		case void 0: return 2;
+		case Date: return 3;
+		case Error:
+		case EvalError:
+		case RangeError:
+		case ReferenceError:
+		case SyntaxError:
+		case TypeError:
+		case URIError: return 4;
+		case Number:
+		case Boolean:
+		case String:
+		case BigInt: return 6;
+		case ArrayBuffer: return 7;
+		case Int8Array:
+		case Int16Array:
+		case Int32Array:
+		case Uint8Array:
+		case Uint16Array:
+		case Uint32Array:
+		case Uint8ClampedArray:
+		case Float32Array:
+		case Float64Array: return 8;
+		case DataView: return 10;
+		case Map: return 11;
+		case Set: return 12;
+	}
+	if (currentClass === Promise || current instanceof Promise) return 13;
+	if (features & 32 && currentClass === RegExp) return 14;
+	if (features & 16 && (currentClass === BigInt64Array || currentClass === BigUint64Array)) return 9;
+	if (features & 1 && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) return 5;
+	if (features & 64 && typeof Temporal !== "undefined" && getTemporalType(currentClass) != null) return 15;
+	if (current instanceof Error) return 4;
+	if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) return 16;
+	return 0;
+}
+function createObjectNode(id, current, empty, record) {
+	return createSerovalNode(empty ? 11 : 10, id, void 0, void 0, void 0, record, void 0, void 0, void 0, void 0, getObjectFlag(current));
+}
+/**
+* Gets the sentinel node for a Map. Call it before parsing the entries, so
+* that an outer Map declares the sentinel before any Map inside it uses it.
+*/
+function parseMapSentinel(ctx) {
+	return parseSpecialReference(ctx, 0);
+}
 function createMapNode(id, sentinel, k, v) {
 	return createSerovalNode(8, id, void 0, void 0, void 0, void 0, {
 		k,
 		v
-	}, void 0, sentinel, void 0, void 0, void 0);
+	}, void 0, sentinel);
 }
 function createPromiseConstructorNode(ctx, id, resolver) {
-	return createSerovalNode(22, id, resolver, void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 1), void 0, void 0, void 0);
+	return createSerovalNode(22, id, resolver, void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 1));
 }
 function getArrayBufferView(ctx, current) {
 	if (!ctx.compactArrayBufferViews) return current;
 	const buffer = new Uint8Array(current.buffer, current.byteOffset, current.byteLength).slice().buffer;
 	return new (current instanceof DataView ? DataView : getTypedArrayConstructor(getTypedArrayName(current)))(buffer);
 }
-function encodeArrayBuffer(current) {
-	if (typeof Buffer !== "undefined") return Buffer.from(current).toString("base64");
-	const bytes = new Uint8Array(current);
-	if (typeof bytes.toBase64 === "function") return bytes.toBase64();
-	let result = "";
-	for (let i = 0, len = bytes.length; i < len; i++) result += String.fromCharCode(bytes[i]);
-	return btoa(result);
-}
 function createArrayBufferNode(ctx, id, current) {
-	return createSerovalNode(19, id, encodeArrayBuffer(current), void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 5), void 0, void 0, void 0);
+	return createSerovalNode(19, id, encodeArrayBuffer(current), void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 5));
 }
 //#endregion
 //#region src/core/context/async-parser.ts
-function createAsyncParserContext(mode, options) {
-	return {
-		base: createBaseParserContext(mode, options),
-		child: void 0
-	};
+function createAsyncParserContext(options) {
+	return { base: createBaseParserContext(options) };
 }
-var AsyncParsePluginContext = class {
-	constructor(_p, depth) {
-		this._p = _p;
-		this.depth = depth;
-	}
-	parse(current) {
-		return parseAsync(this._p, this.depth, current);
-	}
-};
 async function parseItems$1(ctx, depth, current) {
-	const nodes = [];
-	for (let i = 0, len = current.length; i < len; i++) if (i in current) nodes[i] = await parseAsync(ctx, depth, current[i]);
-	else nodes[i] = 0;
+	const len = current.length;
+	const nodes = new Array(len);
+	for (let i = 0, node; i < len; i++) if (i in current) {
+		node = parseValueAsync(ctx, depth, current[i]);
+		nodes[i] = node instanceof Promise ? await node : node;
+	} else nodes[i] = 0;
 	return nodes;
 }
 async function parseArray$1(ctx, depth, id, current) {
 	return createArrayNode(id, current, await parseItems$1(ctx, depth, current));
 }
 async function parseProperties$1(ctx, depth, properties) {
-	const entries = Object.entries(properties);
-	const keyNodes = [];
-	const valueNodes = [];
-	for (let i = 0, len = entries.length; i < len; i++) {
-		keyNodes.push(serializeString(entries[i][0]));
-		valueNodes.push(await parseAsync(ctx, depth, entries[i][1]));
+	const keys = Object.keys(properties);
+	const len = keys.length;
+	const keyNodes = new Array(len);
+	const valueNodes = new Array(len);
+	for (let i = 0, key, node; i < len; i++) {
+		key = keys[i];
+		keyNodes[i] = serializeString(key);
+		node = parseValueAsync(ctx, depth, properties[key]);
+		valueNodes[i] = node instanceof Promise ? await node : node;
 	}
 	if (SYM_ITERATOR in properties) {
 		keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));
-		valueNodes.push(createIteratorFactoryInstanceNode(parseIteratorFactory(ctx.base), await parseAsync(ctx, depth, createSequenceFromIterable(properties))));
+		valueNodes.push(createIteratorFactoryInstanceNode(28, parseIteratorFactory(ctx.base), await parseAsync(ctx, depth, createSequenceFromIterable(properties))));
 	}
 	if (SYM_ASYNC_ITERATOR in properties) {
 		keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));
-		valueNodes.push(createAsyncIteratorFactoryInstanceNode(parseAsyncIteratorFactory(ctx.base), await parseAsync(ctx, depth, createStreamFromAsyncIterable(properties))));
+		valueNodes.push(createIteratorFactoryInstanceNode(30, parseAsyncIteratorFactory(ctx.base), await parseAsyncIterable$1(ctx, depth, properties)));
 	}
 	if (SYM_TO_STRING_TAG in properties) {
 		keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));
@@ -1095,167 +1424,183 @@ async function parsePlainObject$1(ctx, depth, id, current, empty) {
 async function parseBoxed$1(ctx, depth, id, current) {
 	return createBoxedNode(id, await parseAsync(ctx, depth, current.valueOf()));
 }
-async function parseTypedArray$1(ctx, depth, id, current) {
-	current = getArrayBufferView(ctx.base, current);
-	return createTypedArrayNode(id, current, await parseAsync(ctx, depth, current.buffer));
-}
-async function parseBigIntTypedArray$1(ctx, depth, id, current) {
+async function parseView$1(ctx, depth, type, id, current) {
 	current = getArrayBufferView(ctx.base, current);
-	return createBigIntTypedArrayNode(id, current, await parseAsync(ctx, depth, current.buffer));
+	return createViewNode(type, id, current, await parseAsync(ctx, depth, current.buffer));
 }
-async function parseDataView$1(ctx, depth, id, current) {
-	current = getArrayBufferView(ctx.base, current);
-	return createDataViewNode(id, current, await parseAsync(ctx, depth, current.buffer));
-}
-async function parseError$1(ctx, depth, id, current) {
-	const options = getErrorOptions(current, ctx.base.features);
-	return createErrorNode(id, current, options ? await parseProperties$1(ctx, depth, options) : void 0);
-}
-async function parseAggregateError$1(ctx, depth, id, current) {
+async function parseError$1(ctx, depth, type, id, current) {
 	const options = getErrorOptions(current, ctx.base.features);
-	return createAggregateErrorNode(id, current, options ? await parseProperties$1(ctx, depth, options) : void 0);
+	return createErrorNode(type, id, current, options ? await parseProperties$1(ctx, depth, options) : void 0);
 }
 async function parseMap$1(ctx, depth, id, current) {
 	const sentinel = parseMapSentinel(ctx.base);
-	const keyNodes = [];
-	const valueNodes = [];
+	const keyNodes = new Array(current.size);
+	const valueNodes = new Array(current.size);
+	let node;
+	let i = 0;
 	for (const [key, value] of current.entries()) {
-		keyNodes.push(await parseAsync(ctx, depth, key));
-		valueNodes.push(await parseAsync(ctx, depth, value));
+		node = parseValueAsync(ctx, depth, key);
+		keyNodes[i] = node instanceof Promise ? await node : node;
+		node = parseValueAsync(ctx, depth, value);
+		valueNodes[i] = node instanceof Promise ? await node : node;
+		i++;
 	}
 	return createMapNode(id, sentinel, keyNodes, valueNodes);
 }
 async function parseSet$1(ctx, depth, id, current) {
-	const items = [];
-	for (const item of current.keys()) items.push(await parseAsync(ctx, depth, item));
+	const items = new Array(current.size);
+	let node;
+	let i = 0;
+	for (const item of current.keys()) {
+		node = parseValueAsync(ctx, depth, item);
+		items[i++] = node instanceof Promise ? await node : node;
+	}
 	return createSetNode(id, items);
 }
-async function parsePlugin$1(ctx, depth, id, current) {
-	const currentPlugins = ctx.base.plugins;
+async function parsePlugin$1(ctx, depth, id, current, currentPlugins) {
 	if (currentPlugins) for (let i = 0, len = currentPlugins.length; i < len; i++) {
 		const plugin = currentPlugins[i];
-		if (plugin.parse.async && plugin.test(current)) return createPluginNode(id, plugin.tag, await plugin.parse.async(current, new AsyncParsePluginContext(ctx, depth), { id }));
+		if (plugin.parse.async && plugin.test(current)) return createPluginNode(id, plugin.tag, await plugin.parse.async(current, {
+			parse: (value) => parseAsync(ctx, depth, value),
+			parseStreamSource(source) {
+				if (depth >= ctx.base.depthLimit) throw new SerovalDepthLimitError(ctx.base.depthLimit);
+				return parseAsyncIterable$1(ctx, depth + 1, source);
+			}
+		}, { id }));
 	}
 }
 async function parsePromise$1(ctx, depth, id, current) {
 	const [status, result] = await promiseToResult(current);
-	return createSerovalNode(12, id, status, void 0, void 0, void 0, void 0, void 0, await parseAsync(ctx, depth, result), void 0, void 0, void 0);
+	return createSerovalNode(12, id, status, void 0, void 0, void 0, void 0, void 0, await parseAsync(ctx, depth, result));
 }
 function parseStreamHandle(depth, id, current, resolve, reject) {
 	const sequence = [];
-	const cleanup = current.on({
-		next: (value) => {
-			markParserRef(this.base, id);
-			parseAsync(this, depth, value).then((data) => {
-				sequence.push(createStreamNextNode(id, data));
-			}, (data) => {
-				reject(data);
-				cleanup();
-			});
-		},
-		throw: (value) => {
-			markParserRef(this.base, id);
-			parseAsync(this, depth, value).then((data) => {
-				sequence.push(createStreamThrowNode(id, data));
-				resolve(sequence);
-				cleanup();
-			}, (data) => {
-				reject(data);
-				cleanup();
-			});
-		},
-		return: (value) => {
-			markParserRef(this.base, id);
-			parseAsync(this, depth, value).then((data) => {
-				sequence.push(createStreamReturnNode(id, data));
-				resolve(sequence);
-				cleanup();
-			}, (data) => {
-				reject(data);
-				cleanup();
-			});
+	let unparsed = 0;
+	let ended = false;
+	let settled = false;
+	const fail = (error) => {
+		if (!settled) {
+			settled = true;
+			try {
+				cleanup(error);
+			} catch {}
+			reject(error);
 		}
-	});
+	};
+	const handle = (type) => (value, accept) => {
+		if (settled) return;
+		markParserRef(this.base, id);
+		const slot = sequence.push(void 0) - 1;
+		unparsed++;
+		if (type !== 32) ended = true;
+		parseAsync(this, depth, value).then((data) => {
+			if (!settled) {
+				sequence[slot] = createStreamEventNode(type, id, data);
+				unparsed--;
+				accept?.();
+				if (ended && unparsed === 0) {
+					settled = true;
+					try {
+						cleanup();
+					} catch (error) {
+						reject(error);
+						return;
+					}
+					resolve(sequence);
+				}
+			}
+		}, fail);
+	};
+	const listener = {
+		next: handle(32),
+		throw: handle(33),
+		return: handle(34)
+	};
+	const cleanup = isLiveStream(current) ? current.pump(listener) : current.on(listener);
 }
 async function parseStream$1(ctx, depth, id, current) {
 	return createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), await new Promise(parseStreamHandle.bind(ctx, depth, id, current)));
 }
+/**
+* Collects an async iterable into a replay node, one value at a time.
+*/
+async function parseAsyncIterable$1(ctx, depth, current) {
+	const id = createIndexForValue(ctx.base, {});
+	const reference = parseSpecialReference(ctx.base, 4);
+	const iterator = current[SYM_ASYNC_ITERATOR]();
+	const sequence = [];
+	for (;;) {
+		let result;
+		try {
+			result = await iterator.next();
+		} catch (error) {
+			markParserRef(ctx.base, id);
+			sequence.push(createStreamEventNode(33, id, await parseAsync(ctx, depth, error)));
+			break;
+		}
+		markParserRef(ctx.base, id);
+		let parsed;
+		try {
+			parsed = await parseAsync(ctx, depth, result.value);
+		} catch (error) {
+			Promise.resolve().then(() => iterator.return?.()).catch(() => {});
+			throw error;
+		}
+		sequence.push(createStreamEventNode(result.done ? 34 : 32, id, parsed));
+		if (result.done) break;
+	}
+	return createStreamConstructorNode(id, reference, sequence);
+}
 async function parseSequence$1(ctx, depth, id, current) {
-	const nodes = [];
-	for (let i = 0, len = current.v.length; i < len; i++) nodes[i] = await parseAsync(ctx, depth, current.v[i]);
+	const len = current.v.length;
+	const nodes = new Array(len);
+	for (let i = 0, node; i < len; i++) {
+		node = parseValueAsync(ctx, depth, current.v[i]);
+		nodes[i] = node instanceof Promise ? await node : node;
+	}
 	return createSequenceNode(id, nodes, current.t, current.d);
 }
 async function parseObjectAsync(ctx, depth, id, current) {
 	if (Array.isArray(current)) return parseArray$1(ctx, depth, id, current);
 	if (isStream(current)) return parseStream$1(ctx, depth, id, current);
 	if (isSequence(current)) return parseSequence$1(ctx, depth, id, current);
-	let currentClass = current.constructor;
-	if (currentClass !== void 0 && typeof currentClass !== "function") {
-		const proto = Object.getPrototypeOf(current);
-		currentClass = proto === null ? void 0 : proto.constructor;
-	}
+	const currentClass = getObjectClass(current);
 	if (currentClass === OpaqueReference) return parseAsync(ctx, depth, current.replacement);
-	const parsed = await parsePlugin$1(ctx, depth, id, current);
+	const parsed = await parsePlugin$1(ctx, depth, id, current, getObjectPlugins(ctx.base, current, currentClass));
 	if (parsed) return parsed;
-	switch (currentClass) {
-		case Object: return parsePlainObject$1(ctx, depth, id, current, false);
-		case void 0: return parsePlainObject$1(ctx, depth, id, current, true);
-		case Date: return createDateNode(id, current);
-		case Error:
-		case EvalError:
-		case RangeError:
-		case ReferenceError:
-		case SyntaxError:
-		case TypeError:
-		case URIError: return parseError$1(ctx, depth, id, current);
-		case Number:
-		case Boolean:
-		case String:
-		case BigInt: return parseBoxed$1(ctx, depth, id, current);
-		case ArrayBuffer: return createArrayBufferNode(ctx.base, id, current);
-		case Int8Array:
-		case Int16Array:
-		case Int32Array:
-		case Uint8Array:
-		case Uint16Array:
-		case Uint32Array:
-		case Uint8ClampedArray:
-		case Float32Array:
-		case Float64Array: return parseTypedArray$1(ctx, depth, id, current);
-		case DataView: return parseDataView$1(ctx, depth, id, current);
-		case Map: return parseMap$1(ctx, depth, id, current);
-		case Set: return parseSet$1(ctx, depth, id, current);
-	}
-	if (currentClass === Promise || current instanceof Promise) return parsePromise$1(ctx, depth, id, current);
-	const currentFeatures = ctx.base.features;
-	if (currentFeatures & 32 && currentClass === RegExp) return createRegExpNode(id, current);
-	if (currentFeatures & 16) switch (currentClass) {
-		case BigInt64Array:
-		case BigUint64Array: return parseBigIntTypedArray$1(ctx, depth, id, current);
-	}
-	if (currentFeatures & 1 && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) return parseAggregateError$1(ctx, depth, id, current);
-	if (currentFeatures & 64 && typeof Temporal !== "undefined") switch (currentClass) {
-		case Temporal.Instant: return createTemporalNode(id, 0, current);
-		case Temporal.Duration: return createTemporalNode(id, 1, current);
-		case Temporal.PlainDate: return createTemporalNode(id, 2, current);
-		case Temporal.PlainDateTime: return createTemporalNode(id, 3, current);
-		case Temporal.PlainMonthDay: return createTemporalNode(id, 4, current);
-		case Temporal.PlainTime: return createTemporalNode(id, 5, current);
-		case Temporal.PlainYearMonth: return createTemporalNode(id, 6, current);
-		case Temporal.ZonedDateTime: return createTemporalNode(id, 7, current);
-	}
-	if (current instanceof Error) return parseError$1(ctx, depth, id, current);
-	if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) return parsePlainObject$1(ctx, depth, id, current, !!currentClass);
-	throw new SerovalUnsupportedTypeError(current);
+	if (currentClass === Object) return parsePlainObject$1(ctx, depth, id, current, false);
+	switch (getObjectKind(current, currentClass, ctx.base.features)) {
+		case 2: return parsePlainObject$1(ctx, depth, id, current, true);
+		case 3: return createDateNode(id, current);
+		case 4: return parseError$1(ctx, depth, 13, id, current);
+		case 5: return parseError$1(ctx, depth, 14, id, current);
+		case 6: return parseBoxed$1(ctx, depth, id, current);
+		case 7: return createArrayBufferNode(ctx.base, id, current);
+		case 8: return parseView$1(ctx, depth, 15, id, current);
+		case 9: return parseView$1(ctx, depth, 16, id, current);
+		case 10: return parseView$1(ctx, depth, 20, id, current);
+		case 11: return parseMap$1(ctx, depth, id, current);
+		case 12: return parseSet$1(ctx, depth, id, current);
+		case 13: return parsePromise$1(ctx, depth, id, current);
+		case 14: return createRegExpNode(id, current);
+		case 15: return createTemporalNode(id, getTemporalType(currentClass), current);
+		case 16: return parsePlainObject$1(ctx, depth, id, current, !!currentClass);
+		default: throw new SerovalUnsupportedTypeError(current);
+	}
 }
 async function parseFunctionAsync(ctx, depth, current) {
 	const ref = getReferenceNode(ctx.base, current);
-	if (ref.type !== 0) return ref.value;
-	const plugin = await parsePlugin$1(ctx, depth, ref.value, current);
+	if (typeof ref !== "number") return ref;
+	const plugin = await parsePlugin$1(ctx, depth, ref, current, ctx.base.plugins);
 	if (plugin) return plugin;
 	throw new SerovalUnsupportedTypeError(current);
 }
-async function parseAsync(ctx, depth, current) {
+/**
+* Parses primitives and already-seen values synchronously; only objects and
+* functions come back as a Promise. Errors are thrown synchronously, which
+* an async caller turns into a rejection as before.
+*/
+function parseValueAsync(ctx, depth, current) {
 	if (depth >= ctx.base.depthLimit) throw new SerovalDepthLimitError(ctx.base.depthLimit);
 	switch (typeof current) {
 		case "boolean": return current ? TRUE_NODE : FALSE_NODE;
@@ -1266,7 +1611,7 @@ async function parseAsync(ctx, depth, current) {
 		case "object":
 			if (current) {
 				const ref = getReferenceNode(ctx.base, current);
-				return ref.type === 0 ? await parseObjectAsync(ctx, depth + 1, ref.value, current) : ref.value;
+				return typeof ref === "number" ? parseObjectAsync(ctx, depth + 1, ref, current) : ref;
 			}
 			return NULL_NODE;
 		case "symbol": return parseWellKnownSymbol(ctx.base, current);
@@ -1274,6 +1619,9 @@ async function parseAsync(ctx, depth, current) {
 		default: throw new SerovalUnsupportedTypeError(current);
 	}
 }
+async function parseAsync(ctx, depth, current) {
+	return await parseValueAsync(ctx, depth, current);
+}
 async function parseTopAsync(ctx, current) {
 	try {
 		return await parseAsync(ctx, 0, current);
@@ -1282,32 +1630,6 @@ async function parseTopAsync(ctx, current) {
 	}
 }
 //#endregion
-//#region src/core/plugin.ts
-let SerovalMode = /* @__PURE__ */ function(SerovalMode) {
-	SerovalMode[SerovalMode["Vanilla"] = 1] = "Vanilla";
-	SerovalMode[SerovalMode["Cross"] = 2] = "Cross";
-	return SerovalMode;
-}({});
-function createPlugin(plugin) {
-	return plugin;
-}
-function dedupePlugins(deduped, plugins) {
-	for (let i = 0, len = plugins.length; i < len; i++) {
-		const current = plugins[i];
-		if (!deduped.has(current)) {
-			deduped.add(current);
-			if (current.extends) dedupePlugins(deduped, current.extends);
-		}
-	}
-}
-function resolvePlugins(plugins) {
-	if (plugins) {
-		const deduped = /* @__PURE__ */ new Set();
-		dedupePlugins(deduped, plugins);
-		return [...deduped];
-	}
-}
-//#endregion
 //#region src/core/utils/valid-properties.ts
 function isValidKey(key) {
 	switch (key) {
@@ -1333,7 +1655,6 @@ function isValidSymbol(symbol) {
 //#endregion
 //#region src/core/context/deserializer.ts
 const DEFAULT_MAX_BASE64_LENGTH = 1e6;
-const MIN_NATIVE_BASE64_LENGTH = 512;
 const MAX_BIGINT_LENGTH = 1e4;
 const MAX_REGEXP_SOURCE_LENGTH = 2e4;
 function applyObjectFlag(obj, flag) {
@@ -1345,68 +1666,50 @@ function applyObjectFlag(obj, flag) {
 	}
 }
 const DEFAULT_DEPTH_LIMIT = 1e3;
-function createBaseDeserializerContext(mode, options) {
-	var _options$maxBase64Len, _options$features;
-	const maxBase64Length = (_options$maxBase64Len = options.maxBase64Length) !== null && _options$maxBase64Len !== void 0 ? _options$maxBase64Len : DEFAULT_MAX_BASE64_LENGTH;
+function createBaseDeserializerContext(options) {
+	const maxBase64Length = options.maxBase64Length ?? DEFAULT_MAX_BASE64_LENGTH;
 	if (!Number.isSafeInteger(maxBase64Length) || maxBase64Length < 0) throw new RangeError("maxBase64Length must be a non-negative safe integer");
-	const refs = options.refs || /* @__PURE__ */ new Map();
+	const refs = options.refs ?? /* @__PURE__ */ new Map();
 	if (!("types" in refs)) Object.assign(refs, { types: /* @__PURE__ */ new Map() });
 	return {
-		mode,
 		plugins: options.plugins,
 		refs,
-		features: (_options$features = options.features) !== null && _options$features !== void 0 ? _options$features : 127 ^ (options.disabledFeatures || 0),
+		features: options.features ?? 127 ^ (options.disabledFeatures ?? 0),
 		depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT,
 		maxBase64Length
 	};
 }
 function createVanillaDeserializerContext(options) {
 	return {
-		mode: 1,
-		base: createBaseDeserializerContext(1, options),
-		child: void 0,
-		state: { marked: new Set(options.markedRefs) }
+		base: createBaseDeserializerContext(options),
+		marked: new Set(options.markedRefs)
 	};
 }
 function createCrossDeserializerContext(options) {
 	return {
-		mode: 2,
-		base: createBaseDeserializerContext(2, options),
-		child: void 0
+		base: createBaseDeserializerContext(options),
+		marked: void 0
 	};
 }
-var DeserializePluginContext = class {
-	constructor(_p, depth) {
-		this._p = _p;
-		this.depth = depth;
-	}
-	deserialize(node) {
-		return deserialize$1(this._p, this.depth, node);
-	}
-};
 function guardIndexedValue(ctx, id) {
-	if (id < 0 || !Number.isFinite(id) || !Number.isInteger(id)) throw new SerovalMalformedNodeError({
+	const node = {
 		t: 4,
 		i: id
-	});
-	if (ctx.refs.has(id)) throw new Error("Conflicted ref id: " + id);
+	};
+	if (id < 0 || !Number.isInteger(id)) throw new SerovalMalformedNodeError(node);
+	if (ctx.refs.has(id)) throw new SerovalConflictedNodeIdError(node);
 }
 function isThennable(value) {
 	return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
 }
-function assignIndexedValueVanilla(ctx, id, value) {
-	guardIndexedValue(ctx.base, id);
-	if (ctx.state.marked.has(id)) ctx.base.refs.set(id, value);
-	return value;
-}
-function assignIndexedValueCross(ctx, id, value) {
+const ignoreRejection = () => {};
+function assignIndexedValue$1(ctx, id, value) {
 	guardIndexedValue(ctx.base, id);
-	ctx.base.refs.set(id, value);
+	if (ctx.base.pending && value instanceof Promise) value.catch(ignoreRejection);
+	const marked = ctx.marked;
+	if (!marked || marked.has(id)) ctx.base.refs.set(id, value);
 	return value;
 }
-function assignIndexedValue$1(ctx, id, value) {
-	return ctx.mode === 1 ? assignIndexedValueVanilla(ctx, id, value) : assignIndexedValueCross(ctx, id, value);
-}
 function deserializeKnownValue(node, record, key) {
 	if (Object.hasOwn(record, key)) return record[key];
 	throw new SerovalMalformedNodeError(node);
@@ -1463,7 +1766,8 @@ function deserializeProperties(ctx, depth, node, result) {
 	const keys = node.k;
 	validateNodeList(node, keys);
 	validateNodeList(node, node.v);
-	if (keys.length > 0) for (let i = 0, vals = node.v, len = keys.length; i < len; i++) assignProperty(ctx, depth, result, keys[i], vals[i]);
+	const len = keys.length;
+	if (len > 0) for (let i = 0, vals = node.v; i < len; i++) assignProperty(ctx, depth, result, keys[i], vals[i]);
 	return result;
 }
 function deserializeObject(ctx, depth, node) {
@@ -1477,35 +1781,8 @@ function deserializeDate(ctx, node) {
 }
 function deserializeTemporal(ctx, node) {
 	if (!(ctx.base.features & 64)) throw new SerovalUnsupportedNodeError(node);
-	let value;
-	switch (node.c) {
-		case 0:
-			value = Temporal.Instant.from(node.s);
-			break;
-		case 1:
-			value = Temporal.Duration.from(node.s);
-			break;
-		case 2:
-			value = Temporal.PlainDate.from(node.s);
-			break;
-		case 3:
-			value = Temporal.PlainDateTime.from(node.s);
-			break;
-		case 4:
-			value = Temporal.PlainMonthDay.from(node.s);
-			break;
-		case 5:
-			value = Temporal.PlainTime.from(node.s);
-			break;
-		case 6:
-			value = Temporal.PlainYearMonth.from(node.s);
-			break;
-		case 7:
-			value = Temporal.ZonedDateTime.from(node.s);
-			break;
-		default: throw new SerovalMalformedNodeError(node);
-	}
-	return assignIndexedValue$1(ctx, node.i, value);
+	const construct = Temporal[deserializeKnownValue(node, TEMPORAL_TYPE_NAME, node.c)];
+	return assignIndexedValue$1(ctx, node.i, construct.from(node.s));
 }
 function deserializeRegExp(ctx, node) {
 	if (ctx.base.features & 32) {
@@ -1531,32 +1808,15 @@ function deserializeMap(ctx, depth, node) {
 function deserializeArrayBuffer(ctx, node) {
 	if (typeof node.s !== "string") throw new SerovalMalformedNodeError(node);
 	if (node.s.length > ctx.base.maxBase64Length) throw new RangeError("ArrayBuffer exceeds maxBase64Length (" + ctx.base.maxBase64Length + ")");
-	const source = deserializeString(node.s);
-	let buffer;
-	if (source.length < MIN_NATIVE_BASE64_LENGTH || typeof Buffer === "undefined") buffer = ARRAY_BUFFER_CONSTRUCTOR(source);
-	else {
-		const decoded = atob(source);
-		buffer = new ArrayBuffer(decoded.length);
-		Buffer.from(buffer).write(decoded, "latin1");
-	}
+	const buffer = decodeArrayBuffer(deserializeString(node.s));
 	return assignIndexedValue$1(ctx, node.i, buffer);
 }
-function deserializeTypedArray(ctx, depth, node) {
-	var _node$b;
-	const construct = getTypedArrayConstructor(node.c);
+function deserializeView(ctx, depth, node, construct) {
 	const source = deserialize$1(ctx, depth, node.f);
 	if (!(source instanceof ArrayBuffer)) throw new SerovalMalformedNodeError(node);
-	const offset = (_node$b = node.b) !== null && _node$b !== void 0 ? _node$b : 0;
+	const offset = node.b ?? 0;
 	if (offset < 0 || offset > source.byteLength) throw new SerovalMalformedNodeError(node);
-	return assignIndexedValue$1(ctx, node.i, new construct(source, offset, node.l));
-}
-function deserializeDataView(ctx, depth, node) {
-	var _node$b2;
-	const source = deserialize$1(ctx, depth, node.f);
-	if (!(source instanceof ArrayBuffer)) throw new SerovalMalformedNodeError(node);
-	const offset = (_node$b2 = node.b) !== null && _node$b2 !== void 0 ? _node$b2 : 0;
-	if (offset < 0 || offset > source.byteLength) throw new SerovalMalformedNodeError(node);
-	return assignIndexedValue$1(ctx, node.i, new DataView(source, offset, node.l));
+	return assignIndexedValue$1(ctx, node.i, construct ? new construct(source, offset, node.l) : new DataView(source, offset, node.l));
 }
 function deserializeDictionary(ctx, depth, node, result) {
 	if (node.p) {
@@ -1590,7 +1850,7 @@ function deserializePlugin(ctx, depth, node) {
 		const tag = deserializeString(node.c);
 		for (let i = 0, len = currentPlugins.length; i < len; i++) {
 			const plugin = currentPlugins[i];
-			if (plugin.tag === tag) return assignIndexedValue$1(ctx, node.i, plugin.deserialize(node.s, new DeserializePluginContext(ctx, depth), { id: node.i }));
+			if (plugin.tag === tag) return assignIndexedValue$1(ctx, node.i, plugin.deserialize(node.s, { deserialize: (current) => deserialize$1(ctx, depth, current) }, { id: node.i }));
 		}
 	}
 	throw new SerovalMissingPluginError(node.c);
@@ -1598,6 +1858,7 @@ function deserializePlugin(ctx, depth, node) {
 function deserializePromiseConstructor(ctx, node) {
 	const value = assignIndexedValue$1(ctx, node.i, assignIndexedValue$1(ctx, node.s, PROMISE_CONSTRUCTOR()).p);
 	assignNodeType(ctx, node.s, 22);
+	ctx.base.pending?.add(node.s);
 	return value;
 }
 function deserializePromiseFulfill(ctx, depth, node) {
@@ -1608,6 +1869,7 @@ function deserializePromiseFulfill(ctx, depth, node) {
 		if (isThennable(deserialized)) throw new SerovalMalformedNodeError(node.a[1]);
 		if (node.t === 23) deferred.s(deserialized);
 		else deferred.f(deserialized);
+		ctx.base.pending?.delete(node.i);
 		return;
 	}
 	throw new SerovalMissingInstanceError("Promise");
@@ -1625,37 +1887,21 @@ function deserializeAsyncIteratorFactoryInstance(ctx, depth, node) {
 	return streamToAsyncIterable(source);
 }
 function deserializeStreamConstructor(ctx, depth, node) {
-	const result = assignIndexedValue$1(ctx, node.i, createStream());
+	const result = assignIndexedValue$1(ctx, node.i, new Stream(node.l === 1 ? 1 : void 0));
 	assignNodeType(ctx, node.i, 31);
+	ctx.base.pending?.add(node.i);
 	const items = node.a;
 	validateNodeList(node, items);
 	const len = items.length;
 	if (len) for (let i = 0; i < len; i++) deserialize$1(ctx, depth, items[i]);
 	return result;
 }
-function deserializeStreamNext(ctx, depth, node) {
-	const deferred = ctx.base.refs.get(node.i);
-	if (deferred) {
-		validateNodeType(ctx, node, node.i, 31);
-		deferred.next(deserialize$1(ctx, depth, node.f));
-		return;
-	}
-	throw new SerovalMissingInstanceError("Stream");
-}
-function deserializeStreamThrow(ctx, depth, node) {
+function deserializeStreamCall(ctx, depth, node, method) {
 	const deferred = ctx.base.refs.get(node.i);
 	if (deferred) {
 		validateNodeType(ctx, node, node.i, 31);
-		deferred.throw(deserialize$1(ctx, depth, node.f));
-		return;
-	}
-	throw new SerovalMissingInstanceError("Stream");
-}
-function deserializeStreamReturn(ctx, depth, node) {
-	const deferred = ctx.base.refs.get(node.i);
-	if (deferred) {
-		validateNodeType(ctx, node, node.i, 31);
-		deferred.return(deserialize$1(ctx, depth, node.f));
+		deferred[method](deserialize$1(ctx, depth, node.f));
+		if (method !== "next") ctx.base.pending?.delete(node.i);
 		return;
 	}
 	throw new SerovalMissingInstanceError("Stream");
@@ -1674,6 +1920,7 @@ function deserializeSequence(ctx, depth, node) {
 	const size = node.a.length;
 	if (!(isSequenceIndex(node.s, size) && isSequenceIndex(node.l, size))) throw new SerovalMalformedNodeError(node);
 	const result = assignIndexedValue$1(ctx, node.i, createSequence([], node.s, node.l));
+	assignNodeType(ctx, node.i, 35);
 	for (let i = 0; i < size; i++) result.v[i] = deserialize$1(ctx, depth, node.a[i]);
 	return result;
 }
@@ -1698,8 +1945,8 @@ function deserialize$1(ctx, depth, node) {
 		case 8: return deserializeMap(ctx, depth, node);
 		case 19: return deserializeArrayBuffer(ctx, node);
 		case 16:
-		case 15: return deserializeTypedArray(ctx, depth, node);
-		case 20: return deserializeDataView(ctx, depth, node);
+		case 15: return deserializeView(ctx, depth, node, getTypedArrayConstructor(node.c));
+		case 20: return deserializeView(ctx, depth, node);
 		case 14: return deserializeAggregateError(ctx, depth, node);
 		case 13: return deserializeError(ctx, depth, node);
 		case 12: return deserializePromise(ctx, depth, node);
@@ -1712,9 +1959,9 @@ function deserialize$1(ctx, depth, node) {
 		case 28: return deserializeIteratorFactoryInstance(ctx, depth, node);
 		case 30: return deserializeAsyncIteratorFactoryInstance(ctx, depth, node);
 		case 31: return deserializeStreamConstructor(ctx, depth, node);
-		case 32: return deserializeStreamNext(ctx, depth, node);
-		case 33: return deserializeStreamThrow(ctx, depth, node);
-		case 34: return deserializeStreamReturn(ctx, depth, node);
+		case 32: return deserializeStreamCall(ctx, depth, node, "next");
+		case 33: return deserializeStreamCall(ctx, depth, node, "throw");
+		case 34: return deserializeStreamCall(ctx, depth, node, "return");
 		case 27: return deserializeIteratorFactory(ctx, depth, node);
 		case 29: return deserializeAsyncIteratorFactory(ctx, depth, node);
 		case 35: return deserializeSequence(ctx, depth, node);
@@ -1729,11 +1976,31 @@ function deserializeTop(ctx, node) {
 		throw new SerovalDeserializationError(error);
 	}
 }
+/**
+* Rejects every pending promise and throws into every open stream tracked
+* by `ctx.base.pending`, then drops the bookkeeping so the context no longer
+* accepts deferred values. Does nothing once the bookkeeping is gone.
+*/
+function abortDeferred(ctx, reason) {
+	const pending = ctx.base.pending;
+	if (pending) {
+		ctx.base.pending = void 0;
+		const refs = ctx.base.refs;
+		const errors = [];
+		for (const id of pending) try {
+			const value = refs.get(id);
+			if (refs.types.get(id) === 22) value.f(reason);
+			else value.throw(reason);
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length) throw errors[0];
+	}
+}
 //#endregion
 //#region src/core/function-string.ts
 const RETURN = () => T;
-const SERIALIZED_RETURN = /* @__PURE__ */ RETURN.toString();
-const IS_MODERN = /* @__PURE__ */ /=>/.test(SERIALIZED_RETURN);
+const IS_MODERN = /* @__PURE__ */ (/* @__PURE__ */ RETURN.toString()).includes("=>");
 function createFunction(parameters, body) {
 	if (IS_MODERN) return (parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")") + "=>" + (body.startsWith("{") ? "(" + body + ")" : body);
 	return "function(" + parameters.join(",") + "){return " + body + "}";
@@ -1761,10 +2028,13 @@ function getIdentifier(index) {
 }
 //#endregion
 //#region src/core/utils/is-valid-identifier.ts
-const 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);
+	const len = name.length;
+	for (let i = 0; i < len; i++) {
+		const code = name.charCodeAt(i);
+		if (!(code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 && i > 0 || code === 95 || code === 36)) return false;
+	}
+	return len > 0;
 }
 //#endregion
 //#region src/core/context/serializer.ts
@@ -1778,58 +2048,31 @@ function getAssignmentExpression(assignment) {
 	}
 }
 const MAX_ASSIGNMENT_CHAIN_LENGTH = 100;
-function mergeAssignments(assignments) {
-	const newAssignments = [];
-	let current = assignments[0];
+function resolveAssignments(assignments) {
+	if (!assignments.length) return void 0;
+	let previous = assignments[0];
+	let expression = getAssignmentExpression(previous);
+	let result = "";
 	let chainLength = 1;
-	for (let i = 1, len = assignments.length, item, prev = current; i < len; i++) {
-		item = assignments[i];
+	for (let index = 1, length = assignments.length; index < length; index++) {
+		const assignment = assignments[index];
 		if (chainLength === MAX_ASSIGNMENT_CHAIN_LENGTH) {
-			newAssignments.push(current);
-			current = item;
+			result += expression + ",";
+			expression = getAssignmentExpression(assignment);
 			chainLength = 0;
-		} else if (item.t === 0 && prev.t === 0 && item.v === prev.v) current = {
-			t: 0,
-			s: item.s,
-			k: void 0,
-			v: getAssignmentExpression(current)
-		};
-		else if (item.t === 2 && prev.t === 2 && item.s === prev.s) current = {
-			t: 2,
-			s: getAssignmentExpression(current),
-			k: item.k,
-			v: item.v
-		};
-		else if (item.t === 1 && prev.t === 1 && item.s === prev.s) current = {
-			t: 1,
-			s: getAssignmentExpression(current),
-			k: void 0,
-			v: item.v
-		};
-		else if (item.t === 3 && prev.t === 2 && item.s === prev.s) current = {
-			t: 3,
-			s: getAssignmentExpression(current),
-			k: item.k,
-			v: void 0
-		};
+		} else if (assignment.t === 0 && previous.t === 0 && assignment.v === previous.v) expression = assignment.s + "=" + expression;
+		else if (assignment.t === 2 && previous.t === 2 && assignment.s === previous.s) expression += ".set(" + assignment.k + "," + assignment.v + ")";
+		else if (assignment.t === 1 && previous.t === 1 && assignment.s === previous.s) expression += ".add(" + assignment.v + ")";
+		else if (assignment.t === 3 && previous.t === 2 && assignment.s === previous.s) expression += ".delete(" + assignment.k + ")";
 		else {
-			newAssignments.push(current);
-			current = item;
+			result += expression + ",";
+			expression = getAssignmentExpression(assignment);
 			chainLength = 0;
 		}
 		chainLength++;
-		prev = item;
-	}
-	newAssignments.push(current);
-	return newAssignments;
-}
-function resolveAssignments(assignments) {
-	if (assignments.length) {
-		let result = "";
-		const merged = mergeAssignments(assignments);
-		for (let i = 0, len = merged.length; i < len; i++) result += getAssignmentExpression(merged[i]) + ",";
-		return result;
+		previous = assignment;
 	}
+	return result + expression + ",";
 }
 const NULL_CONSTRUCTOR = "Object.create(null)";
 const SET_CONSTRUCTOR = "new Set";
@@ -1847,42 +2090,34 @@ function createBaseSerializerContext(mode, options) {
 		mode,
 		plugins: options.plugins,
 		features: options.features,
-		marked: new Set(options.markedRefs),
+		marked: Array.isArray(options.markedRefs) ? new Set(options.markedRefs) : options.markedRefs,
 		stack: [],
 		flags: [],
-		assignments: []
+		assignments: [],
+		assignAll: mode === 2 && !options.assignSharedRefsOnly
 	};
 }
 function createVanillaSerializerState() {
 	return {
 		valid: /* @__PURE__ */ new Map(),
-		vars: []
+		vars: [],
+		sentinels: /* @__PURE__ */ new Set()
 	};
 }
 function createVanillaSerializerContext(options) {
 	return {
 		mode: 1,
 		base: createBaseSerializerContext(1, options),
-		state: createVanillaSerializerState(),
-		child: void 0
+		state: createVanillaSerializerState()
 	};
 }
 function createCrossSerializerContext(options) {
 	return {
 		mode: 2,
 		base: createBaseSerializerContext(2, options),
-		state: options,
-		child: void 0
+		state: options
 	};
 }
-var SerializePluginContext = class {
-	constructor(_p) {
-		this._p = _p;
-	}
-	serialize(node) {
-		return serialize$1(this._p, node);
-	}
-};
 /**
 * Creates the reference param (identifier) from the given reference ID
 * Calling this function means the value has been referenced somewhere
@@ -1990,7 +2225,7 @@ function createArrayAssign(ctx, ref, index, value) {
 	createAssignment(ctx.base, getRefParam(ctx, ref) + "[" + index + "]", value);
 }
 function createObjectAssign(ctx, ref, key, value) {
-	if (!isValidKey(key)) {
+	if (key === "__proto__") {
 		ctx.base.assignments.push({
 			t: 4,
 			s: getRefParam(ctx, ref),
@@ -2008,6 +2243,15 @@ function createSequenceAssign(ctx, ref, index, value) {
 * Checks if the value is in the stack. Stack here is a reference
 * structure to know if a object is to be accessed in a TDZ.
 */
+function getKeyKind(key) {
+	const first = key.charCodeAt(0);
+	if (first >= 48 && first <= 57) {
+		const check = Number(key);
+		return check >= 0 && check.toString() === key ? 2 : 0;
+	}
+	if (key === "Infinity") return 2;
+	return isValidIdentifier(key) ? 1 : 0;
+}
 function isIndexedValueInStack(ctx, node) {
 	return node.t === 4 && ctx.stack.includes(node.i);
 }
@@ -2034,7 +2278,7 @@ function hasMarkedNode(ctx, node) {
 * it.
 */
 function assignIndexedValue(ctx, index, value) {
-	if (ctx.mode === 1 && !isSerializerRefMarked(ctx.base, index)) return value;
+	if (!ctx.base.assignAll && !isSerializerRefMarked(ctx.base, index)) return value;
 	/**
 	* In cross-reference, we have to assume that
 	* every reference are going to be referenced
@@ -2042,12 +2286,13 @@ function assignIndexedValue(ctx, index, value) {
 	* all of it into the reference array.
 	*
 	* otherwise in vanilla, we only do this if it
-	* is actually referenced
+	* is actually referenced. `assignSharedRefsOnly` gives cross-reference
+	* output the vanilla behavior.
 	*/
 	return getRefParam(ctx, index) + "=" + value;
 }
 function serializeReference(node) {
-	return "__SEROVAL_REFS__.get(\"" + node.s + "\")";
+	return REFERENCES_KEY + ".get(\"" + node.s + "\")";
 }
 function serializeArrayItem(ctx, id, item, index) {
 	if (item) {
@@ -2081,16 +2326,15 @@ function serializeArray(ctx, node) {
 }
 function serializeProperty(ctx, source, key, val) {
 	if (typeof key === "string") {
-		const check = Number(key);
-		const isIdentifier = check >= 0 && check.toString() === key || isValidIdentifier(key);
+		const kind = getKeyKind(key);
 		if (isIndexedValueInStack(ctx.base, val)) {
 			const refParam = getRefParam(ctx, val.i);
 			markSerializerRef(ctx.base, source.i);
-			if (isIdentifier && check !== check) createObjectAssign(ctx, source.i, key, refParam);
-			else createArrayAssign(ctx, source.i, isIdentifier ? key : "\"" + key + "\"", refParam);
+			if (kind === 1) createObjectAssign(ctx, source.i, key, refParam);
+			else createArrayAssign(ctx, source.i, kind === 2 ? key : "\"" + key + "\"", refParam);
 			return "";
 		}
-		if (isValidKey(key)) return (isIdentifier ? key : "\"" + key + "\"") + ":" + serialize$1(ctx, val);
+		if (key !== "__proto__") return (kind === 0 ? "\"" + key + "\"" : key) + ":" + serialize$1(ctx, val);
 		return "[\"" + key + "\"]:" + serialize$1(ctx, val);
 	}
 	return "[" + serialize$1(ctx, key) + "]:" + serialize$1(ctx, val);
@@ -2102,7 +2346,7 @@ function serializeProperties(ctx, source, record) {
 		const values = record.v;
 		ctx.base.stack.push(source.i);
 		let result = serializeProperty(ctx, source, keys[0], values[0]);
-		for (let i = 1, item = result; i < len; i++) {
+		for (let i = 1, item; i < len; i++) {
 			item = serializeProperty(ctx, source, keys[i], values[i]);
 			result += (item && result && ",") + item;
 		}
@@ -2123,18 +2367,14 @@ function serializeWithObjectAssign(ctx, source, value, serialized) {
 function serializeStringKeyAssignment(ctx, source, mainAssignments, key, value) {
 	const base = ctx.base;
 	const serialized = serialize$1(ctx, value);
-	const check = Number(key);
-	const isIdentifier = check >= 0 && check.toString() === key || isValidIdentifier(key);
-	if (isIndexedValueInStack(base, value)) {
-		if (isIdentifier && check !== check) createObjectAssign(ctx, source.i, key, serialized);
-		else createArrayAssign(ctx, source.i, isIdentifier ? key : "\"" + key + "\"", serialized);
-	} else {
-		const parentAssignment = base.assignments;
-		base.assignments = mainAssignments;
-		if (isIdentifier && check !== check) createObjectAssign(ctx, source.i, key, serialized);
-		else createArrayAssign(ctx, source.i, isIdentifier ? key : "\"" + key + "\"", serialized);
-		base.assignments = parentAssignment;
-	}
+	const parentAssignment = base.assignments;
+	if (!isIndexedValueInStack(base, value)) base.assignments = mainAssignments;
+	createKeyAssign(ctx, source.i, getKeyKind(key), key, serialized);
+	base.assignments = parentAssignment;
+}
+function createKeyAssign(ctx, ref, kind, key, value) {
+	if (kind === 1) createObjectAssign(ctx, ref, key, value);
+	else createArrayAssign(ctx, ref, kind === 2 ? key : "\"" + key + "\"", value);
 }
 function serializeAssignment(ctx, source, mainAssignments, key, value) {
 	if (typeof key === "string") serializeStringKeyAssignment(ctx, source, mainAssignments, key, value);
@@ -2165,7 +2405,7 @@ function serializeAssignments(ctx, source, node) {
 function serializeDictionary(ctx, node, init) {
 	if (node.p) {
 		const base = ctx.base;
-		if (base.features & 8) init = serializeWithObjectAssign(ctx, node, node.p, init);
+		if (base.features & 8 && !node.p.k.includes("__proto__")) init = serializeWithObjectAssign(ctx, node, node.p, init);
 		else {
 			markSerializerRef(base, node.i);
 			const assignments = serializeAssignments(ctx, node, node.p);
@@ -2181,18 +2421,8 @@ function serializeNullConstructor(ctx, node) {
 function serializeDate(node) {
 	return "new Date(\"" + node.s + "\")";
 }
-const TEMPORAL_CONSTRUCTOR = {
-	[0]: "Temporal.Instant",
-	[1]: "Temporal.Duration",
-	[2]: "Temporal.PlainDate",
-	[3]: "Temporal.PlainDateTime",
-	[4]: "Temporal.PlainMonthDay",
-	[5]: "Temporal.PlainTime",
-	[6]: "Temporal.PlainYearMonth",
-	[7]: "Temporal.ZonedDateTime"
-};
 function serializeTemporal(ctx, node) {
-	if (ctx.base.features & 64) return TEMPORAL_CONSTRUCTOR[node.c] + ".from(\"" + node.s + "\")";
+	if (ctx.base.features & 64) return "Temporal." + TEMPORAL_TYPE_NAME[node.c] + ".from(\"" + node.s + "\")";
 	throw new SerovalUnsupportedNodeError(node);
 }
 function serializeRegExp(ctx, node) {
@@ -2219,7 +2449,7 @@ function serializeSet(ctx, node) {
 	if (size > 0) {
 		ctx.base.stack.push(id);
 		let result = serializeSetItem(ctx, id, items[0]);
-		for (let i = 1, item = result; i < size; i++) {
+		for (let i = 1, item; i < size; i++) {
 			item = serializeSetItem(ctx, id, items[i]);
 			result += (item && result && ",") + item;
 		}
@@ -2228,7 +2458,7 @@ function serializeSet(ctx, node) {
 	}
 	return serialized;
 }
-function serializeMapEntry(ctx, id, key, val, sentinel) {
+function serializeMapEntry(ctx, id, key, val, getSentinel) {
 	const base = ctx.base;
 	if (isIndexedValueInStack(base, key)) {
 		const keyRef = getRefParam(ctx, key.i);
@@ -2239,6 +2469,7 @@ function serializeMapEntry(ctx, id, key, val, sentinel) {
 		}
 		if (val.t !== 4 && val.i != null && hasMarkedNode(base, val)) {
 			markSerializerRef(base, val.i);
+			const sentinel = getSentinel();
 			const serialized = "(" + serialize$1(ctx, val) + ",[" + sentinel + "," + sentinel + "])";
 			createSetAssignment(ctx, id, keyRef, getRefParam(ctx, val.i));
 			createDeleteAssignment(ctx, id, sentinel);
@@ -2255,6 +2486,7 @@ function serializeMapEntry(ctx, id, key, val, sentinel) {
 		markSerializerRef(base, id);
 		if (key.t !== 4 && key.i != null && hasMarkedNode(base, key)) {
 			markSerializerRef(base, key.i);
+			const sentinel = getSentinel();
 			const serialized = "(" + serialize$1(ctx, key) + ",[" + sentinel + "," + sentinel + "])";
 			createSetAssignment(ctx, id, getRefParam(ctx, key.i), valueRef);
 			createDeleteAssignment(ctx, id, sentinel);
@@ -2274,20 +2506,27 @@ function serializeMap(ctx, node) {
 	const size = keys.length;
 	const id = node.i;
 	const sentinel = node.f;
-	const sentinelId = getRefParam(ctx, sentinel.i);
+	let sentinelRef;
+	const getSentinel = () => {
+		if (sentinelRef == null) {
+			sentinelRef = getRefParam(ctx, sentinel.i);
+			if (ctx.mode === 1) ctx.state.sentinels.add(ctx.state.valid.get(sentinel.i));
+		}
+		return sentinelRef;
+	};
 	const base = ctx.base;
 	if (size > 0) {
 		const vals = node.e.v;
 		base.stack.push(id);
-		let result = serializeMapEntry(ctx, id, keys[0], vals[0], sentinelId);
-		for (let i = 1, item = result; i < size; i++) {
-			item = serializeMapEntry(ctx, id, keys[i], vals[i], sentinelId);
+		let result = serializeMapEntry(ctx, id, keys[0], vals[0], getSentinel);
+		for (let i = 1, item; i < size; i++) {
+			item = serializeMapEntry(ctx, id, keys[i], vals[i], getSentinel);
 			result += (item && result && ",") + item;
 		}
 		base.stack.pop();
 		if (result) serialized += "([" + result + "])";
 	}
-	if (sentinel.t === 26) {
+	if (ctx.mode === 2 && sentinel.t === 26) {
 		markSerializerRef(base, sentinel.i);
 		serialized = "(" + serialize$1(ctx, sentinel) + "," + serialized + ")";
 	}
@@ -2296,11 +2535,8 @@ function serializeMap(ctx, node) {
 function serializeArrayBuffer(ctx, node) {
 	return getConstructor(ctx, node.f) + "(\"" + node.s + "\")";
 }
-function serializeTypedArray(ctx, node) {
-	return "new " + node.c + "(" + serialize$1(ctx, node.f) + "," + node.b + "," + node.l + ")";
-}
-function serializeDataView(ctx, node) {
-	return "new DataView(" + serialize$1(ctx, node.f) + "," + node.b + "," + node.l + ")";
+function serializeView(ctx, node) {
+	return "new " + (node.t === 20 ? "DataView" : node.c) + "(" + serialize$1(ctx, node.f) + "," + node.b + "," + node.l + ")";
 }
 function serializeAggregateError(ctx, node) {
 	const id = node.i;
@@ -2340,11 +2576,7 @@ function serializePromiseConstructor(ctx, node) {
 	if (ctx.mode === 1) throw new SerovalUnsupportedNodeError(node);
 	return "(" + assignIndexedValue(ctx, node.s, getConstructor(ctx, node.f) + "()") + ").p";
 }
-function serializePromiseResolve(ctx, node) {
-	if (ctx.mode === 1) throw new SerovalUnsupportedNodeError(node);
-	return getConstructor(ctx, node.a[0]) + "(" + getRefParam(ctx, node.i) + "," + serialize$1(ctx, node.a[1]) + ")";
-}
-function serializePromiseReject(ctx, node) {
+function serializePromiseResult(ctx, node) {
 	if (ctx.mode === 1) throw new SerovalUnsupportedNodeError(node);
 	return getConstructor(ctx, node.a[0]) + "(" + getRefParam(ctx, node.i) + "," + serialize$1(ctx, node.a[1]) + ")";
 }
@@ -2352,10 +2584,7 @@ function serializePlugin(ctx, node) {
 	const currentPlugins = ctx.base.plugins;
 	if (currentPlugins) for (let i = 0, len = currentPlugins.length; i < len; i++) {
 		const plugin = currentPlugins[i];
-		if (plugin.tag === node.c) {
-			if (ctx.child == null) ctx.child = new SerializePluginContext(ctx);
-			return plugin.serialize(node.s, ctx.child, { id: node.i });
-		}
+		if (plugin.tag === node.c) return plugin.serialize(node.s, { serialize: (current) => serialize$1(ctx, current) }, { id: node.i });
 	}
 	throw new SerovalMissingPluginError(node.c);
 }
@@ -2392,11 +2621,8 @@ function serializeAsyncIteratorFactory(ctx, node) {
 	if (result) return result + iterator + ")";
 	return iterator;
 }
-function serializeAsyncIteratorFactoryInstance(ctx, node) {
-	return getConstructor(ctx, node.a[0]) + "(" + serialize$1(ctx, node.a[1]) + ")";
-}
 function serializeStreamConstructor(ctx, node) {
-	const result = assignIndexedValue(ctx, node.i, getConstructor(ctx, node.f) + "()");
+	const result = assignIndexedValue(ctx, node.i, getConstructor(ctx, node.f) + (node.l === 1 ? "(1)" : "()"));
 	const len = node.a.length;
 	if (len) {
 		let values = serialize$1(ctx, node.a[0]);
@@ -2405,14 +2631,8 @@ function serializeStreamConstructor(ctx, node) {
 	}
 	return result;
 }
-function serializeStreamNext(ctx, node) {
-	return getRefParam(ctx, node.i) + ".next(" + serialize$1(ctx, node.f) + ")";
-}
-function serializeStreamThrow(ctx, node) {
-	return getRefParam(ctx, node.i) + ".throw(" + serialize$1(ctx, node.f) + ")";
-}
-function serializeStreamReturn(ctx, node) {
-	return getRefParam(ctx, node.i) + ".return(" + serialize$1(ctx, node.f) + ")";
+function serializeStreamCall(ctx, node, method) {
+	return getRefParam(ctx, node.i) + "." + method + "(" + serialize$1(ctx, node.f) + ")";
 }
 function serializeSequenceItem(ctx, id, index, item) {
 	const base = ctx.base;
@@ -2430,7 +2650,7 @@ function serializeSequence(ctx, node) {
 	if (size > 0) {
 		ctx.base.stack.push(id);
 		let result = serializeSequenceItem(ctx, id, 0, items[0]);
-		for (let i = 1, item = result; i < size; i++) {
+		for (let i = 1, item; i < size; i++) {
 			item = serializeSequenceItem(ctx, id, i, items[i]);
 			result += (item && result && ",") + item;
 		}
@@ -2452,8 +2672,8 @@ function serializeAssignable(ctx, node) {
 		case 8: return serializeMap(ctx, node);
 		case 19: return serializeArrayBuffer(ctx, node);
 		case 16:
-		case 15: return serializeTypedArray(ctx, node);
-		case 20: return serializeDataView(ctx, node);
+		case 15:
+		case 20: return serializeView(ctx, node);
 		case 14: return serializeAggregateError(ctx, node);
 		case 13: return serializeError(ctx, node);
 		case 12: return serializePromise(ctx, node);
@@ -2473,20 +2693,20 @@ function serialize$1(ctx, node) {
 		case 1: return "\"" + node.s + "\"";
 		case 3: return node.s + "n";
 		case 4: return getRefParam(ctx, node.i);
-		case 23: return serializePromiseResolve(ctx, node);
-		case 24: return serializePromiseReject(ctx, node);
+		case 23:
+		case 24: return serializePromiseResult(ctx, node);
 		case 27: return serializeIteratorFactory(ctx, node);
-		case 28: return serializeIteratorFactoryInstance(ctx, node);
+		case 28:
+		case 30: return serializeIteratorFactoryInstance(ctx, node);
 		case 29: return serializeAsyncIteratorFactory(ctx, node);
-		case 30: return serializeAsyncIteratorFactoryInstance(ctx, node);
 		case 31: return serializeStreamConstructor(ctx, node);
-		case 32: return serializeStreamNext(ctx, node);
-		case 33: return serializeStreamThrow(ctx, node);
-		case 34: return serializeStreamReturn(ctx, node);
+		case 32: return serializeStreamCall(ctx, node, "next");
+		case 33: return serializeStreamCall(ctx, node, "throw");
+		case 34: return serializeStreamCall(ctx, node, "return");
 		default: return assignIndexedValue(ctx, node.i, serializeAssignable(ctx, node));
 	}
 }
-function serializeTopVanilla(ctx, tree) {
+function serializeVanilla(ctx, tree) {
 	const result = serialize$1(ctx, tree);
 	if (tree.i != null && ctx.state.vars.length) {
 		const patches = resolvePatches(ctx.base);
@@ -2497,12 +2717,18 @@ function serializeTopVanilla(ctx, tree) {
 			if (!result.startsWith(index + "=")) body = index + "=" + body;
 			body = "(" + body + ")";
 		}
+		const sentinels = ctx.state.sentinels;
+		if (sentinels.size) {
+			let declarations = "";
+			for (const index of sentinels) declarations += ctx.state.vars[index] + "=[],";
+			body = "(" + declarations + body + ")";
+		}
 		return "(" + createFunction(ctx.state.vars, body) + ")()";
 	}
 	if (tree.t === 10) return "(" + result + ")";
 	return result;
 }
-function serializeTopCross(ctx, tree) {
+function serializeCross(ctx, tree) {
 	const result = serialize$1(ctx, tree);
 	const id = tree.i;
 	if (id == null) return result;
@@ -2510,7 +2736,11 @@ function serializeTopCross(ctx, tree) {
 	const ref = getRefParam(ctx, id);
 	const scopeId = ctx.state.scopeId;
 	const params = scopeId == null ? "" : "$R";
-	const body = patches ? "(" + result + "," + patches + ref + ")" : result;
+	let body = result;
+	if (patches) {
+		if (!ctx.base.assignAll && !result.startsWith(ref + "=")) body = ref + "=" + result;
+		body = "(" + body + "," + patches + ref + ")";
+	}
 	if (params === "") {
 		if (tree.t === 10 && !patches) return "(" + body + ")";
 		return body;
@@ -2518,76 +2748,35 @@ function serializeTopCross(ctx, tree) {
 	const args = scopeId == null ? "()" : "($R[\"" + serializeString(scopeId) + "\"])";
 	return "(" + createFunction([params], body) + ")" + args;
 }
-//#endregion
-//#region src/core/context/sync-parser.ts
-function createSyncParserContext(mode, options) {
-	return {
-		type: 1,
-		base: createBaseParserContext(mode, options),
-		child: void 0
-	};
+function wrapSerializationError(error) {
+	return error instanceof SerovalSerializationError ? error : new SerovalSerializationError(error);
 }
-var SyncParsePluginContext = class {
-	constructor(_p, depth) {
-		this._p = _p;
-		this.depth = depth;
-	}
-	parse(current) {
-		return parseSOS(this._p, this.depth, current);
-	}
-};
-var StreamParsePluginContext = class {
-	constructor(_p, depth) {
-		this._p = _p;
-		this.depth = depth;
-	}
-	parse(current) {
-		return parseSOS(this._p, this.depth, current);
-	}
-	parseWithError(current) {
-		return parseWithError(this._p, this.depth, current);
-	}
-	isAlive() {
-		return this._p.state.alive;
-	}
-	pushPendingState() {
-		pushPendingState(this._p);
-	}
-	popPendingState() {
-		popPendingState(this._p);
-	}
-	onParse(node) {
-		onParse(this._p, node);
-	}
-	onError(error) {
-		onError(this._p, error);
+function serializeTopVanilla(ctx, tree) {
+	try {
+		return serializeVanilla(ctx, tree);
+	} catch (error) {
+		throw wrapSerializationError(error);
 	}
-	addCleanup(callback) {
-		this._p.state.cleanups.push(callback);
+}
+function serializeTopCross(ctx, tree) {
+	try {
+		return serializeCross(ctx, tree);
+	} catch (error) {
+		throw wrapSerializationError(error);
 	}
-};
-function createStreamParserState(options) {
-	return {
-		alive: true,
-		pending: 0,
-		initial: true,
-		buffer: [],
-		onParse: options.onParse,
-		onError: options.onError,
-		onDone: options.onDone,
-		cleanups: []
-	};
 }
-function createStreamParserContext(options) {
+//#endregion
+//#region src/core/context/sync-parser.ts
+function createSyncParserContext(options) {
 	return {
-		type: 2,
-		base: createBaseParserContext(2, options),
-		state: createStreamParserState(options)
+		type: 1,
+		base: createBaseParserContext(options)
 	};
 }
 function parseItems(ctx, depth, current) {
-	const nodes = [];
-	for (let i = 0, len = current.length; i < len; i++) if (i in current) nodes[i] = parseSOS(ctx, depth, current[i]);
+	const len = current.length;
+	const nodes = new Array(len);
+	for (let i = 0; i < len; i++) if (i in current) nodes[i] = parseSOS(ctx, depth, current[i]);
 	else nodes[i] = 0;
 	return nodes;
 }
@@ -2595,20 +2784,22 @@ function parseArray(ctx, depth, id, current) {
 	return createArrayNode(id, current, parseItems(ctx, depth, current));
 }
 function parseProperties(ctx, depth, 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(parseSOS(ctx, depth, entries[i][1]));
+	const keys = Object.keys(properties);
+	const len = keys.length;
+	const keyNodes = new Array(len);
+	const valueNodes = new Array(len);
+	for (let i = 0, key; i < len; i++) {
+		key = keys[i];
+		keyNodes[i] = serializeString(key);
+		valueNodes[i] = parseSOS(ctx, depth, properties[key]);
 	}
 	if (SYM_ITERATOR in properties) {
 		keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));
-		valueNodes.push(createIteratorFactoryInstanceNode(parseIteratorFactory(ctx.base), parseSOS(ctx, depth, createSequenceFromIterable(properties))));
+		valueNodes.push(createIteratorFactoryInstanceNode(28, parseIteratorFactory(ctx.base), parseSOS(ctx, depth, createSequenceFromIterable(properties))));
 	}
 	if (SYM_ASYNC_ITERATOR in properties) {
 		keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));
-		valueNodes.push(createAsyncIteratorFactoryInstanceNode(parseAsyncIteratorFactory(ctx.base), parseSOS(ctx, depth, ctx.type === 1 ? createStream() : createStreamFromAsyncIterable(properties, ctx.state.cleanups))));
+		valueNodes.push(createIteratorFactoryInstanceNode(30, parseAsyncIteratorFactory(ctx.base), parseAsyncIterable(ctx, depth, properties)));
 	}
 	if (SYM_TO_STRING_TAG in properties) {
 		keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));
@@ -2623,188 +2814,131 @@ function parseProperties(ctx, depth, properties) {
 		v: valueNodes
 	};
 }
+function parseAsyncIterable(ctx, depth, current) {
+	if (ctx.type !== 2) throw new SerovalUnsupportedTypeError(current);
+	const id = createIndexForValue(ctx.base, {});
+	const result = createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), []);
+	ctx.state.iterable(ctx, depth, id, current);
+	return result;
+}
 function parsePlainObject(ctx, depth, id, current, empty) {
 	return createObjectNode(id, current, empty, parseProperties(ctx, depth, current));
 }
 function parseBoxed(ctx, depth, id, current) {
 	return createBoxedNode(id, parseSOS(ctx, depth, current.valueOf()));
 }
-function parseTypedArray(ctx, depth, id, current) {
-	current = getArrayBufferView(ctx.base, current);
-	return createTypedArrayNode(id, current, parseSOS(ctx, depth, current.buffer));
-}
-function parseBigIntTypedArray(ctx, depth, id, current) {
+function parseView(ctx, depth, type, id, current) {
 	current = getArrayBufferView(ctx.base, current);
-	return createBigIntTypedArrayNode(id, current, parseSOS(ctx, depth, current.buffer));
-}
-function parseDataView(ctx, depth, id, current) {
-	current = getArrayBufferView(ctx.base, current);
-	return createDataViewNode(id, current, parseSOS(ctx, depth, current.buffer));
-}
-function parseError(ctx, depth, id, current) {
-	const options = getErrorOptions(current, ctx.base.features);
-	return createErrorNode(id, current, options ? parseProperties(ctx, depth, options) : void 0);
+	return createViewNode(type, id, current, parseSOS(ctx, depth, current.buffer));
 }
-function parseAggregateError(ctx, depth, id, current) {
+function parseError(ctx, depth, type, id, current) {
 	const options = getErrorOptions(current, ctx.base.features);
-	return createAggregateErrorNode(id, current, options ? parseProperties(ctx, depth, options) : void 0);
+	return createErrorNode(type, id, current, options ? parseProperties(ctx, depth, options) : void 0);
 }
 function parseMap(ctx, depth, id, current) {
 	const sentinel = parseMapSentinel(ctx.base);
-	const keyNodes = [];
-	const valueNodes = [];
+	const keyNodes = new Array(current.size);
+	const valueNodes = new Array(current.size);
+	let i = 0;
 	for (const [key, value] of current.entries()) {
-		keyNodes.push(parseSOS(ctx, depth, key));
-		valueNodes.push(parseSOS(ctx, depth, value));
+		keyNodes[i] = parseSOS(ctx, depth, key);
+		valueNodes[i] = parseSOS(ctx, depth, value);
+		i++;
 	}
 	return createMapNode(id, sentinel, keyNodes, valueNodes);
 }
 function parseSet(ctx, depth, id, current) {
-	const items = [];
-	for (const item of current.keys()) items.push(parseSOS(ctx, depth, item));
+	const items = new Array(current.size);
+	let i = 0;
+	for (const item of current.keys()) items[i++] = parseSOS(ctx, depth, item);
 	return createSetNode(id, items);
 }
-function parseStream(ctx, depth, id, current) {
-	const result = createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), []);
-	if (ctx.type === 1) return result;
-	pushPendingState(ctx);
-	current.on({
-		next: (value) => {
-			if (ctx.state.alive) {
-				const parsed = parseWithError(ctx, depth, value);
-				if (parsed) onParse(ctx, createStreamNextNode(id, parsed));
-			}
-		},
-		throw: (value) => {
-			if (ctx.state.alive) {
-				const parsed = parseWithError(ctx, depth, value);
-				if (parsed) onParse(ctx, createStreamThrowNode(id, parsed));
-			}
-			popPendingState(ctx);
-		},
-		return: (value) => {
-			if (ctx.state.alive) {
-				const parsed = parseWithError(ctx, depth, value);
-				if (parsed) onParse(ctx, createStreamReturnNode(id, parsed));
-			}
-			popPendingState(ctx);
-		}
-	});
-	return result;
+/**
+* Sends the events of a stream that has ended, so the copy gets all of them.
+* A stream that is still open throws, because the other sync modes cannot
+* send its later events.
+*/
+function parseEndedStream(ctx, depth, id, current) {
+	const events = current.endedEvents();
+	if (!events) throw new SerovalUnsupportedTypeError(current);
+	const values = events.values;
+	const last = values.length - 1;
+	const sequence = new Array(values.length);
+	if (last >= 0) markParserRef(ctx.base, id);
+	for (let i = 0; i <= last; i++) sequence[i] = createStreamEventNode(i < last ? 32 : events.success ? 34 : 33, id, parseSOS(ctx, depth, values[i]));
+	return sequence;
 }
-function handlePromiseSuccess(id, depth, data) {
-	if (this.state.alive) {
-		const parsed = parseWithError(this, depth, data);
-		if (parsed) onParse(this, createSerovalNode(23, id, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(this.base, 2), parsed], void 0, void 0, void 0, void 0));
-		popPendingState(this);
+function parseStream(ctx, depth, id, current) {
+	const reference = parseSpecialReference(ctx.base, 4);
+	if (ctx.type === 2) {
+		const result = createStreamConstructorNode(id, reference, []);
+		ctx.state.stream(ctx, depth, id, current);
+		return result;
 	}
+	return createStreamConstructorNode(id, reference, parseEndedStream(ctx, depth, id, current));
 }
-function handlePromiseFailure(id, depth, data) {
-	if (this.state.alive) {
-		const parsed = parseWithError(this, depth, data);
-		if (parsed) onParse(this, createSerovalNode(24, id, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(this.base, 3), parsed], void 0, void 0, void 0, void 0));
-	}
-	popPendingState(this);
+function parseLiveStream(ctx, depth, id, current) {
+	if (ctx.type !== 2) throw new SerovalUnsupportedTypeError(current);
+	const result = createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), [], 1);
+	ctx.state.live(ctx, depth, id, current);
+	return result;
 }
 function parsePromise(ctx, depth, id, current) {
+	if (ctx.type !== 2) throw new SerovalUnsupportedTypeError(current);
 	const resolver = createIndexForValue(ctx.base, {});
-	if (ctx.type === 2) {
-		pushPendingState(ctx);
-		current.then(handlePromiseSuccess.bind(ctx, resolver, depth), handlePromiseFailure.bind(ctx, resolver, depth));
-	}
+	ctx.state.promise(ctx, resolver, depth, current);
 	return createPromiseConstructorNode(ctx.base, id, resolver);
 }
 function parsePluginSync(ctx, depth, id, current, currentPlugins) {
 	for (let i = 0, len = currentPlugins.length; i < len; i++) {
 		const plugin = currentPlugins[i];
-		if (plugin.parse.sync && plugin.test(current)) return createPluginNode(id, plugin.tag, plugin.parse.sync(current, new SyncParsePluginContext(ctx, depth), { id }));
+		if (plugin.parse.sync && plugin.test(current)) return createPluginNode(id, plugin.tag, plugin.parse.sync(current, { parse: (value) => parseSOS(ctx, depth, value) }, { id }));
 	}
 }
-function parsePluginStream(ctx, depth, id, current, currentPlugins) {
-	for (let i = 0, len = currentPlugins.length; i < len; i++) {
-		const plugin = currentPlugins[i];
-		if (plugin.parse.stream && plugin.test(current)) return createPluginNode(id, plugin.tag, plugin.parse.stream(current, new StreamParsePluginContext(ctx, depth), { id }));
-	}
-}
-function parsePlugin(ctx, depth, id, current) {
-	const currentPlugins = ctx.base.plugins;
-	if (currentPlugins) return ctx.type === 1 ? parsePluginSync(ctx, depth, id, current, currentPlugins) : parsePluginStream(ctx, depth, id, current, currentPlugins);
+function parsePlugin(ctx, depth, id, current, currentPlugins) {
+	if (currentPlugins) return ctx.type === 1 ? parsePluginSync(ctx, depth, id, current, currentPlugins) : ctx.state.plugin(ctx, depth, id, current, currentPlugins);
 }
 function parseSequence(ctx, depth, id, current) {
-	const nodes = [];
-	for (let i = 0, len = current.v.length; i < len; i++) nodes[i] = parseSOS(ctx, depth, current.v[i]);
+	const len = current.v.length;
+	const nodes = new Array(len);
+	for (let i = 0; i < len; i++) nodes[i] = parseSOS(ctx, depth, current.v[i]);
 	return createSequenceNode(id, nodes, current.t, current.d);
 }
 function parseObjectPhase2(ctx, depth, id, current, currentClass) {
-	switch (currentClass) {
-		case Object: return parsePlainObject(ctx, depth, id, current, false);
-		case void 0: return parsePlainObject(ctx, depth, id, current, true);
-		case Date: return createDateNode(id, current);
-		case Error:
-		case EvalError:
-		case RangeError:
-		case ReferenceError:
-		case SyntaxError:
-		case TypeError:
-		case URIError: return parseError(ctx, depth, id, current);
-		case Number:
-		case Boolean:
-		case String:
-		case BigInt: return parseBoxed(ctx, depth, id, current);
-		case ArrayBuffer: return createArrayBufferNode(ctx.base, id, current);
-		case Int8Array:
-		case Int16Array:
-		case Int32Array:
-		case Uint8Array:
-		case Uint16Array:
-		case Uint32Array:
-		case Uint8ClampedArray:
-		case Float32Array:
-		case Float64Array: return parseTypedArray(ctx, depth, id, current);
-		case DataView: return parseDataView(ctx, depth, id, current);
-		case Map: return parseMap(ctx, depth, id, current);
-		case Set: return parseSet(ctx, depth, id, current);
-	}
-	if (currentClass === Promise || current instanceof Promise) return parsePromise(ctx, depth, id, current);
-	const currentFeatures = ctx.base.features;
-	if (currentFeatures & 32 && currentClass === RegExp) return createRegExpNode(id, current);
-	if (currentFeatures & 16) switch (currentClass) {
-		case BigInt64Array:
-		case BigUint64Array: return parseBigIntTypedArray(ctx, depth, id, current);
-	}
-	if (currentFeatures & 1 && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) return parseAggregateError(ctx, depth, id, current);
-	if (currentFeatures & 64 && typeof Temporal !== "undefined") switch (currentClass) {
-		case Temporal.Instant: return createTemporalNode(id, 0, current);
-		case Temporal.Duration: return createTemporalNode(id, 1, current);
-		case Temporal.PlainDate: return createTemporalNode(id, 2, current);
-		case Temporal.PlainDateTime: return createTemporalNode(id, 3, current);
-		case Temporal.PlainMonthDay: return createTemporalNode(id, 4, current);
-		case Temporal.PlainTime: return createTemporalNode(id, 5, current);
-		case Temporal.PlainYearMonth: return createTemporalNode(id, 6, current);
-		case Temporal.ZonedDateTime: return createTemporalNode(id, 7, current);
-	}
-	if (current instanceof Error) return parseError(ctx, depth, id, current);
-	if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) return parsePlainObject(ctx, depth, id, current, !!currentClass);
-	throw new SerovalUnsupportedTypeError(current);
+	if (currentClass === Object) return parsePlainObject(ctx, depth, id, current, false);
+	switch (getObjectKind(current, currentClass, ctx.base.features)) {
+		case 2: return parsePlainObject(ctx, depth, id, current, true);
+		case 3: return createDateNode(id, current);
+		case 4: return parseError(ctx, depth, 13, id, current);
+		case 5: return parseError(ctx, depth, 14, id, current);
+		case 6: return parseBoxed(ctx, depth, id, current);
+		case 7: return createArrayBufferNode(ctx.base, id, current);
+		case 8: return parseView(ctx, depth, 15, id, current);
+		case 9: return parseView(ctx, depth, 16, id, current);
+		case 10: return parseView(ctx, depth, 20, id, current);
+		case 11: return parseMap(ctx, depth, id, current);
+		case 12: return parseSet(ctx, depth, id, current);
+		case 13: return parsePromise(ctx, depth, id, current);
+		case 14: return createRegExpNode(id, current);
+		case 15: return createTemporalNode(id, getTemporalType(currentClass), current);
+		case 16: return parsePlainObject(ctx, depth, id, current, !!currentClass);
+		default: throw new SerovalUnsupportedTypeError(current);
+	}
 }
 function parseObject(ctx, depth, id, current) {
 	if (Array.isArray(current)) return parseArray(ctx, depth, id, current);
-	if (isStream(current)) return parseStream(ctx, depth, id, current);
+	if (isStream(current)) return isLiveStream(current) ? parseLiveStream(ctx, depth, id, current) : parseStream(ctx, depth, id, current);
 	if (isSequence(current)) return parseSequence(ctx, depth, id, current);
-	let currentClass = current.constructor;
-	if (currentClass !== void 0 && typeof currentClass !== "function") {
-		const proto = Object.getPrototypeOf(current);
-		currentClass = proto === null ? void 0 : proto.constructor;
-	}
+	const currentClass = getObjectClass(current);
 	if (currentClass === OpaqueReference) return parseSOS(ctx, depth, current.replacement);
-	const parsed = parsePlugin(ctx, depth, id, current);
+	const parsed = parsePlugin(ctx, depth, id, current, getObjectPlugins(ctx.base, current, currentClass));
 	if (parsed) return parsed;
 	return parseObjectPhase2(ctx, depth, id, current, currentClass);
 }
 function parseFunction(ctx, depth, current) {
 	const ref = getReferenceNode(ctx.base, current);
-	if (ref.type !== 0) return ref.value;
-	const plugin = parsePlugin(ctx, depth, ref.value, current);
+	if (typeof ref !== "number") return ref;
+	const plugin = parsePlugin(ctx, depth, ref, current, ctx.base.plugins);
 	if (plugin) return plugin;
 	throw new SerovalUnsupportedTypeError(current);
 }
@@ -2819,7 +2953,7 @@ function parseSOS(ctx, depth, current) {
 		case "object":
 			if (current) {
 				const ref = getReferenceNode(ctx.base, current);
-				return ref.type === 0 ? parseObject(ctx, depth + 1, ref.value, current) : ref.value;
+				return typeof ref === "number" ? parseObject(ctx, depth + 1, ref, current) : ref;
 			}
 			return NULL_NODE;
 		case "symbol": return parseWellKnownSymbol(ctx.base, current);
@@ -2834,63 +2968,431 @@ function parseTop(ctx, current) {
 		throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
 	}
 }
-function onParse(ctx, node) {
-	if (ctx.state.initial) ctx.state.buffer.push(node);
-	else onParseInternal(ctx, node, false);
+//#endregion
+//#region src/core/context/stream-parser.ts
+/**
+* Streaming parse mode. Everything here is reached through the function
+* fields of the stream parser state, which only `createStreamParserContext`
+* sets, so synchronous consumers (`serialize`, `toJSON`) never bundle it.
+*/
+function createStreamParsePluginContext(ctx, depth) {
+	const state = ctx.state;
+	function parse(current) {
+		state.parsing++;
+		try {
+			return parseSOS(ctx, depth, current);
+		} finally {
+			state.parsing--;
+			if (!state.alive) releaseParserValues(ctx);
+		}
+	}
+	return {
+		parse,
+		parseStreamSource(current) {
+			state.parsing++;
+			try {
+				if (depth >= ctx.base.depthLimit) throw new SerovalDepthLimitError(ctx.base.depthLimit);
+				const id = createIndexForValue(ctx.base, {});
+				const node = createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), [], 1);
+				iterateAsync(ctx, depth + 1, id, current, true);
+				return node;
+			} finally {
+				state.parsing--;
+				if (!state.alive) releaseParserValues(ctx);
+			}
+		},
+		parseWithError(current) {
+			try {
+				return parse(current);
+			} catch (error) {
+				stopStreamParse(ctx, 1, error);
+				return;
+			}
+		},
+		isAlive: () => state.alive,
+		pushPendingState: () => {
+			pushPendingState(ctx);
+		},
+		popPendingState: () => {
+			popPendingState(ctx);
+		},
+		onParse(node) {
+			if (state.alive) {
+				state.queue.push({
+					node,
+					initial: false,
+					accept: void 0
+				});
+				drainOutput(ctx);
+			}
+		},
+		onError(error) {
+			stopStreamParse(ctx, 1, error);
+		},
+		addCleanup(callback) {
+			addCleanup(ctx, callback);
+		}
+	};
+}
+function getStreamParsePluginContext(ctx, depth) {
+	const contexts = ctx.state.pluginContexts;
+	return contexts[depth] ?? (contexts[depth] = createStreamParsePluginContext(ctx, depth));
 }
-function onError(ctx, error) {
-	if (ctx.state.onError) ctx.state.onError(error);
-	else throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
+function addCleanup(ctx, callback) {
+	if (ctx.state.alive) ctx.state.cleanups.push(callback);
+	else callback();
 }
-function onDone(ctx) {
-	if (ctx.state.onDone) ctx.state.onDone();
-	for (let i = 0, len = ctx.state.cleanups.length; i < len; i++) ctx.state.cleanups[i]();
+function parsePluginStream(ctx, depth, id, current, currentPlugins) {
+	for (let i = 0, len = currentPlugins.length; i < len; i++) {
+		const plugin = currentPlugins[i];
+		if (plugin.parse.stream && plugin.test(current)) return createPluginNode(id, plugin.tag, plugin.parse.stream(current, getStreamParsePluginContext(ctx, depth), { id }));
+	}
+}
+/**
+* One listener shape serves both `Stream.on` (no accept) and
+* `LiveStream.pump` (accept tied to record acceptance). Handlers return the
+* parse error so the pump can stop the source.
+*/
+function streamListener(ctx, depth, id, subscription) {
+	const handle = (type, terminal) => (value, accept) => {
+		let failure = void 0;
+		if (ctx.state.alive) try {
+			failure = parseEvent(ctx, depth, value, createStreamEventNode.bind(null, type, id), accept);
+		} catch (error) {
+			if (!subscription?.active) throw error;
+			subscription.failure ?? (subscription.failure = { value: error });
+			failure = error;
+		}
+		if (terminal && !accept) popPendingState(ctx);
+		return failure;
+	};
+	return {
+		next: handle(32, false),
+		throw: handle(33, true),
+		return: handle(34, true),
+		done() {
+			popPendingState(ctx);
+		},
+		error(reason) {
+			if (ctx.state.alive) stopStreamParse(ctx, 1, reason);
+		}
+	};
 }
-function onParseInternal(ctx, node, initial) {
+function subscribeStream(ctx, depth, id, current) {
+	pushPendingState(ctx);
+	const subscription = {
+		active: true,
+		failure: void 0
+	};
+	let cleanup;
+	try {
+		cleanup = current.on(streamListener(ctx, depth, id, subscription));
+	} finally {
+		subscription.active = false;
+	}
 	try {
-		ctx.state.onParse(node, initial);
+		addCleanup(ctx, cleanup);
 	} catch (error) {
-		onError(ctx, error);
+		subscription.failure ?? (subscription.failure = { value: error });
 	}
+	const failure = subscription.failure;
+	subscription.failure = void 0;
+	if (failure) throw failure.value;
+}
+function consumeLiveStream(ctx, depth, id, current) {
+	const cancel = current.pump(streamListener(ctx, depth, id));
+	pushPendingState(ctx);
+	addCleanup(ctx, () => {
+		cancel(ctx.state.reason);
+	});
+}
+function wrapPromiseResult(ctx, type, id, node) {
+	return createSerovalNode(type, id, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(ctx.base, type === 23 ? 2 : 3), node], void 0, void 0, void 0, void 0);
+}
+function handlePromise(type, id, depth, data) {
+	if (this.state.alive) parseEvent(this, depth, data, wrapPromiseResult.bind(null, this, type, id), void 0);
+	popPendingState(this);
+}
+function watchPromise(ctx, resolver, depth, current) {
+	pushPendingState(ctx);
+	current.then(handlePromise.bind(ctx, 23, resolver, depth), handlePromise.bind(ctx, 24, resolver, depth));
+}
+function returnIterator(iterator) {
+	Promise.resolve().then(() => iterator.return?.()).catch(() => {});
+}
+/**
+* Drives an async iterator directly. The next value is pulled only after the
+* record for the previous one has been accepted, and cancellation returns
+* the iterator once.
+*/
+function iterateAsync(ctx, depth, id, current, forwardReason) {
+	const iterator = current[SYM_ASYNC_ITERATOR]();
+	const listener = streamListener(ctx, depth, id);
+	let active = true;
+	function stop() {
+		if (active) {
+			active = false;
+			if (forwardReason) try {
+				Promise.resolve(iterator.return?.(ctx.state.reason)).catch(() => {});
+			} catch {}
+			else returnIterator(iterator);
+		}
+	}
+	function pull() {
+		if (active) iterator.next().then((result) => {
+			if (active) {
+				if (result.done) {
+					active = false;
+					listener.return(result.value, void 0);
+				} else if (listener.next(result.value, pull) !== void 0) {
+					stop();
+					listener.done();
+				}
+			}
+		}, (error) => {
+			if (active) {
+				active = false;
+				listener.throw(error, void 0);
+			}
+		});
+	}
+	pushPendingState(ctx);
+	addCleanup(ctx, stop);
+	pull();
+}
+function createStreamParserState(options) {
+	return {
+		alive: true,
+		pending: 0,
+		parsing: 0,
+		queue: [],
+		writing: false,
+		inFlight: void 0,
+		reason: void 0,
+		onParse: options.onParse,
+		onError: options.onError,
+		onDone: options.onDone,
+		cleanups: [],
+		pluginContexts: [],
+		stream: subscribeStream,
+		live: consumeLiveStream,
+		promise: watchPromise,
+		iterable: iterateAsync,
+		plugin: parsePluginStream
+	};
+}
+function createStreamParserContext(options) {
+	return {
+		type: 2,
+		base: createBaseParserContext(options),
+		state: createStreamParserState(options)
+	};
 }
 function pushPendingState(ctx) {
-	ctx.state.pending++;
+	if (ctx.state.alive) ctx.state.pending++;
 }
 function popPendingState(ctx) {
-	if (--ctx.state.pending <= 0) onDone(ctx);
+	if (ctx.state.alive) {
+		ctx.state.pending--;
+		checkStreamParse(ctx);
+	}
 }
-function parseWithError(ctx, depth, current) {
+/**
+* Parses a value that arrived after the root. Its record is queued before
+* parsing starts so that records discovered inside it follow it, and it is
+* dropped again if parsing fails. Returns the parse error after reporting
+* it, or `undefined`.
+*/
+function parseEvent(ctx, depth, value, wrap, accept) {
+	const state = ctx.state;
+	const record = {
+		node: void 0,
+		initial: false,
+		accept
+	};
+	let failure;
+	state.queue.push(record);
+	state.parsing++;
 	try {
-		return parseSOS(ctx, depth, current);
-	} catch (err) {
-		onError(ctx, err);
-		return;
+		record.node = wrap(parseSOS(ctx, depth, value));
+	} catch (error) {
+		failure = { value: error };
+	} finally {
+		state.parsing--;
+		if (!state.alive) releaseParserValues(ctx);
 	}
+	if (failure) stopStreamParse(ctx, 1, failure.value);
+	else drainOutput(ctx);
+	return failure?.value;
+}
+/**
+* Emits queued records one at a time. A callback that returns a promise
+* pauses emission until it settles; the source event behind the record is
+* accepted only after that.
+*/
+function drainOutput(ctx) {
+	const state = ctx.state;
+	if (state.writing || state.parsing > 0) return;
+	while (state.alive && state.queue.length > 0) {
+		const record = state.queue.shift();
+		if (!record.node) continue;
+		let pending;
+		state.writing = true;
+		state.inFlight = record;
+		state.parsing++;
+		try {
+			if (!state.onParse) throw new Error("Stream output callback is unavailable");
+			const result = state.onParse(record.node, record.initial);
+			if (result !== null && (typeof result === "object" || typeof result === "function")) {
+				const then = Reflect.get(result, "then");
+				if (typeof then === "function") pending = new Promise((resolve, reject) => {
+					Reflect.apply(then, result, [resolve, reject]);
+				});
+			}
+		} catch (error) {
+			releaseRecord(record);
+			stopStreamParse(ctx, 1, error);
+			return;
+		} finally {
+			state.parsing--;
+			if (!state.alive) releaseParserValues(ctx);
+		}
+		record.node = void 0;
+		if (pending) {
+			if (!state.alive) releaseRecord(record);
+			pending.then(() => {
+				state.writing = false;
+				state.inFlight = void 0;
+				if (state.alive) {
+					const accept = record.accept;
+					releaseRecord(record);
+					accept?.();
+					drainOutput(ctx);
+				}
+			}, (error) => {
+				state.writing = false;
+				state.inFlight = void 0;
+				releaseRecord(record);
+				stopStreamParse(ctx, 1, error);
+			});
+			return;
+		}
+		if (!state.alive) {
+			releaseRecord(record);
+			return;
+		}
+		state.writing = false;
+		state.inFlight = void 0;
+		const accept = record.accept;
+		releaseRecord(record);
+		accept?.();
+	}
+	checkStreamParse(ctx);
+}
+function checkStreamParse(ctx) {
+	const state = ctx.state;
+	if (state.alive && state.parsing === 0 && state.pending <= 0 && state.queue.length === 0 && !state.writing) stopStreamParse(ctx, 0);
 }
 function startStreamParse(ctx, current) {
-	const parsed = parseWithError(ctx, 0, current);
-	if (parsed) {
-		onParseInternal(ctx, parsed, true);
-		ctx.state.initial = false;
-		flushStreamParse(ctx, ctx.state);
-		if (ctx.state.pending <= 0) destroyStreamParse(ctx);
+	const state = ctx.state;
+	let parsed;
+	let failure;
+	state.parsing++;
+	try {
+		parsed = parseSOS(ctx, 0, current);
+	} catch (error) {
+		failure = { value: error };
+	} finally {
+		state.parsing--;
+		if (!state.alive) releaseParserValues(ctx);
+	}
+	if (failure) {
+		if (state.alive) stopStreamParse(ctx, 1, failure.value);
+		else throw failure.value;
+	} else if (parsed && state.alive) {
+		state.queue.unshift({
+			node: parsed,
+			initial: true,
+			accept: void 0
+		});
+		drainOutput(ctx);
+	}
+}
+function runCleanups(state) {
+	const cleanups = state.cleanups;
+	let failure;
+	state.cleanups = [];
+	for (const record of state.queue) releaseRecord(record);
+	state.queue.length = 0;
+	if (state.inFlight) releaseRecord(state.inFlight);
+	state.inFlight = void 0;
+	for (let i = 0, len = cleanups.length; i < len; i++) try {
+		cleanups[i]();
+	} catch (error) {
+		failure ?? (failure = { value: error });
 	}
+	if (failure) throw failure.value;
 }
-function flushStreamParse(ctx, state) {
-	for (let i = 0, len = state.buffer.length; i < len; i++) onParseInternal(ctx, state.buffer[i], false);
+function releaseRecord(record) {
+	record.node = void 0;
+	record.accept = void 0;
 }
-function destroyStreamParse(ctx) {
-	if (ctx.state.alive) {
-		onDone(ctx);
-		ctx.state.alive = false;
+function releaseParserValues(ctx) {
+	ctx.base.refs = /* @__PURE__ */ new Map();
+	ctx.base.marked.clear();
+	ctx.base.plugins = void 0;
+	ctx.base.plainObjectPlugins = void 0;
+	ctx.state.pluginContexts = [];
+	if (ctx.state.parsing === 0) ctx.state.reason = void 0;
+}
+/**
+* Ends the parse once: `onDone` on success, `onError` on failure, and every
+* cleanup either way.
+*/
+function stopStreamParse(ctx, mode, reason) {
+	const state = ctx.state;
+	if (state.alive) {
+		state.alive = false;
+		const onError = state.onError;
+		const onDone = state.onDone;
+		if (mode === 1 && !onError && !(reason instanceof SerovalParserError)) reason = new SerovalParserError(reason);
+		state.reason = reason;
+		state.onParse = void 0;
+		state.onError = void 0;
+		state.onDone = void 0;
+		state.writing = false;
+		state.parsing++;
+		let failure;
+		try {
+			if (mode === 1) {
+				if (onError) onError(reason);
+				else throw reason;
+			} else if (mode === 0) onDone?.();
+		} catch (error) {
+			failure = { value: error };
+		}
+		try {
+			runCleanups(state);
+		} catch (error) {
+			failure ?? (failure = { value: error });
+		} finally {
+			state.parsing--;
+			releaseParserValues(ctx);
+			state.pending = 0;
+		}
+		if (failure) throw failure.value;
 	}
 }
+function destroyStreamParse(ctx, reason) {
+	stopStreamParse(ctx, 2, reason);
+}
 //#endregion
 //#region src/core/cross/index.ts
 function crossSerialize(source, options = {}) {
 	const plugins = resolvePlugins(options.plugins);
-	const ctx = createSyncParserContext(2, {
+	const ctx = createSyncParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		disabledFeatures: options.disabledFeatures,
 		refs: options.refs
@@ -2900,13 +3402,15 @@ function crossSerialize(source, options = {}) {
 		plugins,
 		features: ctx.base.features,
 		scopeId: options.scopeId,
-		markedRefs: ctx.base.marked
+		markedRefs: ctx.base.marked,
+		assignSharedRefsOnly: options.assignSharedRefsOnly
 	}), tree);
 }
 async function crossSerializeAsync(source, options = {}) {
 	const plugins = resolvePlugins(options.plugins);
-	const ctx = createAsyncParserContext(2, {
+	const ctx = createAsyncParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		disabledFeatures: options.disabledFeatures,
 		refs: options.refs
@@ -2916,13 +3420,15 @@ async function crossSerializeAsync(source, options = {}) {
 		plugins,
 		features: ctx.base.features,
 		scopeId: options.scopeId,
-		markedRefs: ctx.base.marked
+		markedRefs: ctx.base.marked,
+		assignSharedRefsOnly: options.assignSharedRefsOnly
 	}), tree);
 }
 function toCrossJSON(source, options = {}) {
 	const plugins = resolvePlugins(options.plugins);
-	return parseTop(createSyncParserContext(2, {
+	return parseTop(createSyncParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		disabledFeatures: options.disabledFeatures,
 		refs: options.refs
@@ -2930,8 +3436,9 @@ function toCrossJSON(source, options = {}) {
 }
 async function toCrossJSONAsync(source, options = {}) {
 	const plugins = resolvePlugins(options.plugins);
-	return await parseTopAsync(createAsyncParserContext(2, {
+	return await parseTopAsync(createAsyncParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		disabledFeatures: options.disabledFeatures,
 		refs: options.refs
@@ -2939,8 +3446,11 @@ async function toCrossJSONAsync(source, options = {}) {
 }
 function crossSerializeStream(source, options) {
 	const plugins = resolvePlugins(options.plugins);
+	const onSerialize = options.onSerialize;
+	const scopeId = options.scopeId;
 	const ctx = createStreamParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		refs: options.refs,
 		disabledFeatures: options.disabledFeatures,
@@ -2948,17 +3458,10 @@ function crossSerializeStream(source, options) {
 			const serial = createCrossSerializerContext({
 				plugins,
 				features: ctx.base.features,
-				scopeId: options.scopeId,
+				scopeId,
 				markedRefs: ctx.base.marked
 			});
-			let serialized;
-			try {
-				serialized = serializeTopCross(serial, node);
-			} catch (err) {
-				if (options.onError) options.onError(err);
-				return;
-			}
-			options.onSerialize(serialized, initial);
+			return onSerialize(serializeTopCross(serial, node), initial);
 		},
 		onError: options.onError,
 		onDone: options.onDone
@@ -2981,22 +3484,39 @@ function toCrossJSONStream(source, options) {
 	startStreamParse(ctx, source);
 	return destroyStreamParse.bind(null, ctx);
 }
-function fromCrossJSON(source, options) {
-	const plugins = resolvePlugins(options.plugins);
-	return deserializeTop(createCrossDeserializerContext({
+function createFromCrossJSONContext(options) {
+	return createCrossDeserializerContext({
 		maxBase64Length: options.maxBase64Length,
-		plugins,
+		plugins: resolvePlugins(options.plugins),
 		refs: options.refs,
 		features: options.features,
 		disabledFeatures: options.disabledFeatures,
 		depthLimit: options.depthLimit
-	}), source);
+	});
+}
+function fromCrossJSON(source, options) {
+	return deserializeTop(createFromCrossJSONContext(options), source);
+}
+function createCrossDeserializer(options) {
+	const ctx = createFromCrossJSONContext(options);
+	ctx.base.pending = /* @__PURE__ */ new Set();
+	return {
+		deserialize(node) {
+			if (!ctx.base.pending) throw new SerovalAbortedError();
+			return deserializeTop(ctx, node);
+		},
+		get pending() {
+			return ctx.base.pending?.size ?? 0;
+		},
+		abort(reason) {
+			abortDeferred(ctx, reason);
+		}
+	};
 }
 //#endregion
 //#region src/core/Serializer.ts
 var Serializer = class {
 	constructor(options) {
-		this.options = options;
 		this.alive = true;
 		this.flushed = false;
 		this.done = false;
@@ -3005,32 +3525,52 @@ var Serializer = class {
 		this.refs = /* @__PURE__ */ new Map();
 		this.keys = /* @__PURE__ */ new Set();
 		this.ids = 0;
+		this.options = options;
 		this.plugins = resolvePlugins(options.plugins);
 	}
 	write(key, value) {
-		if (this.alive && !this.flushed) {
+		const options = this.options;
+		if (this.alive && !this.flushed && options) {
 			this.pending++;
 			this.keys.add(key);
-			this.cleanups.push(crossSerializeStream(value, {
+			const cleanup = crossSerializeStream(value, {
 				plugins: this.plugins,
-				scopeId: this.options.scopeId,
+				scopeId: options.scopeId,
 				refs: this.refs,
-				disabledFeatures: this.options.disabledFeatures,
-				compactArrayBufferViews: this.options.compactArrayBufferViews,
-				onError: this.options.onError,
+				disabledFeatures: options.disabledFeatures,
+				compactArrayBufferViews: options.compactArrayBufferViews,
+				depthLimit: options.depthLimit,
+				onError: (error) => {
+					let failure;
+					try {
+						if (options.onError) options.onError(error);
+						else throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
+					} catch (handlerError) {
+						failure = { value: handlerError };
+					}
+					try {
+						this.finishWrite();
+					} catch (finishError) {
+						failure ?? (failure = { value: finishError });
+					}
+					if (failure) throw failure.value;
+				},
 				onSerialize: (data, initial) => {
-					if (this.alive) this.options.onData(initial ? this.options.globalIdentifier + "[\"" + serializeString(key) + "\"]=" + data : data);
+					const current = this.options;
+					if (this.alive && current) current.onData(initial ? current.globalIdentifier + "[\"" + serializeString(key) + "\"]=" + data : data);
 				},
 				onDone: () => {
-					if (this.alive) {
-						this.pending--;
-						if (this.pending <= 0 && this.flushed && !this.done && this.options.onDone) {
-							this.options.onDone();
-							this.done = true;
-						}
-					}
+					this.finishWrite();
 				}
-			}));
+			});
+			if (this.alive) this.cleanups.push(cleanup);
+			else cleanup();
+		}
+	}
+	finishWrite() {
+		if (this.alive) {
+			this.pending--;
+			if (this.pending <= 0 && this.flushed && !this.done) this.close();
 		}
 	}
 	getNextID() {
@@ -3045,20 +3585,36 @@ var Serializer = class {
 	flush() {
 		if (this.alive) {
 			this.flushed = true;
-			if (this.pending <= 0 && !this.done && this.options.onDone) {
-				this.options.onDone();
-				this.done = true;
-			}
+			if (this.pending <= 0 && !this.done) this.close();
 		}
 	}
 	close() {
+		this.finish();
+	}
+	finish() {
 		if (this.alive) {
-			for (let i = 0, len = this.cleanups.length; i < len; i++) this.cleanups[i]();
-			if (!this.done && this.options.onDone) {
-				this.options.onDone();
+			this.alive = false;
+			const options = this.options;
+			this.options = void 0;
+			this.plugins = void 0;
+			const cleanups = this.cleanups;
+			this.cleanups = [];
+			let failure;
+			for (let index = 0, length = cleanups.length; index < length; index++) try {
+				cleanups[index]();
+			} catch (error) {
+				failure ?? (failure = { value: error });
+			}
+			this.refs.clear();
+			if (!this.done) {
 				this.done = true;
+				try {
+					options?.onDone?.();
+				} catch (error) {
+					failure ?? (failure = { value: error });
+				}
 			}
-			this.alive = false;
+			if (failure) throw failure.value;
 		}
 	}
 };
@@ -3066,8 +3622,9 @@ var Serializer = class {
 //#region src/core/tree/index.ts
 function serialize(source, options = {}) {
 	const plugins = resolvePlugins(options.plugins);
-	const ctx = createSyncParserContext(1, {
+	const ctx = createSyncParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		disabledFeatures: options.disabledFeatures
 	});
@@ -3080,8 +3637,9 @@ function serialize(source, options = {}) {
 }
 async function serializeAsync(source, options = {}) {
 	const plugins = resolvePlugins(options.plugins);
-	const ctx = createAsyncParserContext(1, {
+	const ctx = createAsyncParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		disabledFeatures: options.disabledFeatures
 	});
@@ -3097,8 +3655,9 @@ function deserialize(source) {
 }
 function toJSON(source, options = {}) {
 	const plugins = resolvePlugins(options.plugins);
-	const ctx = createSyncParserContext(1, {
+	const ctx = createSyncParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		disabledFeatures: options.disabledFeatures
 	});
@@ -3110,8 +3669,9 @@ function toJSON(source, options = {}) {
 }
 async function toJSONAsync(source, options = {}) {
 	const plugins = resolvePlugins(options.plugins);
-	const ctx = createAsyncParserContext(1, {
+	const ctx = createAsyncParserContext({
 		compactArrayBufferViews: options.compactArrayBufferViews,
+		depthLimit: options.depthLimit,
 		plugins,
 		disabledFeatures: options.disabledFeatures
 	});
@@ -3129,11 +3689,11 @@ function compileJSON(source, options = {}) {
 	}), source.t);
 }
 function fromJSON(source, options = {}) {
-	var _source$f;
 	const plugins = resolvePlugins(options.plugins);
-	const disabledFeatures = options.disabledFeatures || 0;
-	const sourceFeatures = (_source$f = source.f) !== null && _source$f !== void 0 ? _source$f : 127;
+	const disabledFeatures = options.disabledFeatures ?? 0;
+	const sourceFeatures = source.f ?? 127;
 	return deserializeTop(createVanillaDeserializerContext({
+		depthLimit: options.depthLimit,
 		maxBase64Length: options.maxBase64Length,
 		plugins,
 		markedRefs: source.m,
@@ -3142,4 +3702,4 @@ function fromJSON(source, options = {}) {
 	}), source.t);
 }
 //#endregion
-export { Feature, OpaqueReference, Serializer, SerovalConflictedNodeIdError, SerovalDepthLimitError, SerovalDeserializationError, SerovalError, SerovalMalformedNodeError, SerovalMissingInstanceError, SerovalMissingPluginError, SerovalMissingReferenceError, SerovalMissingReferenceForIdError, SerovalMode, SerovalParserError, SerovalSerializationError, SerovalUnknownTypedArrayError, SerovalUnsupportedNodeError, SerovalUnsupportedTypeError, compileJSON, createPlugin, createReference, createStream, crossSerialize, crossSerializeAsync, crossSerializeStream, deserialize, fromCrossJSON, fromJSON, getCrossReferenceHeader, isStream, resolvePlugins, serialize, serializeAsync, toCrossJSON, toCrossJSONAsync, toCrossJSONStream, toJSON, toJSONAsync };
+export { Feature, LiveStream, OpaqueReference, Sequence, Serializer, SerovalAbortedError, SerovalConflictedNodeIdError, SerovalDepthLimitError, SerovalDeserializationError, SerovalError, SerovalLiveStreamError, SerovalMalformedNodeError, SerovalMissingInstanceError, SerovalMissingPluginError, SerovalMissingReferenceError, SerovalMissingReferenceForIdError, SerovalMode, SerovalParserError, SerovalSerializationError, SerovalUnknownTypedArrayError, SerovalUnsupportedNodeError, SerovalUnsupportedTypeError, Stream, compileJSON, createCrossDeserializer, createLiveStream, createPlugin, createReference, createStream, crossSerialize, crossSerializeAsync, crossSerializeStream, deserialize, fromCrossJSON, fromJSON, getCrossReferenceHeader, getPlainObjectPlugins, isLiveStream, isStream, resolvePlugins, serialize, serializeAsync, toCrossJSON, toCrossJSONAsync, toCrossJSONStream, toJSON, toJSONAsync };