seroval 1.4.0 → 1.4.2

package/dist/cjs/development/index.cjs

@@ -23,8 +23,11 @@ __export(src_exports, {
   Feature: () => Feature,
   OpaqueReference: () => OpaqueReference,
   Serializer: () => Serializer,
+  SerovalConflictedNodeIdError: () => SerovalConflictedNodeIdError,
+  SerovalDepthLimitError: () => SerovalDepthLimitError,
   SerovalDeserializationError: () => SerovalDeserializationError,
   SerovalError: () => SerovalError,
+  SerovalMalformedNodeError: () => SerovalMalformedNodeError,
   SerovalMissingInstanceError: () => SerovalMissingInstanceError,
   SerovalMissingPluginError: () => SerovalMissingPluginError,
   SerovalMissingReferenceError: () => SerovalMissingReferenceError,
@@ -64,9 +67,10 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
   Feature2[Feature2["ErrorPrototypeStack"] = 4] = "ErrorPrototypeStack";
   Feature2[Feature2["ObjectAssign"] = 8] = "ObjectAssign";
   Feature2[Feature2["BigIntTypedArray"] = 16] = "BigIntTypedArray";
+  Feature2[Feature2["RegExp"] = 32] = "RegExp";
   return Feature2;
 })(Feature || {});
-var ALL_ENABLED = 1 /* AggregateError */ | 2 /* ArrowFunction */ | 4 /* ErrorPrototypeStack */ | 8 /* ObjectAssign */ | 16 /* BigIntTypedArray */;
+var ALL_ENABLED = 1 /* AggregateError */ | 2 /* ArrowFunction */ | 4 /* ErrorPrototypeStack */ | 8 /* ObjectAssign */ | 16 /* BigIntTypedArray */ | 32 /* RegExp */;
 
 // src/core/symbols.ts
 var SYM_ASYNC_ITERATOR = Symbol.asyncIterator;
@@ -139,10 +143,11 @@ var CONSTANT_STRING = {
   [6 /* NegInf */]: "-1/0",
   [7 /* Nan */]: "0/0"
 };
+var NIL = void 0;
 var CONSTANT_VAL = {
   [2 /* True */]: true,
   [3 /* False */]: false,
-  [1 /* Undefined */]: void 0,
+  [1 /* Undefined */]: NIL,
   [0 /* Null */]: null,
   [4 /* NegZero */]: -0,
   [5 /* Inf */]: Number.POSITIVE_INFINITY,
@@ -167,15 +172,13 @@ var ERROR_CONSTRUCTOR = {
   [5 /* TypeError */]: TypeError,
   [6 /* URIError */]: URIError
 };
-var NIL = void 0;
 
 // src/core/node.ts
-function createSerovalNode(t, i, s, l, c, m, p, e, a, f, b, o) {
+function createSerovalNode(t, i, s, c, m, p, e, a, f, b, o, l) {
   return {
     t,
     i,
     s,
-    l,
     c,
     m,
     p,
@@ -183,7 +186,8 @@ function createSerovalNode(t, i, s, l, c, m, p, e, a, f, b, o) {
     a,
     f,
     b,
-    o
+    o,
+    l
   };
 }
 
@@ -251,7 +255,7 @@ function serializeChar(str) {
     case "\u2029":
       return "\\u2029";
     default:
-      return void 0;
+      return NIL;
   }
 }
 function serializeString(str) {
@@ -539,7 +543,6 @@ function createRegExpNode(id, current) {
     6 /* RegExp */,
     id,
     NIL,
-    NIL,
     serializeString(current.source),
     current.flags,
     NIL,
@@ -547,6 +550,7 @@ function createRegExpNode(id, current) {
     NIL,
     NIL,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -587,7 +591,6 @@ function createPluginNode(id, tag, value) {
     25 /* Plugin */,
     id,
     value,
-    NIL,
     serializeString(tag),
     NIL,
     NIL,
@@ -595,6 +598,7 @@ function createPluginNode(id, tag, value) {
     NIL,
     NIL,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -603,7 +607,6 @@ function createArrayNode(id, current, parsedItems) {
     9 /* Array */,
     id,
     NIL,
-    current.length,
     NIL,
     NIL,
     NIL,
@@ -611,7 +614,8 @@ function createArrayNode(id, current, parsedItems) {
     parsedItems,
     NIL,
     NIL,
-    getObjectFlag(current)
+    getObjectFlag(current),
+    NIL
   );
 }
 function createBoxedNode(id, boxed) {
@@ -624,9 +628,9 @@ function createBoxedNode(id, boxed) {
     NIL,
     NIL,
     NIL,
-    NIL,
     boxed,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -635,7 +639,6 @@ function createTypedArrayNode(id, current, buffer) {
     15 /* TypedArray */,
     id,
     NIL,
-    current.length,
     current.constructor.name,
     NIL,
     NIL,
@@ -643,7 +646,8 @@ function createTypedArrayNode(id, current, buffer) {
     NIL,
     buffer,
     current.byteOffset,
-    NIL
+    NIL,
+    current.length
   );
 }
 function createBigIntTypedArrayNode(id, current, buffer) {
@@ -651,7 +655,6 @@ function createBigIntTypedArrayNode(id, current, buffer) {
     16 /* BigIntTypedArray */,
     id,
     NIL,
-    current.length,
     current.constructor.name,
     NIL,
     NIL,
@@ -659,7 +662,8 @@ function createBigIntTypedArrayNode(id, current, buffer) {
     NIL,
     buffer,
     current.byteOffset,
-    NIL
+    NIL,
+    current.byteLength
   );
 }
 function createDataViewNode(id, current, buffer) {
@@ -667,7 +671,6 @@ function createDataViewNode(id, current, buffer) {
     20 /* DataView */,
     id,
     NIL,
-    current.byteLength,
     NIL,
     NIL,
     NIL,
@@ -675,7 +678,8 @@ function createDataViewNode(id, current, buffer) {
     NIL,
     buffer,
     current.byteOffset,
-    NIL
+    NIL,
+    current.byteLength
   );
 }
 function createErrorNode(id, current, options) {
@@ -684,13 +688,13 @@ function createErrorNode(id, current, options) {
     id,
     getErrorConstructor(current),
     NIL,
-    NIL,
     serializeString(current.message),
     options,
     NIL,
     NIL,
     NIL,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -700,22 +704,21 @@ function createAggregateErrorNode(id, current, options) {
     id,
     getErrorConstructor(current),
     NIL,
-    NIL,
     serializeString(current.message),
     options,
     NIL,
     NIL,
     NIL,
     NIL,
+    NIL,
     NIL
   );
 }
-function createSetNode(id, size, items) {
+function createSetNode(id, items) {
   return createSerovalNode(
     7 /* Set */,
     id,
     NIL,
-    size,
     NIL,
     NIL,
     NIL,
@@ -723,6 +726,7 @@ function createSetNode(id, size, items) {
     items,
     NIL,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -735,10 +739,10 @@ function createIteratorFactoryInstanceNode(factory, items) {
     NIL,
     NIL,
     NIL,
-    NIL,
     [factory, items],
     NIL,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -751,10 +755,10 @@ function createAsyncIteratorFactoryInstanceNode(factory, items) {
     NIL,
     NIL,
     NIL,
-    NIL,
     [factory, items],
     NIL,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -767,10 +771,10 @@ function createStreamConstructorNode(id, factory, sequence) {
     NIL,
     NIL,
     NIL,
-    NIL,
     sequence,
     factory,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -784,9 +788,9 @@ function createStreamNextNode(id, parsed) {
     NIL,
     NIL,
     NIL,
-    NIL,
     parsed,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -800,9 +804,9 @@ function createStreamThrowNode(id, parsed) {
     NIL,
     NIL,
     NIL,
-    NIL,
     parsed,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -816,9 +820,9 @@ function createStreamReturnNode(id, parsed) {
     NIL,
     NIL,
     NIL,
-    NIL,
     parsed,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -918,6 +922,27 @@ var SerovalUnknownTypedArrayError = class extends Error {
     );
   }
 };
+var SerovalMalformedNodeError = class extends Error {
+  constructor(node) {
+    super(
+      false ? getSpecificErrorMessage(8 /* MalformedNode */) : 'Malformed node type "' + node.t + '".'
+    );
+  }
+};
+var SerovalConflictedNodeIdError = class extends Error {
+  constructor(node) {
+    super(
+      false ? getSpecificErrorMessage(9 /* ConflictedNodeId */) : 'Conflicted node id "' + node.i + '".'
+    );
+  }
+};
+var SerovalDepthLimitError = class extends Error {
+  constructor(limit) {
+    super(
+      false ? getSpecificErrorMessage(9 /* ConflictedNodeId */) : "Depth limit of " + limit + " reached"
+    );
+  }
+};
 
 // src/core/opaque-reference.ts
 var OpaqueReference = class {
@@ -1127,8 +1152,9 @@ var ASYNC_ITERATOR_CONSTRUCTOR = (symbol, createPromise) => (stream) => () => {
   return instance;
 };
 var SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR = /* @__PURE__ */ ASYNC_ITERATOR_CONSTRUCTOR.toString();
-var ARRAY_BUFFER_CONSTRUCTOR = (length, b64) => {
+var ARRAY_BUFFER_CONSTRUCTOR = (b64) => {
   const decoded = atob(b64);
+  const length = decoded.length;
   const arr = new Uint8Array(length);
   for (let i = 0; i < length; i++) {
     arr[i] = decoded.charCodeAt(i);
@@ -1240,7 +1266,8 @@ function createBaseParserContext(mode, options) {
     mode,
     marked: /* @__PURE__ */ new Set(),
     features: ALL_ENABLED ^ (options.disabledFeatures || 0),
-    refs: options.refs || /* @__PURE__ */ new Map()
+    refs: options.refs || /* @__PURE__ */ new Map(),
+    depthLimit: options.depthLimit || 1e3
   };
 }
 function markParserRef(ctx, id) {
@@ -1322,9 +1349,9 @@ function parseIteratorFactory(ctx) {
     NIL,
     NIL,
     NIL,
-    NIL,
     parseWellKnownSymbol(ctx, SYM_ITERATOR),
     NIL,
+    NIL,
     NIL
   );
 }
@@ -1341,13 +1368,13 @@ function parseAsyncIteratorFactory(ctx) {
     NIL,
     NIL,
     NIL,
-    NIL,
     [
       parseSpecialReference(ctx, 1 /* PromiseConstructor */),
       parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR)
     ],
     NIL,
     NIL,
+    NIL,
     NIL
   );
 }
@@ -1358,16 +1385,16 @@ function createObjectNode(id, current, empty, record) {
     NIL,
     NIL,
     NIL,
-    NIL,
     record,
     NIL,
     NIL,
     NIL,
     NIL,
-    getObjectFlag(current)
+    getObjectFlag(current),
+    NIL
   );
 }
-function createMapNode(ctx, id, k, v, s) {
+function createMapNode(ctx, id, k, v) {
   return createSerovalNode(
     8 /* Map */,
     id,
@@ -1375,11 +1402,11 @@ function createMapNode(ctx, id, k, v, s) {
     NIL,
     NIL,
     NIL,
-    NIL,
-    { k, v, s },
+    { k, v },
     NIL,
     parseSpecialReference(ctx, 0 /* MapSentinel */),
     NIL,
+    NIL,
     NIL
   );
 }
@@ -1393,24 +1420,22 @@ function createPromiseConstructorNode(ctx, id, resolver) {
     NIL,
     NIL,
     NIL,
-    NIL,
     parseSpecialReference(ctx, 1 /* PromiseConstructor */),
     NIL,
+    NIL,
     NIL
   );
 }
 function createArrayBufferNode(ctx, id, current) {
   const bytes = new Uint8Array(current);
-  const len = bytes.length;
   let result = "";
-  for (let i = 0; i < len; i++) {
+  for (let i = 0, len = bytes.length; i < len; i++) {
     result += String.fromCharCode(bytes[i]);
   }
   return createSerovalNode(
     19 /* ArrayBuffer */,
     id,
     serializeString(btoa(result)),
-    len,
     NIL,
     NIL,
     NIL,
@@ -1418,6 +1443,7 @@ function createArrayBufferNode(ctx, id, current) {
     NIL,
     parseSpecialReference(ctx, 5 /* ArrayBufferConstructor */),
     NIL,
+    NIL,
     NIL
   );
 }
@@ -1430,32 +1456,35 @@ function createAsyncParserContext(mode, options) {
   };
 }
 var AsyncParsePluginContext = class {
-  constructor(_p) {
+  constructor(_p, depth) {
     this._p = _p;
+    this.depth = depth;
   }
   parse(current) {
-    return parseAsync(this._p, current);
+    return parseAsync(this._p, this.depth, current);
   }
 };
-async function parseItems(ctx, current) {
+async function parseItems(ctx, depth, current) {
   const nodes = [];
   for (let i = 0, len = current.length; i < len; i++) {
     if (i in current) {
-      nodes[i] = await parseAsync(ctx, current[i]);
+      nodes[i] = await parseAsync(ctx, depth, current[i]);
+    } else {
+      nodes[i] = 0;
     }
   }
   return nodes;
 }
-async function parseArray(ctx, id, current) {
-  return createArrayNode(id, current, await parseItems(ctx, current));
+async function parseArray(ctx, depth, id, current) {
+  return createArrayNode(id, current, await parseItems(ctx, depth, current));
 }
-async function parseProperties(ctx, properties) {
+async 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(await parseAsync(ctx, entries[i][1]));
+    valueNodes.push(await parseAsync(ctx, depth, entries[i][1]));
   }
   if (SYM_ITERATOR in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));
@@ -1464,6 +1493,7 @@ async function parseProperties(ctx, properties) {
         parseIteratorFactory(ctx.base),
         await parseAsync(
           ctx,
+          depth,
           iteratorToSequence(properties)
         )
       )
@@ -1476,6 +1506,7 @@ async function parseProperties(ctx, properties) {
         parseAsyncIteratorFactory(ctx.base),
         await parseAsync(
           ctx,
+          depth,
           createStreamFromAsyncIterable(
             properties
           )
@@ -1495,92 +1526,96 @@ async function parseProperties(ctx, properties) {
   }
   return {
     k: keyNodes,
-    v: valueNodes,
-    s: keyNodes.length
+    v: valueNodes
   };
 }
-async function parsePlainObject(ctx, id, current, empty) {
+async function parsePlainObject(ctx, depth, id, current, empty) {
   return createObjectNode(
     id,
     current,
     empty,
-    await parseProperties(ctx, current)
+    await parseProperties(ctx, depth, current)
   );
 }
-async function parseBoxed(ctx, id, current) {
-  return createBoxedNode(id, await parseAsync(ctx, current.valueOf()));
+async function parseBoxed(ctx, depth, id, current) {
+  return createBoxedNode(id, await parseAsync(ctx, depth, current.valueOf()));
 }
-async function parseTypedArray(ctx, id, current) {
+async function parseTypedArray(ctx, depth, id, current) {
   return createTypedArrayNode(
     id,
     current,
-    await parseAsync(ctx, current.buffer)
+    await parseAsync(ctx, depth, current.buffer)
   );
 }
-async function parseBigIntTypedArray(ctx, id, current) {
+async function parseBigIntTypedArray(ctx, depth, id, current) {
   return createBigIntTypedArrayNode(
     id,
     current,
-    await parseAsync(ctx, current.buffer)
+    await parseAsync(ctx, depth, current.buffer)
   );
 }
-async function parseDataView(ctx, id, current) {
-  return createDataViewNode(id, current, await parseAsync(ctx, current.buffer));
+async function parseDataView(ctx, depth, id, current) {
+  return createDataViewNode(
+    id,
+    current,
+    await parseAsync(ctx, depth, current.buffer)
+  );
 }
-async function parseError(ctx, id, current) {
+async function parseError(ctx, depth, id, current) {
   const options = getErrorOptions(current, ctx.base.features);
   return createErrorNode(
     id,
     current,
-    options ? await parseProperties(ctx, options) : NIL
+    options ? await parseProperties(ctx, depth, options) : NIL
   );
 }
-async function parseAggregateError(ctx, id, current) {
+async function parseAggregateError(ctx, depth, id, current) {
   const options = getErrorOptions(current, ctx.base.features);
   return createAggregateErrorNode(
     id,
     current,
-    options ? await parseProperties(ctx, options) : NIL
+    options ? await parseProperties(ctx, depth, options) : NIL
   );
 }
-async function parseMap(ctx, id, current) {
+async function parseMap(ctx, depth, id, current) {
   const keyNodes = [];
   const valueNodes = [];
   for (const [key, value] of current.entries()) {
-    keyNodes.push(await parseAsync(ctx, key));
-    valueNodes.push(await parseAsync(ctx, value));
+    keyNodes.push(await parseAsync(ctx, depth, key));
+    valueNodes.push(await parseAsync(ctx, depth, value));
   }
-  return createMapNode(ctx.base, id, keyNodes, valueNodes, current.size);
+  return createMapNode(ctx.base, id, keyNodes, valueNodes);
 }
-async function parseSet(ctx, id, current) {
+async function parseSet(ctx, depth, id, current) {
   const items = [];
   for (const item of current.keys()) {
-    items.push(await parseAsync(ctx, item));
+    items.push(await parseAsync(ctx, depth, item));
   }
-  return createSetNode(id, current.size, items);
+  return createSetNode(id, items);
 }
-async function parsePlugin(ctx, id, current) {
+async function parsePlugin(ctx, depth, id, current) {
   const currentPlugins = ctx.base.plugins;
   if (currentPlugins) {
     for (let i = 0, len = currentPlugins.length; i < len; i++) {
       const plugin = currentPlugins[i];
       if (plugin.parse.async && plugin.test(current)) {
-        if (ctx.child == null) {
-          ctx.child = new AsyncParsePluginContext(ctx);
-        }
         return createPluginNode(
           id,
           plugin.tag,
-          await plugin.parse.async(current, ctx.child, {
-            id
-          })
+          await plugin.parse.async(
+            current,
+            new AsyncParsePluginContext(ctx, depth),
+            {
+              id
+            }
+          )
         );
       }
     }
   }
   return NIL;
 }
-async function parsePromise(ctx, id, current) {
+async function parsePromise(ctx, depth, id, current) {
   const [status, result] = await promiseToResult(current);
   return createSerovalNode(
     12 /* Promise */,
@@ -1591,18 +1626,18 @@ async function parsePromise(ctx, id, current) {
     NIL,
     NIL,
     NIL,
+    await parseAsync(ctx, depth, result),
     NIL,
-    await parseAsync(ctx, result),
     NIL,
     NIL
   );
 }
-function parseStreamHandle(id, current, resolve, reject) {
+function parseStreamHandle(depth, id, current, resolve, reject) {
   const sequence = [];
   const cleanup = current.on({
     next: (value) => {
       markParserRef(this.base, id);
-      parseAsync(this, value).then(
+      parseAsync(this, depth, value).then(
         (data) => {
           sequence.push(createStreamNextNode(id, data));
         },
@@ -1614,7 +1649,7 @@ function parseStreamHandle(id, current, resolve, reject) {
     },
     throw: (value) => {
       markParserRef(this.base, id);
-      parseAsync(this, value).then(
+      parseAsync(this, depth, value).then(
         (data) => {
           sequence.push(createStreamThrowNode(id, data));
           resolve(sequence);
@@ -1628,7 +1663,7 @@ function parseStreamHandle(id, current, resolve, reject) {
     },
     return: (value) => {
       markParserRef(this.base, id);
-      parseAsync(this, value).then(
+      parseAsync(this, depth, value).then(
         (data) => {
           sequence.push(createStreamReturnNode(id, data));
           resolve(sequence);
@@ -1642,28 +1677,31 @@ function parseStreamHandle(id, current, resolve, reject) {
     }
   });
 }
-async function parseStream(ctx, id, current) {
+async function parseStream(ctx, depth, id, current) {
   return createStreamConstructorNode(
     id,
     parseSpecialReference(ctx.base, 4 /* StreamConstructor */),
-    await new Promise(parseStreamHandle.bind(ctx, id, current))
+    await new Promise(
+      parseStreamHandle.bind(ctx, depth, id, current)
+    )
   );
 }
-async function parseObjectAsync(ctx, id, current) {
+async function parseObjectAsync(ctx, depth, id, current) {
   if (Array.isArray(current)) {
-    return parseArray(ctx, id, current);
+    return parseArray(ctx, depth, id, current);
   }
   if (isStream(current)) {
-    return parseStream(ctx, id, current);
+    return parseStream(ctx, depth, id, current);
   }
   const currentClass = current.constructor;
   if (currentClass === OpaqueReference) {
     return parseAsync(
       ctx,
+      depth,
       current.replacement
     );
   }
-  const parsed = await parsePlugin(ctx, id, current);
+  const parsed = await parsePlugin(ctx, depth, id, current);
   if (parsed) {
     return parsed;
   }
@@ -1671,6 +1709,7 @@ async function parseObjectAsync(ctx, id, current) {
     case Object:
       return parsePlainObject(
         ctx,
+        depth,
         id,
         current,
         false
@@ -1678,14 +1717,13 @@ async function parseObjectAsync(ctx, id, current) {
     case NIL:
       return parsePlainObject(
         ctx,
+        depth,
         id,
         current,
         true
       );
     case Date:
       return createDateNode(id, current);
-    case RegExp:
-      return createRegExpNode(id, current);
     case Error:
     case EvalError:
     case RangeError:
@@ -1693,12 +1731,12 @@ async function parseObjectAsync(ctx, id, current) {
     case SyntaxError:
     case TypeError:
     case URIError:
-      return parseError(ctx, id, current);
+      return parseError(ctx, depth, id, current);
     case Number:
     case Boolean:
     case String:
     case BigInt:
-      return parseBoxed(ctx, id, current);
+      return parseBoxed(ctx, depth, id, current);
     case ArrayBuffer:
       return createArrayBufferNode(
         ctx.base,
@@ -1714,26 +1752,40 @@ async function parseObjectAsync(ctx, id, current) {
     case Uint8ClampedArray:
     case Float32Array:
     case Float64Array:
-      return parseTypedArray(ctx, id, current);
+      return parseTypedArray(
+        ctx,
+        depth,
+        id,
+        current
+      );
     case DataView:
-      return parseDataView(ctx, id, current);
+      return parseDataView(ctx, depth, id, current);
     case Map:
-      return parseMap(ctx, id, current);
+      return parseMap(
+        ctx,
+        depth,
+        id,
+        current
+      );
     case Set:
-      return parseSet(ctx, id, current);
+      return parseSet(ctx, depth, id, current);
     default:
       break;
   }
   if (currentClass === Promise || current instanceof Promise) {
-    return parsePromise(ctx, id, current);
+    return parsePromise(ctx, depth, id, current);
   }
   const currentFeatures = ctx.base.features;
+  if (currentFeatures & 32 /* RegExp */ && currentClass === RegExp) {
+    return createRegExpNode(id, current);
+  }
   if (currentFeatures & 16 /* BigIntTypedArray */) {
     switch (currentClass) {
       case BigInt64Array:
       case BigUint64Array:
         return parseBigIntTypedArray(
           ctx,
+          depth,
           id,
           current
         );
@@ -1742,28 +1794,33 @@ async function parseObjectAsync(ctx, id, current) {
     }
   }
   if (currentFeatures & 1 /* AggregateError */ && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) {
-    return parseAggregateError(ctx, id, current);
+    return parseAggregateError(
+      ctx,
+      depth,
+      id,
+      current
+    );
   }
   if (current instanceof Error) {
-    return parseError(ctx, id, current);
+    return parseError(ctx, depth, id, current);
   }
   if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) {
-    return parsePlainObject(ctx, id, current, !!currentClass);
+    return parsePlainObject(ctx, depth, id, current, !!currentClass);
   }
   throw new SerovalUnsupportedTypeError(current);
 }
-async function parseFunctionAsync(ctx, current) {
+async function parseFunctionAsync(ctx, depth, current) {
   const ref = getReferenceNode(ctx.base, current);
   if (ref.type !== 0 /* Fresh */) {
     return ref.value;
   }
-  const plugin = await parsePlugin(ctx, ref.value, current);
+  const plugin = await parsePlugin(ctx, depth, ref.value, current);
   if (plugin) {
     return plugin;
   }
   throw new SerovalUnsupportedTypeError(current);
 }
-async function parseAsync(ctx, current) {
+async function parseAsync(ctx, depth, current) {
   switch (typeof current) {
     case "boolean":
       return current ? TRUE_NODE : FALSE_NODE;
@@ -1778,21 +1835,21 @@ async function parseAsync(ctx, current) {
     case "object": {
       if (current) {
         const ref = getReferenceNode(ctx.base, current);
-        return ref.type === 0 ? await parseObjectAsync(ctx, ref.value, current) : ref.value;
+        return ref.type === 0 ? await parseObjectAsync(ctx, depth + 1, ref.value, current) : ref.value;
       }
       return NULL_NODE;
     }
     case "symbol":
       return parseWellKnownSymbol(ctx.base, current);
     case "function":
-      return parseFunctionAsync(ctx, current);
+      return parseFunctionAsync(ctx, depth, current);
     default:
       throw new SerovalUnsupportedTypeError(current);
   }
 }
 async function parseTopAsync(ctx, current) {
   try {
-    return await parseAsync(ctx, current);
+    return await parseAsync(ctx, 0, current);
   } catch (error) {
     throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
   }
@@ -1858,6 +1915,9 @@ function getTypedArrayConstructor(name) {
 }
 
 // src/core/context/deserializer.ts
+var MAX_BASE64_LENGTH = 1e6;
+var MAX_BIGINT_LENGTH = 1e4;
+var MAX_REGEXP_SOURCE_LENGTH = 2e4;
 function applyObjectFlag(obj, flag) {
   switch (flag) {
     case 3 /* Frozen */:
@@ -1870,18 +1930,22 @@ function applyObjectFlag(obj, flag) {
       return obj;
   }
 }
+var DEFAULT_DEPTH_LIMIT = 1e3;
 function createBaseDeserializerContext(mode, options) {
+  var _a;
   return {
     mode,
     plugins: options.plugins,
-    refs: options.refs || /* @__PURE__ */ new Map()
+    refs: options.refs || /* @__PURE__ */ new Map(),
+    features: (_a = options.features) != null ? _a : ALL_ENABLED ^ (options.disabledFeatures || 0),
+    depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT
   };
 }
 function createVanillaDeserializerContext(options) {
   return {
     mode: 1 /* Vanilla */,
     base: createBaseDeserializerContext(1 /* Vanilla */, options),
-    child: void 0,
+    child: NIL,
     state: {
       marked: new Set(options.markedRefs)
     }
@@ -1891,32 +1955,50 @@ function createCrossDeserializerContext(options) {
   return {
     mode: 2 /* Cross */,
     base: createBaseDeserializerContext(2 /* Cross */, options),
-    child: void 0
+    child: NIL
   };
 }
 var DeserializePluginContext = class {
-  constructor(_p) {
+  constructor(_p, depth) {
     this._p = _p;
+    this.depth = depth;
   }
   deserialize(node) {
-    return deserialize(this._p, node);
+    return deserialize(this._p, this.depth, node);
   }
 };
+function guardIndexedValue(ctx, id) {
+  if (id < 0 || !Number.isFinite(id) || !Number.isInteger(id)) {
+    throw new SerovalMalformedNodeError({
+      t: 4 /* IndexedValue */,
+      i: id
+    });
+  }
+  if (ctx.refs.has(id)) {
+    throw new Error("Conflicted ref id: " + id);
+  }
+}
 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) {
-  if (!ctx.base.refs.has(id)) {
-    ctx.base.refs.set(id, value);
-  }
+  guardIndexedValue(ctx.base, id);
+  ctx.base.refs.set(id, value);
   return value;
 }
 function assignIndexedValue(ctx, id, value) {
   return ctx.mode === 1 /* Vanilla */ ? 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);
+}
 function deserializeReference(ctx, node) {
   return assignIndexedValue(
     ctx,
@@ -1924,46 +2006,96 @@ function deserializeReference(ctx, node) {
     getReference(deserializeString(node.s))
   );
 }
-function deserializeArray(ctx, node) {
-  const len = node.l;
+function deserializeArray(ctx, depth, node) {
+  const items = node.a;
+  const len = items.length;
   const result = assignIndexedValue(
     ctx,
     node.i,
     new Array(len)
   );
-  let item;
-  for (let i = 0; i < len; i++) {
-    item = node.a[i];
+  for (let i = 0, item; i < len; i++) {
+    item = items[i];
     if (item) {
-      result[i] = deserialize(ctx, item);
+      result[i] = deserialize(ctx, depth, item);
     }
   }
   applyObjectFlag(result, node.o);
   return result;
 }
-function deserializeProperties(ctx, node, result) {
-  const len = node.s;
-  if (len) {
-    const keys = node.k;
-    const vals = node.v;
-    for (let i = 0, key; i < len; i++) {
-      key = keys[i];
-      if (typeof key === "string") {
-        result[deserializeString(key)] = deserialize(ctx, vals[i]);
-      } else {
-        result[deserialize(ctx, key)] = deserialize(ctx, vals[i]);
-      }
+function isValidKey(key) {
+  switch (key) {
+    case "constructor":
+    case "__proto__":
+    case "prototype":
+    case "__defineGetter__":
+    case "__defineSetter__":
+    case "__lookupGetter__":
+    case "__lookupSetter__":
+      return false;
+    default:
+      return true;
+  }
+}
+function isValidSymbol(symbol) {
+  switch (symbol) {
+    case SYM_ASYNC_ITERATOR:
+    case SYM_IS_CONCAT_SPREADABLE:
+    case SYM_TO_STRING_TAG:
+    case SYM_ITERATOR:
+      return true;
+    default:
+      return false;
+  }
+}
+function assignStringProperty(object, key, value) {
+  if (isValidKey(key)) {
+    object[key] = value;
+  } else {
+    Object.defineProperty(object, key, {
+      value,
+      configurable: true,
+      enumerable: true,
+      writable: true
+    });
+  }
+}
+function assignProperty(ctx, depth, object, key, value) {
+  if (typeof key === "string") {
+    assignStringProperty(object, key, deserialize(ctx, depth, value));
+  } else {
+    const actual = deserialize(ctx, depth, key);
+    switch (typeof actual) {
+      case "string":
+        assignStringProperty(object, actual, deserialize(ctx, depth, value));
+        break;
+      case "symbol":
+        if (isValidSymbol(actual)) {
+          object[actual] = deserialize(ctx, depth, value);
+        }
+        break;
+      default:
+        throw new SerovalMalformedNodeError(key);
+    }
+  }
+}
+function deserializeProperties(ctx, depth, node, result) {
+  const keys = node.k;
+  const len = keys.length;
+  if (len > 0) {
+    for (let i = 0, vals = node.v, len2 = keys.length; i < len2; i++) {
+      assignProperty(ctx, depth, result, keys[i], vals[i]);
     }
   }
   return result;
 }
-function deserializeObject(ctx, node) {
+function deserializeObject(ctx, depth, node) {
   const result = assignIndexedValue(
     ctx,
     node.i,
     node.t === 10 /* Object */ ? {} : /* @__PURE__ */ Object.create(null)
   );
-  deserializeProperties(ctx, node.p, result);
+  deserializeProperties(ctx, depth, node.p, result);
   applyObjectFlag(result, node.o);
   return result;
 }
@@ -1971,84 +2103,100 @@ function deserializeDate(ctx, node) {
   return assignIndexedValue(ctx, node.i, new Date(node.s));
 }
 function deserializeRegExp(ctx, node) {
-  return assignIndexedValue(
-    ctx,
-    node.i,
-    new RegExp(deserializeString(node.c), node.m)
-  );
+  if (ctx.base.features & 32 /* RegExp */) {
+    const source = deserializeString(node.c);
+    if (source.length > MAX_REGEXP_SOURCE_LENGTH) {
+      throw new SerovalMalformedNodeError(node);
+    }
+    return assignIndexedValue(ctx, node.i, new RegExp(source, node.m));
+  }
+  throw new SerovalUnsupportedNodeError(node);
 }
-function deserializeSet(ctx, node) {
+function deserializeSet(ctx, depth, node) {
   const result = assignIndexedValue(ctx, node.i, /* @__PURE__ */ new Set());
-  const items = node.a;
-  for (let i = 0, len = node.l; i < len; i++) {
-    result.add(deserialize(ctx, items[i]));
+  for (let i = 0, items = node.a, len = items.length; i < len; i++) {
+    result.add(deserialize(ctx, depth, items[i]));
   }
   return result;
 }
-function deserializeMap(ctx, node) {
+function deserializeMap(ctx, depth, node) {
   const result = assignIndexedValue(ctx, node.i, /* @__PURE__ */ new Map());
-  const keys = node.e.k;
-  const vals = node.e.v;
-  for (let i = 0, len = node.e.s; i < len; i++) {
-    result.set(deserialize(ctx, keys[i]), deserialize(ctx, vals[i]));
+  for (let i = 0, keys = node.e.k, vals = node.e.v, len = keys.length; i < len; i++) {
+    result.set(
+      deserialize(ctx, depth, keys[i]),
+      deserialize(ctx, depth, vals[i])
+    );
   }
   return result;
 }
 function deserializeArrayBuffer(ctx, node) {
+  if (node.s.length > MAX_BASE64_LENGTH) {
+    throw new SerovalMalformedNodeError(node);
+  }
   const result = assignIndexedValue(
     ctx,
     node.i,
-    ARRAY_BUFFER_CONSTRUCTOR(node.l, deserializeString(node.s))
+    ARRAY_BUFFER_CONSTRUCTOR(deserializeString(node.s))
   );
   return result;
 }
-function deserializeTypedArray(ctx, node) {
+function deserializeTypedArray(ctx, depth, node) {
+  var _a;
   const construct = getTypedArrayConstructor(node.c);
-  const source = deserialize(ctx, node.f);
+  const source = deserialize(ctx, depth, node.f);
+  const offset = (_a = node.b) != null ? _a : 0;
+  if (offset < 0 || offset > source.byteLength) {
+    throw new SerovalMalformedNodeError(node);
+  }
   const result = assignIndexedValue(
     ctx,
     node.i,
-    new construct(source, node.b, node.l)
+    new construct(source, offset, node.l)
   );
   return result;
 }
-function deserializeDataView(ctx, node) {
-  const source = deserialize(ctx, node.f);
+function deserializeDataView(ctx, depth, node) {
+  var _a;
+  const source = deserialize(ctx, depth, node.f);
+  const offset = (_a = node.b) != null ? _a : 0;
+  if (offset < 0 || offset > source.byteLength) {
+    throw new SerovalMalformedNodeError(node);
+  }
   const result = assignIndexedValue(
     ctx,
     node.i,
-    new DataView(source, node.b, node.l)
+    new DataView(source, offset, node.l)
   );
   return result;
 }
-function deserializeDictionary(ctx, node, result) {
+function deserializeDictionary(ctx, depth, node, result) {
   if (node.p) {
-    const fields = deserializeProperties(ctx, node.p, {});
-    Object.assign(result, fields);
+    const fields = deserializeProperties(ctx, depth, node.p, {});
+    Object.defineProperties(result, Object.getOwnPropertyDescriptors(fields));
   }
   return result;
 }
-function deserializeAggregateError(ctx, node) {
+function deserializeAggregateError(ctx, depth, node) {
   const result = assignIndexedValue(
     ctx,
     node.i,
     new AggregateError([], deserializeString(node.m))
   );
-  return deserializeDictionary(ctx, node, result);
+  return deserializeDictionary(ctx, depth, node, result);
 }
-function deserializeError(ctx, node) {
-  const construct = ERROR_CONSTRUCTOR[node.s];
+function deserializeError(ctx, depth, node) {
+  const construct = deserializeKnownValue(node, ERROR_CONSTRUCTOR, node.s);
   const result = assignIndexedValue(
     ctx,
     node.i,
     new construct(deserializeString(node.m))
   );
-  return deserializeDictionary(ctx, node, result);
+  return deserializeDictionary(ctx, depth, node, result);
 }
-function deserializePromise(ctx, node) {
+function deserializePromise(ctx, depth, node) {
   const deferred = PROMISE_CONSTRUCTOR();
   const result = assignIndexedValue(ctx, node.i, deferred.p);
-  const deserialized = deserialize(ctx, node.f);
+  const deserialized = deserialize(ctx, depth, node.f);
   if (node.s) {
     deferred.s(deserialized);
   } else {
@@ -2056,23 +2204,25 @@ function deserializePromise(ctx, node) {
   }
   return result;
 }
-function deserializeBoxed(ctx, node) {
-  return assignIndexedValue(ctx, node.i, Object(deserialize(ctx, node.f)));
+function deserializeBoxed(ctx, depth, node) {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    // biome-ignore lint/style/useConsistentBuiltinInstantiation: intended
+    Object(deserialize(ctx, depth, node.f))
+  );
 }
-function deserializePlugin(ctx, node) {
+function deserializePlugin(ctx, depth, node) {
   const currentPlugins = ctx.base.plugins;
   if (currentPlugins) {
     const tag = deserializeString(node.c);
     for (let i = 0, len = currentPlugins.length; i < len; i++) {
       const plugin = currentPlugins[i];
       if (plugin.tag === tag) {
-        if (ctx.child == null) {
-          ctx.child = new DeserializePluginContext(ctx);
-        }
         return assignIndexedValue(
           ctx,
           node.i,
-          plugin.deserialize(node.s, ctx.child, {
+          plugin.deserialize(node.s, new DeserializePluginContext(ctx, depth), {
             id: node.i
           })
         );
@@ -2088,142 +2238,150 @@ function deserializePromiseConstructor(ctx, node) {
     assignIndexedValue(ctx, node.s, PROMISE_CONSTRUCTOR()).p
   );
 }
-function deserializePromiseResolve(ctx, node) {
+function deserializePromiseResolve(ctx, depth, node) {
   const deferred = ctx.base.refs.get(node.i);
   if (deferred) {
-    deferred.s(deserialize(ctx, node.a[1]));
-    return void 0;
+    deferred.s(deserialize(ctx, depth, node.a[1]));
+    return NIL;
   }
   throw new SerovalMissingInstanceError("Promise");
 }
-function deserializePromiseReject(ctx, node) {
+function deserializePromiseReject(ctx, depth, node) {
   const deferred = ctx.base.refs.get(node.i);
   if (deferred) {
-    deferred.f(deserialize(ctx, node.a[1]));
-    return void 0;
+    deferred.f(deserialize(ctx, depth, node.a[1]));
+    return NIL;
   }
   throw new SerovalMissingInstanceError("Promise");
 }
-function deserializeIteratorFactoryInstance(ctx, node) {
-  deserialize(ctx, node.a[0]);
-  const source = deserialize(ctx, node.a[1]);
+function deserializeIteratorFactoryInstance(ctx, depth, node) {
+  deserialize(ctx, depth, node.a[0]);
+  const source = deserialize(ctx, depth, node.a[1]);
   return sequenceToIterator(source);
 }
-function deserializeAsyncIteratorFactoryInstance(ctx, node) {
-  deserialize(ctx, node.a[0]);
-  const source = deserialize(ctx, node.a[1]);
+function deserializeAsyncIteratorFactoryInstance(ctx, depth, node) {
+  deserialize(ctx, depth, node.a[0]);
+  const source = deserialize(ctx, depth, node.a[1]);
   return streamToAsyncIterable(source);
 }
-function deserializeStreamConstructor(ctx, node) {
+function deserializeStreamConstructor(ctx, depth, node) {
   const result = assignIndexedValue(ctx, node.i, createStream());
-  const len = node.a.length;
+  const items = node.a;
+  const len = items.length;
   if (len) {
     for (let i = 0; i < len; i++) {
-      deserialize(ctx, node.a[i]);
+      deserialize(ctx, depth, items[i]);
     }
   }
   return result;
 }
-function deserializeStreamNext(ctx, node) {
+function deserializeStreamNext(ctx, depth, node) {
   const deferred = ctx.base.refs.get(node.i);
-  if (deferred) {
-    deferred.next(deserialize(ctx, node.f));
-    return void 0;
+  if (deferred && isStream(deferred)) {
+    deferred.next(deserialize(ctx, depth, node.f));
+    return NIL;
   }
   throw new SerovalMissingInstanceError("Stream");
 }
-function deserializeStreamThrow(ctx, node) {
+function deserializeStreamThrow(ctx, depth, node) {
   const deferred = ctx.base.refs.get(node.i);
-  if (deferred) {
-    deferred.throw(deserialize(ctx, node.f));
-    return void 0;
+  if (deferred && isStream(deferred)) {
+    deferred.throw(deserialize(ctx, depth, node.f));
+    return NIL;
   }
   throw new SerovalMissingInstanceError("Stream");
 }
-function deserializeStreamReturn(ctx, node) {
+function deserializeStreamReturn(ctx, depth, node) {
   const deferred = ctx.base.refs.get(node.i);
-  if (deferred) {
-    deferred.return(deserialize(ctx, node.f));
-    return void 0;
+  if (deferred && isStream(deferred)) {
+    deferred.return(deserialize(ctx, depth, node.f));
+    return NIL;
   }
   throw new SerovalMissingInstanceError("Stream");
 }
-function deserializeIteratorFactory(ctx, node) {
-  deserialize(ctx, node.f);
-  return void 0;
+function deserializeIteratorFactory(ctx, depth, node) {
+  deserialize(ctx, depth, node.f);
+  return NIL;
 }
-function deserializeAsyncIteratorFactory(ctx, node) {
-  deserialize(ctx, node.a[1]);
-  return void 0;
+function deserializeAsyncIteratorFactory(ctx, depth, node) {
+  deserialize(ctx, depth, node.a[1]);
+  return NIL;
 }
-function deserialize(ctx, node) {
+function deserialize(ctx, depth, node) {
+  if (depth > ctx.base.depthLimit) {
+    throw new SerovalDepthLimitError(ctx.base.depthLimit);
+  }
+  depth += 1;
   switch (node.t) {
     case 2 /* Constant */:
-      return CONSTANT_VAL[node.s];
+      return deserializeKnownValue(node, CONSTANT_VAL, node.s);
     case 0 /* Number */:
-      return node.s;
+      return Number(node.s);
     case 1 /* String */:
-      return deserializeString(node.s);
+      return deserializeString(String(node.s));
     case 3 /* BigInt */:
+      if (String(node.s).length > MAX_BIGINT_LENGTH) {
+        throw new SerovalMalformedNodeError(node);
+      }
       return BigInt(node.s);
     case 4 /* IndexedValue */:
       return ctx.base.refs.get(node.i);
     case 18 /* Reference */:
       return deserializeReference(ctx, node);
     case 9 /* Array */:
-      return deserializeArray(ctx, node);
+      return deserializeArray(ctx, depth, node);
     case 10 /* Object */:
     case 11 /* NullConstructor */:
-      return deserializeObject(ctx, node);
+      return deserializeObject(ctx, depth, node);
     case 5 /* Date */:
       return deserializeDate(ctx, node);
     case 6 /* RegExp */:
       return deserializeRegExp(ctx, node);
     case 7 /* Set */:
-      return deserializeSet(ctx, node);
+      return deserializeSet(ctx, depth, node);
     case 8 /* Map */:
-      return deserializeMap(ctx, node);
+      return deserializeMap(ctx, depth, node);
     case 19 /* ArrayBuffer */:
       return deserializeArrayBuffer(ctx, node);
     case 16 /* BigIntTypedArray */:
     case 15 /* TypedArray */:
-      return deserializeTypedArray(ctx, node);
+      return deserializeTypedArray(ctx, depth, node);
     case 20 /* DataView */:
-      return deserializeDataView(ctx, node);
+      return deserializeDataView(ctx, depth, node);
     case 14 /* AggregateError */:
-      return deserializeAggregateError(ctx, node);
+      return deserializeAggregateError(ctx, depth, node);
     case 13 /* Error */:
-      return deserializeError(ctx, node);
+      return deserializeError(ctx, depth, node);
     case 12 /* Promise */:
-      return deserializePromise(ctx, node);
+      return deserializePromise(ctx, depth, node);
     case 17 /* WKSymbol */:
-      return SYMBOL_REF[node.s];
+      return deserializeKnownValue(node, SYMBOL_REF, node.s);
     case 21 /* Boxed */:
-      return deserializeBoxed(ctx, node);
+      return deserializeBoxed(ctx, depth, node);
     case 25 /* Plugin */:
-      return deserializePlugin(ctx, node);
+      return deserializePlugin(ctx, depth, node);
     case 22 /* PromiseConstructor */:
       return deserializePromiseConstructor(ctx, node);
     case 23 /* PromiseSuccess */:
-      return deserializePromiseResolve(ctx, node);
+      return deserializePromiseResolve(ctx, depth, node);
     case 24 /* PromiseFailure */:
-      return deserializePromiseReject(ctx, node);
+      return deserializePromiseReject(ctx, depth, node);
     case 28 /* IteratorFactoryInstance */:
-      return deserializeIteratorFactoryInstance(ctx, node);
+      return deserializeIteratorFactoryInstance(ctx, depth, node);
     case 30 /* AsyncIteratorFactoryInstance */:
-      return deserializeAsyncIteratorFactoryInstance(ctx, node);
+      return deserializeAsyncIteratorFactoryInstance(ctx, depth, node);
     case 31 /* StreamConstructor */:
-      return deserializeStreamConstructor(ctx, node);
+      return deserializeStreamConstructor(ctx, depth, node);
     case 32 /* StreamNext */:
-      return deserializeStreamNext(ctx, node);
+      return deserializeStreamNext(ctx, depth, node);
     case 33 /* StreamThrow */:
-      return deserializeStreamThrow(ctx, node);
+      return deserializeStreamThrow(ctx, depth, node);
     case 34 /* StreamReturn */:
-      return deserializeStreamReturn(ctx, node);
+      return deserializeStreamReturn(ctx, depth, node);
     case 27 /* IteratorFactory */:
-      return deserializeIteratorFactory(ctx, node);
+      return deserializeIteratorFactory(ctx, depth, node);
     case 29 /* AsyncIteratorFactory */:
-      return deserializeAsyncIteratorFactory(ctx, node);
+      return deserializeAsyncIteratorFactory(ctx, depth, node);
     // case SerovalNodeType.SpecialReference:
     default:
       throw new SerovalUnsupportedNodeError(node);
@@ -2231,7 +2389,7 @@ function deserialize(ctx, node) {
 }
 function deserializeTop(ctx, node) {
   try {
-    return deserialize(ctx, node);
+    return deserialize(ctx, 0, node);
   } catch (error) {
     throw new SerovalDeserializationError(error);
   }
@@ -2379,7 +2537,7 @@ function createVanillaSerializerContext(options) {
     mode: 1 /* Vanilla */,
     base: createBaseSerializerContext(1 /* Vanilla */, options),
     state: createVanillaSerializerState(),
-    child: void 0
+    child: NIL
   };
 }
 function createCrossSerializerContext(options) {
@@ -2387,7 +2545,7 @@ function createCrossSerializerContext(options) {
     mode: 2 /* Cross */,
     base: createBaseSerializerContext(2 /* Cross */, options),
     state: options,
-    child: void 0
+    child: NIL
   };
 }
 var SerializePluginContext = class {
@@ -2519,12 +2677,13 @@ function serializeArrayItem(ctx, id, item, index) {
 }
 function serializeArray(ctx, node) {
   const id = node.i;
-  if (node.l) {
+  const list = node.a;
+  const len = list.length;
+  if (len > 0) {
     ctx.base.stack.push(id);
-    const list = node.a;
     let values = serializeArrayItem(ctx, id, list[0], 0);
     let isHoley = values === "";
-    for (let i = 1, len = node.l, item; i < len; i++) {
+    for (let i = 1, item; i < len; i++) {
       item = serializeArrayItem(ctx, id, list[i], i);
       values += "," + item;
       isHoley = item === "";
@@ -2570,9 +2729,9 @@ function serializeProperty(ctx, source, key, val) {
   return "[" + serialize(ctx, key) + "]:" + serialize(ctx, val);
 }
 function serializeProperties(ctx, source, record) {
-  const len = record.s;
-  if (len) {
-    const keys = record.k;
+  const keys = record.k;
+  const len = keys.length;
+  if (len > 0) {
     const values = record.v;
     ctx.base.stack.push(source.i);
     let result = serializeProperty(ctx, source, keys[0], values[0]);
@@ -2655,10 +2814,10 @@ function serializeAssignment(ctx, source, mainAssignments, key, value) {
   }
 }
 function serializeAssignments(ctx, source, node) {
-  const len = node.s;
-  if (len) {
+  const keys = node.k;
+  const len = keys.length;
+  if (len > 0) {
     const mainAssignments = [];
-    const keys = node.k;
     const values = node.v;
     ctx.base.stack.push(source.i);
     for (let i = 0; i < len; i++) {
@@ -2691,8 +2850,11 @@ function serializeNullConstructor(ctx, node) {
 function serializeDate(node) {
   return 'new Date("' + node.s + '")';
 }
-function serializeRegExp(node) {
-  return "/" + node.c + "/" + node.m;
+function serializeRegExp(ctx, node) {
+  if (ctx.base.features & 32 /* RegExp */) {
+    return "/" + node.c + "/" + node.m;
+  }
+  throw new SerovalUnsupportedNodeError(node);
 }
 function serializeSetItem(ctx, id, item) {
   const base = ctx.base;
@@ -2709,10 +2871,10 @@ function serializeSetItem(ctx, id, item) {
 }
 function serializeSet(ctx, node) {
   let serialized = SET_CONSTRUCTOR;
-  const size = node.l;
+  const items = node.a;
+  const size = items.length;
   const id = node.i;
-  if (size) {
-    const items = node.a;
+  if (size > 0) {
     ctx.base.stack.push(id);
     let result = serializeSetItem(ctx, id, items[0]);
     for (let i = 1, item = result; i < size; i++) {
@@ -2767,13 +2929,13 @@ function serializeMapEntry(ctx, id, key, val, sentinel) {
 }
 function serializeMap(ctx, node) {
   let serialized = MAP_CONSTRUCTOR;
-  const size = node.e.s;
+  const keys = node.e.k;
+  const size = keys.length;
   const id = node.i;
   const sentinel = node.f;
   const sentinelId = getRefParam(ctx, sentinel.i);
   const base = ctx.base;
-  if (size) {
-    const keys = node.e.k;
+  if (size > 0) {
     const vals = node.e.v;
     base.stack.push(id);
     let result = serializeMapEntry(ctx, id, keys[0], vals[0], sentinelId);
@@ -2793,7 +2955,7 @@ function serializeMap(ctx, node) {
   return serialized;
 }
 function serializeArrayBuffer(ctx, node) {
-  return getConstructor(ctx, node.f) + "(" + node.l + ',"' + node.s + '")';
+  return getConstructor(ctx, node.f) + '("' + node.s + '")';
 }
 function serializeTypedArray(ctx, node) {
   return "new " + node.c + "(" + serialize(ctx, node.f) + "," + node.b + "," + node.l + ")";
@@ -2973,7 +3135,7 @@ function serializeAssignable(ctx, node) {
     case 5 /* Date */:
       return serializeDate(node);
     case 6 /* RegExp */:
-      return serializeRegExp(node);
+      return serializeRegExp(ctx, node);
     case 7 /* Set */:
       return serializeSet(ctx, node);
     case 8 /* Map */:
@@ -3085,26 +3247,28 @@ function createSyncParserContext(mode, options) {
   return {
     type: 1 /* Sync */,
     base: createBaseParserContext(mode, options),
-    child: void 0
+    child: NIL
   };
 }
 var SyncParsePluginContext = class {
-  constructor(_p) {
+  constructor(_p, depth) {
     this._p = _p;
+    this.depth = depth;
   }
   parse(current) {
-    return parseSOS(this._p, current);
+    return parseSOS(this._p, this.depth, current);
   }
 };
 var StreamParsePluginContext = class {
-  constructor(_p) {
+  constructor(_p, depth) {
     this._p = _p;
+    this.depth = depth;
   }
   parse(current) {
-    return parseSOS(this._p, current);
+    return parseSOS(this._p, this.depth, current);
   }
   parseWithError(current) {
-    return parseWithError(this._p, current);
+    return parseWithError(this._p, this.depth, current);
   }
   isAlive() {
     return this._p.state.alive;
@@ -3137,29 +3301,30 @@ function createStreamParserContext(options) {
   return {
     type: 2 /* Stream */,
     base: createBaseParserContext(2 /* Cross */, options),
-    child: void 0,
     state: createStreamParserState(options)
   };
 }
-function parseItems2(ctx, current) {
+function parseItems2(ctx, depth, current) {
   const nodes = [];
   for (let i = 0, len = current.length; i < len; i++) {
     if (i in current) {
-      nodes[i] = parseSOS(ctx, current[i]);
+      nodes[i] = parseSOS(ctx, depth, current[i]);
+    } else {
+      nodes[i] = 0;
     }
   }
   return nodes;
 }
-function parseArray2(ctx, id, current) {
-  return createArrayNode(id, current, parseItems2(ctx, current));
+function parseArray2(ctx, depth, id, current) {
+  return createArrayNode(id, current, parseItems2(ctx, depth, current));
 }
-function parseProperties2(ctx, properties) {
+function parseProperties2(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, entries[i][1]));
+    valueNodes.push(parseSOS(ctx, depth, entries[i][1]));
   }
   if (SYM_ITERATOR in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));
@@ -3168,6 +3333,7 @@ function parseProperties2(ctx, properties) {
         parseIteratorFactory(ctx.base),
         parseSOS(
           ctx,
+          depth,
           iteratorToSequence(properties)
         )
       )
@@ -3180,6 +3346,7 @@ function parseProperties2(ctx, properties) {
         parseAsyncIteratorFactory(ctx.base),
         parseSOS(
           ctx,
+          depth,
           ctx.type === 1 /* Sync */ ? createStream() : createStreamFromAsyncIterable(
             properties
           )
@@ -3199,58 +3366,70 @@ function parseProperties2(ctx, properties) {
   }
   return {
     k: keyNodes,
-    v: valueNodes,
-    s: keyNodes.length
+    v: valueNodes
   };
 }
-function parsePlainObject2(ctx, id, current, empty) {
-  return createObjectNode(id, current, empty, parseProperties2(ctx, current));
+function parsePlainObject2(ctx, depth, id, current, empty) {
+  return createObjectNode(
+    id,
+    current,
+    empty,
+    parseProperties2(ctx, depth, current)
+  );
 }
-function parseBoxed2(ctx, id, current) {
-  return createBoxedNode(id, parseSOS(ctx, current.valueOf()));
+function parseBoxed2(ctx, depth, id, current) {
+  return createBoxedNode(id, parseSOS(ctx, depth, current.valueOf()));
 }
-function parseTypedArray2(ctx, id, current) {
-  return createTypedArrayNode(id, current, parseSOS(ctx, current.buffer));
+function parseTypedArray2(ctx, depth, id, current) {
+  return createTypedArrayNode(
+    id,
+    current,
+    parseSOS(ctx, depth, current.buffer)
+  );
 }
-function parseBigIntTypedArray2(ctx, id, current) {
-  return createBigIntTypedArrayNode(id, current, parseSOS(ctx, current.buffer));
+function parseBigIntTypedArray2(ctx, depth, id, current) {
+  return createBigIntTypedArrayNode(
+    id,
+    current,
+    parseSOS(ctx, depth, current.buffer)
+  );
 }
-function parseDataView2(ctx, id, current) {
-  return createDataViewNode(id, current, parseSOS(ctx, current.buffer));
+function parseDataView2(ctx, depth, id, current) {
+  return createDataViewNode(id, current, parseSOS(ctx, depth, current.buffer));
 }
-function parseError2(ctx, id, current) {
+function parseError2(ctx, depth, id, current) {
   const options = getErrorOptions(current, ctx.base.features);
   return createErrorNode(
     id,
     current,
-    options ? parseProperties2(ctx, options) : NIL
+    options ? parseProperties2(ctx, depth, options) : NIL
   );
 }
-function parseAggregateError2(ctx, id, current) {
+function parseAggregateError2(ctx, depth, id, current) {
   const options = getErrorOptions(current, ctx.base.features);
   return createAggregateErrorNode(
     id,
     current,
-    options ? parseProperties2(ctx, options) : NIL
+    options ? parseProperties2(ctx, depth, options) : NIL
   );
 }
-function parseMap2(ctx, id, current) {
+function parseMap2(ctx, depth, id, current) {
   const keyNodes = [];
   const valueNodes = [];
   for (const [key, value] of current.entries()) {
-    keyNodes.push(parseSOS(ctx, key));
-    valueNodes.push(parseSOS(ctx, value));
+    keyNodes.push(parseSOS(ctx, depth, key));
+    valueNodes.push(parseSOS(ctx, depth, value));
   }
-  return createMapNode(ctx.base, id, keyNodes, valueNodes, current.size);
+  return createMapNode(ctx.base, id, keyNodes, valueNodes);
 }
-function parseSet2(ctx, id, current) {
+function parseSet2(ctx, depth, id, current) {
   const items = [];
   for (const item of current.keys()) {
-    items.push(parseSOS(ctx, item));
+    items.push(parseSOS(ctx, depth, item));
   }
-  return createSetNode(id, current.size, items);
+  return createSetNode(id, items);
 }
-function parseStream2(ctx, id, current) {
+function parseStream2(ctx, depth, id, current) {
   const result = createStreamConstructorNode(
     id,
     parseSpecialReference(ctx.base, 4 /* StreamConstructor */),
@@ -3263,7 +3442,7 @@ function parseStream2(ctx, id, current) {
   current.on({
     next: (value) => {
       if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, value);
+        const parsed = parseWithError(ctx, depth, value);
         if (parsed) {
           onParse(ctx, createStreamNextNode(id, parsed));
         }
@@ -3271,7 +3450,7 @@ function parseStream2(ctx, id, current) {
     },
     throw: (value) => {
       if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, value);
+        const parsed = parseWithError(ctx, depth, value);
         if (parsed) {
           onParse(ctx, createStreamThrowNode(id, parsed));
         }
@@ -3280,7 +3459,7 @@ function parseStream2(ctx, id, current) {
     },
     return: (value) => {
       if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, value);
+        const parsed = parseWithError(ctx, depth, value);
         if (parsed) {
           onParse(ctx, createStreamReturnNode(id, parsed));
         }
@@ -3290,9 +3469,9 @@ function parseStream2(ctx, id, current) {
   });
   return result;
 }
-function handlePromiseSuccess(id, data) {
+function handlePromiseSuccess(id, depth, data) {
   if (this.state.alive) {
-    const parsed = parseWithError(this, data);
+    const parsed = parseWithError(this, depth, data);
     if (parsed) {
       onParse(
         this,
@@ -3304,13 +3483,13 @@ function handlePromiseSuccess(id, data) {
           NIL,
           NIL,
           NIL,
-          NIL,
           [
             parseSpecialReference(this.base, 2 /* PromiseSuccess */),
             parsed
           ],
           NIL,
           NIL,
+          NIL,
           NIL
         )
       );
@@ -3318,9 +3497,9 @@ function handlePromiseSuccess(id, data) {
     popPendingState(this);
   }
 }
-function handlePromiseFailure(id, data) {
+function handlePromiseFailure(id, depth, data) {
   if (this.state.alive) {
-    const parsed = parseWithError(this, data);
+    const parsed = parseWithError(this, depth, data);
     if (parsed) {
       onParse(
         this,
@@ -3332,13 +3511,13 @@ function handlePromiseFailure(id, data) {
           NIL,
           NIL,
           NIL,
-          NIL,
           [
             parseSpecialReference(this.base, 3 /* PromiseFailure */),
             parsed
           ],
           NIL,
           NIL,
+          NIL,
           NIL
         )
       );
@@ -3346,80 +3525,74 @@ function handlePromiseFailure(id, data) {
   }
   popPendingState(this);
 }
-function parsePromise2(ctx, id, current) {
+function parsePromise2(ctx, depth, id, current) {
   const resolver = createIndexForValue(ctx.base, {});
   if (ctx.type === 2 /* Stream */) {
     pushPendingState(ctx);
     current.then(
-      handlePromiseSuccess.bind(ctx, resolver),
-      handlePromiseFailure.bind(ctx, resolver)
+      handlePromiseSuccess.bind(ctx, resolver, depth),
+      handlePromiseFailure.bind(ctx, resolver, depth)
     );
   }
   return createPromiseConstructorNode(ctx.base, id, resolver);
 }
-function parsePluginSync(ctx, id, current, currentPlugins) {
+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)) {
-      if (ctx.child == null) {
-        ctx.child = new SyncParsePluginContext(ctx);
-      }
       return createPluginNode(
         id,
         plugin.tag,
-        plugin.parse.sync(current, ctx.child, {
+        plugin.parse.sync(current, new SyncParsePluginContext(ctx, depth), {
           id
         })
       );
     }
   }
-  return void 0;
+  return NIL;
 }
-function parsePluginStream(ctx, id, current, currentPlugins) {
+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)) {
-      if (ctx.child == null) {
-        ctx.child = new StreamParsePluginContext(ctx);
-      }
       return createPluginNode(
         id,
         plugin.tag,
-        plugin.parse.stream(current, ctx.child, {
+        plugin.parse.stream(current, new StreamParsePluginContext(ctx, depth), {
           id
         })
       );
     }
   }
-  return void 0;
+  return NIL;
 }
-function parsePlugin2(ctx, id, current) {
+function parsePlugin2(ctx, depth, id, current) {
   const currentPlugins = ctx.base.plugins;
   if (currentPlugins) {
-    return ctx.type === 1 /* Sync */ ? parsePluginSync(ctx, id, current, currentPlugins) : parsePluginStream(ctx, id, current, currentPlugins);
+    return ctx.type === 1 /* Sync */ ? parsePluginSync(ctx, depth, id, current, currentPlugins) : parsePluginStream(ctx, depth, id, current, currentPlugins);
   }
-  return void 0;
+  return NIL;
 }
-function parseObjectPhase2(ctx, id, current, currentClass) {
+function parseObjectPhase2(ctx, depth, id, current, currentClass) {
   switch (currentClass) {
     case Object:
       return parsePlainObject2(
         ctx,
+        depth,
         id,
         current,
         false
       );
-    case void 0:
+    case NIL:
       return parsePlainObject2(
         ctx,
+        depth,
         id,
         current,
         true
       );
     case Date:
       return createDateNode(id, current);
-    case RegExp:
-      return createRegExpNode(id, current);
     case Error:
     case EvalError:
     case RangeError:
@@ -3427,12 +3600,12 @@ function parseObjectPhase2(ctx, id, current, currentClass) {
     case SyntaxError:
     case TypeError:
     case URIError:
-      return parseError2(ctx, id, current);
+      return parseError2(ctx, depth, id, current);
     case Number:
     case Boolean:
     case String:
     case BigInt:
-      return parseBoxed2(ctx, id, current);
+      return parseBoxed2(ctx, depth, id, current);
     case ArrayBuffer:
       return createArrayBufferNode(
         ctx.base,
@@ -3448,26 +3621,40 @@ function parseObjectPhase2(ctx, id, current, currentClass) {
     case Uint8ClampedArray:
     case Float32Array:
     case Float64Array:
-      return parseTypedArray2(ctx, id, current);
+      return parseTypedArray2(
+        ctx,
+        depth,
+        id,
+        current
+      );
     case DataView:
-      return parseDataView2(ctx, id, current);
+      return parseDataView2(ctx, depth, id, current);
     case Map:
-      return parseMap2(ctx, id, current);
+      return parseMap2(
+        ctx,
+        depth,
+        id,
+        current
+      );
     case Set:
-      return parseSet2(ctx, id, current);
+      return parseSet2(ctx, depth, id, current);
     default:
       break;
   }
   if (currentClass === Promise || current instanceof Promise) {
-    return parsePromise2(ctx, id, current);
+    return parsePromise2(ctx, depth, id, current);
   }
   const currentFeatures = ctx.base.features;
+  if (currentFeatures & 32 /* RegExp */ && currentClass === RegExp) {
+    return createRegExpNode(id, current);
+  }
   if (currentFeatures & 16 /* BigIntTypedArray */) {
     switch (currentClass) {
       case BigInt64Array:
       case BigUint64Array:
         return parseBigIntTypedArray2(
           ctx,
+          depth,
           id,
           current
         );
@@ -3476,48 +3663,57 @@ function parseObjectPhase2(ctx, id, current, currentClass) {
     }
   }
   if (currentFeatures & 1 /* AggregateError */ && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) {
-    return parseAggregateError2(ctx, id, current);
+    return parseAggregateError2(
+      ctx,
+      depth,
+      id,
+      current
+    );
   }
   if (current instanceof Error) {
-    return parseError2(ctx, id, current);
+    return parseError2(ctx, depth, id, current);
   }
   if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) {
-    return parsePlainObject2(ctx, id, current, !!currentClass);
+    return parsePlainObject2(ctx, depth, id, current, !!currentClass);
   }
   throw new SerovalUnsupportedTypeError(current);
 }
-function parseObject(ctx, id, current) {
+function parseObject(ctx, depth, id, current) {
   if (Array.isArray(current)) {
-    return parseArray2(ctx, id, current);
+    return parseArray2(ctx, depth, id, current);
   }
   if (isStream(current)) {
-    return parseStream2(ctx, id, current);
+    return parseStream2(ctx, depth, id, current);
   }
   const currentClass = current.constructor;
   if (currentClass === OpaqueReference) {
     return parseSOS(
       ctx,
+      depth,
       current.replacement
     );
   }
-  const parsed = parsePlugin2(ctx, id, current);
+  const parsed = parsePlugin2(ctx, depth, id, current);
   if (parsed) {
     return parsed;
   }
-  return parseObjectPhase2(ctx, id, current, currentClass);
+  return parseObjectPhase2(ctx, depth, id, current, currentClass);
 }
-function parseFunction(ctx, current) {
+function parseFunction(ctx, depth, current) {
   const ref = getReferenceNode(ctx.base, current);
   if (ref.type !== 0 /* Fresh */) {
     return ref.value;
   }
-  const plugin = parsePlugin2(ctx, ref.value, current);
+  const plugin = parsePlugin2(ctx, depth, ref.value, current);
   if (plugin) {
     return plugin;
   }
   throw new SerovalUnsupportedTypeError(current);
 }
-function parseSOS(ctx, current) {
+function parseSOS(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;
@@ -3532,14 +3728,14 @@ function parseSOS(ctx, current) {
     case "object": {
       if (current) {
         const ref = getReferenceNode(ctx.base, current);
-        return ref.type === 0 /* Fresh */ ? parseObject(ctx, ref.value, current) : ref.value;
+        return ref.type === 0 /* Fresh */ ? parseObject(ctx, depth + 1, ref.value, current) : ref.value;
       }
       return NULL_NODE;
     }
     case "symbol":
       return parseWellKnownSymbol(ctx.base, current);
     case "function": {
-      return parseFunction(ctx, current);
+      return parseFunction(ctx, depth, current);
     }
     default:
       throw new SerovalUnsupportedTypeError(current);
@@ -3547,7 +3743,7 @@ function parseSOS(ctx, current) {
 }
 function parseTop(ctx, current) {
   try {
-    return parseSOS(ctx, current);
+    return parseSOS(ctx, 0, current);
   } catch (error) {
     throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
   }
@@ -3586,16 +3782,16 @@ function popPendingState(ctx) {
     onDone(ctx);
   }
 }
-function parseWithError(ctx, current) {
+function parseWithError(ctx, depth, current) {
   try {
-    return parseSOS(ctx, current);
+    return parseSOS(ctx, depth, current);
   } catch (err) {
     onError(ctx, err);
     return NIL;
   }
 }
 function startStreamParse(ctx, current) {
-  const parsed = parseWithError(ctx, current);
+  const parsed = parseWithError(ctx, 0, current);
   if (parsed) {
     onParseInternal(ctx, parsed, true);
     ctx.state.initial = false;
@@ -3715,7 +3911,9 @@ function fromCrossJSON(source, options) {
   const plugins = resolvePlugins(options.plugins);
   const ctx = createCrossDeserializerContext({
     plugins,
-    refs: options.refs
+    refs: options.refs,
+    features: options.features,
+    disabledFeatures: options.disabledFeatures
   });
   return deserializeTop(ctx, source);
 }
@@ -3865,10 +4063,15 @@ function compileJSON(source, options = {}) {
   return serializeTopVanilla(ctx, source.t);
 }
 function fromJSON(source, options = {}) {
+  var _a;
   const plugins = resolvePlugins(options.plugins);
+  const disabledFeatures = options.disabledFeatures || 0;
+  const sourceFeatures = (_a = source.f) != null ? _a : ALL_ENABLED;
   const ctx = createVanillaDeserializerContext({
     plugins,
-    markedRefs: source.m
+    markedRefs: source.m,
+    features: sourceFeatures & ~disabledFeatures,
+    disabledFeatures
   });
   return deserializeTop(ctx, source.t);
 }