seroval 0.4.0-alpha.11 → 0.4.0-alpha.13

package/dist/esm/development/index.mjs

@@ -1,3 +1,10 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
 // src/compat.ts
 function compareVersion(left, right) {
   let diff = left[0] - right[0];
@@ -242,25 +249,33 @@ function getIdentifier(index) {
 var DEFAULT_OPTIONS = {
   target: "es2023"
 };
-function createParserContext(options = {}) {
-  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
-  return {
-    markedRefs: {},
-    refs: /* @__PURE__ */ new Map(),
-    features: parseTargets(result.target)
-  };
-}
-function createSerializationContext(options) {
-  return {
-    stack: [],
-    vars: [],
-    assignments: [],
-    validRefs: [],
-    refSize: 0,
-    features: options.features,
-    markedRefs: options.markedRefs
-  };
-}
+var ParserContext = class {
+  constructor(options = {}) {
+    __publicField(this, "refs", /* @__PURE__ */ new Map());
+    __publicField(this, "markedRefs", {});
+    __publicField(this, "features");
+    const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+    this.features = parseTargets(result.target);
+  }
+};
+var SerializationContext = class {
+  constructor(options) {
+    __publicField(this, "stack", []);
+    // Map tree refs to actual refs
+    __publicField(this, "validRefs", []);
+    __publicField(this, "refSize", 0);
+    // Variables
+    __publicField(this, "vars", []);
+    // Array of assignments to be done (used for recursion)
+    __publicField(this, "assignments", []);
+    // Supported features
+    __publicField(this, "features");
+    // Refs that are...referenced
+    __publicField(this, "markedRefs");
+    this.features = options.features;
+    this.markedRefs = options.markedRefs;
+  }
+};
 function markRef(ctx, current) {
   ctx.markedRefs[current] = 1;
 }
@@ -344,119 +359,198 @@ function quote(str) {
   return `"${result}"`;
 }
 
+// src/tree/types.ts
+var SerovalObjectRecordNode = class {
+  constructor(k, v, s) {
+    __publicField(this, "k");
+    __publicField(this, "v");
+    __publicField(this, "s");
+    this.k = k;
+    this.v = v;
+    this.s = s;
+  }
+};
+var SerovalMapRecordNode = class {
+  constructor(k, v, s) {
+    __publicField(this, "k");
+    __publicField(this, "v");
+    __publicField(this, "s");
+    this.k = k;
+    this.v = v;
+    this.s = s;
+  }
+};
+var SerovalPrimitiveNode = class {
+  constructor(current) {
+    __publicField(this, "t", 0 /* Primitive */);
+    __publicField(this, "s");
+    this.s = current;
+  }
+};
+var SerovalReferenceNode = class {
+  constructor(id) {
+    __publicField(this, "t", 2 /* Reference */);
+    __publicField(this, "i");
+    this.i = id;
+  }
+};
+var SerovalBigIntNode = class {
+  constructor(current) {
+    __publicField(this, "t", 1 /* BigInt */);
+    __publicField(this, "s");
+    this.s = `${current}n`;
+  }
+};
+var SerovalDateNode = class {
+  constructor(id, current) {
+    __publicField(this, "t", 3 /* Date */);
+    __publicField(this, "i");
+    __publicField(this, "s");
+    this.i = id;
+    this.s = current.toISOString();
+  }
+};
+var SerovalRegExpNode = class {
+  constructor(id, current) {
+    __publicField(this, "t", 4 /* RegExp */);
+    __publicField(this, "i");
+    __publicField(this, "s");
+    this.i = id;
+    this.s = String(current);
+  }
+};
+var SerovalTypedArrayNode = class {
+  constructor(id, current) {
+    __publicField(this, "t", 14 /* TypedArray */);
+    __publicField(this, "i");
+    __publicField(this, "s");
+    __publicField(this, "l");
+    __publicField(this, "c");
+    this.i = id;
+    this.s = current.toString();
+    this.l = current.byteOffset;
+    this.c = current.constructor.name;
+  }
+};
+var SerovalBigIntTypedArrayNode = class {
+  constructor(id, current) {
+    __publicField(this, "t", 15 /* BigIntTypedArray */);
+    __publicField(this, "i");
+    __publicField(this, "s");
+    __publicField(this, "l");
+    __publicField(this, "c");
+    let result = "";
+    const cap = current.length - 1;
+    for (let i = 0; i < cap; i++) {
+      result += `${current[i]}n,`;
+    }
+    result += `"${current[cap]}"`;
+    this.i = id;
+    this.s = result;
+    this.l = current.byteOffset;
+    this.c = current.constructor.name;
+  }
+};
+var SerovalSetNode = class {
+  constructor(id, a) {
+    __publicField(this, "t", 5 /* Set */);
+    __publicField(this, "i");
+    __publicField(this, "a");
+    this.i = id;
+    this.a = a;
+  }
+};
+var SerovalMapNode = class {
+  constructor(id, d) {
+    __publicField(this, "t", 6 /* Map */);
+    __publicField(this, "i");
+    __publicField(this, "d");
+    this.i = id;
+    this.d = d;
+  }
+};
+var SerovalArrayNode = class {
+  constructor(id, a) {
+    __publicField(this, "t", 7 /* Array */);
+    __publicField(this, "i");
+    __publicField(this, "a");
+    this.i = id;
+    this.a = a;
+  }
+};
+var SerovalObjectNode = class {
+  constructor(id, d) {
+    __publicField(this, "t", 8 /* Object */);
+    __publicField(this, "i");
+    __publicField(this, "d");
+    this.i = id;
+    this.d = d;
+  }
+};
+var SerovalNullConstructorNode = class {
+  constructor(id, d) {
+    __publicField(this, "t", 9 /* NullConstructor */);
+    __publicField(this, "i");
+    __publicField(this, "d");
+    this.i = id;
+    this.d = d;
+  }
+};
+var SerovalPromiseNode = class {
+  constructor(id, n) {
+    __publicField(this, "t", 10 /* Promise */);
+    __publicField(this, "i");
+    __publicField(this, "n");
+    this.i = id;
+    this.n = n;
+  }
+};
+var SerovalErrorNode = class {
+  constructor(id, c, m, d) {
+    __publicField(this, "t", 11 /* Error */);
+    __publicField(this, "i");
+    __publicField(this, "c");
+    __publicField(this, "m");
+    __publicField(this, "d");
+    this.i = id;
+    this.c = c;
+    this.m = m;
+    this.d = d;
+  }
+};
+var SerovalAggregateErrorNode = class {
+  constructor(id, m, d, n) {
+    __publicField(this, "t", 12 /* AggregateError */);
+    __publicField(this, "i");
+    __publicField(this, "m");
+    __publicField(this, "d");
+    __publicField(this, "n");
+    this.i = id;
+    this.m = m;
+    this.d = d;
+    this.n = n;
+  }
+};
+var SerovalIterableNode = class {
+  constructor(id, d, a) {
+    __publicField(this, "t", 13 /* Iterable */);
+    __publicField(this, "i");
+    __publicField(this, "d");
+    __publicField(this, "a");
+    this.i = id;
+    this.d = d;
+    this.a = a;
+  }
+};
+
 // src/tree/primitives.ts
-function createPrimitiveNode(value) {
-  return {
-    t: 0 /* Primitive */,
-    i: void 0,
-    s: value,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    a: void 0,
-    n: void 0
-  };
-}
-var TRUE_NODE = createPrimitiveNode("!0");
-var FALSE_NODE = createPrimitiveNode("!1");
-var UNDEFINED_NODE = createPrimitiveNode("void 0");
-var NULL_NODE = createPrimitiveNode(null);
-var NEG_ZERO_NODE = createPrimitiveNode("-0");
-var INFINITY_NODE = createPrimitiveNode("1/0");
-var NEG_INFINITY_NODE = createPrimitiveNode("-1/0");
-function createBigIntNode(ctx, current) {
-  assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
-  return {
-    t: 1 /* BigInt */,
-    i: void 0,
-    a: void 0,
-    s: `${current}n`,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    n: void 0
-  };
-}
-function createReferenceNode(id) {
-  return {
-    t: 2 /* Reference */,
-    i: id,
-    a: void 0,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    n: void 0
-  };
-}
-function createDateNode(id, current) {
-  return {
-    t: 3 /* Date */,
-    i: id,
-    a: void 0,
-    s: current.toISOString(),
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    n: void 0
-  };
-}
-function createRegExpNode(id, current) {
-  return {
-    t: 4 /* RegExp */,
-    i: id,
-    a: void 0,
-    s: String(current),
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    n: void 0
-  };
-}
-function createTypedArrayNode(ctx, id, current) {
-  const constructor = current.constructor.name;
-  assert(ctx.features & 1024 /* TypedArray */, `Unsupported value type "${constructor}"`);
-  return {
-    t: 14 /* TypedArray */,
-    i: id,
-    a: void 0,
-    s: current.toString(),
-    l: current.byteOffset,
-    m: void 0,
-    c: constructor,
-    d: void 0,
-    n: void 0
-  };
-}
-function createBigIntTypedArrayNode(ctx, id, current) {
-  const constructor = current.constructor.name;
-  assert(
-    ctx.features & 2048 /* BigIntTypedArray */,
-    `Unsupported value type "${constructor}"`
-  );
-  let result = "";
-  const cap = current.length - 1;
-  for (let i = 0; i < cap; i++) {
-    result += `${current[i]}n,`;
-  }
-  result += `"${current[cap]}"`;
-  return {
-    t: 15 /* BigIntTypedArray */,
-    i: id,
-    a: void 0,
-    s: result,
-    l: current.byteOffset,
-    m: void 0,
-    c: constructor,
-    d: void 0,
-    n: void 0
-  };
-}
+var TRUE_NODE = new SerovalPrimitiveNode("!0");
+var FALSE_NODE = new SerovalPrimitiveNode("!1");
+var UNDEFINED_NODE = new SerovalPrimitiveNode("void 0");
+var NULL_NODE = new SerovalPrimitiveNode(null);
+var NEG_ZERO_NODE = new SerovalPrimitiveNode("-0");
+var INFINITY_NODE = new SerovalPrimitiveNode("1/0");
+var NEG_INFINITY_NODE = new SerovalPrimitiveNode("-1/0");
 
 // src/tree/shared.ts
 function getErrorConstructor(error) {
@@ -540,317 +634,257 @@ function isIterable(value) {
 }
 
 // src/tree/async.ts
-async function serializePropertiesAsync(ctx, properties) {
-  const keys = Object.keys(properties);
-  const size = keys.length;
-  const keyNodes = new Array(size);
-  const valueNodes = new Array(size);
-  const deferredKeys = new Array(size);
-  const deferredValues = new Array(size);
-  let deferredSize = 0;
-  let nodesSize = 0;
-  let item;
-  for (const key of keys) {
-    item = properties[key];
-    if (isIterable(item)) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = item;
-      deferredSize++;
-    } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = await generateTreeAsync(ctx, item);
-      nodesSize++;
+var AsyncParser = class {
+  constructor(ctx) {
+    __publicField(this, "ctx");
+    this.ctx = ctx;
+  }
+  async generateNodeList(current) {
+    const size = current.length;
+    const nodes = new Array(size);
+    const deferred = new Array(size);
+    let item;
+    for (let i = 0; i < size; i++) {
+      if (i in current) {
+        item = current[i];
+        if (isIterable(item)) {
+          deferred[i] = item;
+        } else {
+          nodes[i] = await this.parse(item);
+        }
+      }
     }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodesSize + i] = deferredKeys[i];
-    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
-  }
-  return {
-    k: keyNodes,
-    v: valueNodes,
-    s: size
-  };
-}
-async function generateSetNode(ctx, current, id) {
-  assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
-  const len = current.size;
-  const nodes = new Array(len);
-  const deferred = new Array(len);
-  let deferredSize = 0;
-  let nodeSize = 0;
-  for (const item of current.keys()) {
-    if (isIterable(item)) {
-      deferred[deferredSize++] = item;
-    } else {
-      nodes[nodeSize++] = await generateTreeAsync(ctx, item);
+    for (let i = 0; i < size; i++) {
+      if (i in deferred) {
+        nodes[i] = await this.parse(deferred[i]);
+      }
     }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
-  }
-  return {
-    t: 5 /* Set */,
-    i: id,
-    a: nodes,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    n: void 0
-  };
-}
-async function generateMapNode(ctx, current, id) {
-  assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
-  const len = current.size;
-  const keyNodes = new Array(len);
-  const valueNodes = new Array(len);
-  const deferredKey = new Array(len);
-  const deferredValue = new Array(len);
-  let deferredSize = 0;
-  let nodeSize = 0;
-  for (const [key, value] of current.entries()) {
-    if (isIterable(key) || isIterable(value)) {
-      deferredKey[deferredSize] = key;
-      deferredValue[deferredSize] = value;
-      deferredSize++;
-    } else {
-      keyNodes[nodeSize] = await generateTreeAsync(ctx, key);
-      valueNodes[nodeSize] = await generateTreeAsync(ctx, value);
-      nodeSize++;
+    return nodes;
+  }
+  async generateArrayNode(id, current) {
+    return new SerovalArrayNode(id, await this.generateNodeList(current));
+  }
+  async generateMapNode(id, current) {
+    assert(this.ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+    const len = current.size;
+    const keyNodes = new Array(len);
+    const valueNodes = new Array(len);
+    const deferredKey = new Array(len);
+    const deferredValue = new Array(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
+    for (const [key, value] of current.entries()) {
+      if (isIterable(key) || isIterable(value)) {
+        deferredKey[deferredSize] = key;
+        deferredValue[deferredSize] = value;
+        deferredSize++;
+      } else {
+        keyNodes[nodeSize] = await this.parse(key);
+        valueNodes[nodeSize] = await this.parse(value);
+        nodeSize++;
+      }
     }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
-    valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
-  }
-  return {
-    t: 6 /* Map */,
-    i: id,
-    a: void 0,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: { k: keyNodes, v: valueNodes, s: len },
-    n: void 0
-  };
-}
-async function generateNodeList(ctx, current) {
-  const size = current.length;
-  const nodes = new Array(size);
-  const deferred = new Array(size);
-  let item;
-  for (let i = 0; i < size; i++) {
-    if (i in current) {
-      item = current[i];
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes[nodeSize + i] = await this.parse(deferredKey[i]);
+      valueNodes[nodeSize + i] = await this.parse(deferredValue[i]);
+    }
+    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
+  }
+  async generateSetNode(id, current) {
+    assert(this.ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+    const len = current.size;
+    const nodes = new Array(len);
+    const deferred = new Array(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
+    for (const item of current.keys()) {
       if (isIterable(item)) {
-        deferred[i] = item;
+        deferred[deferredSize++] = item;
       } else {
-        nodes[i] = await generateTreeAsync(ctx, item);
+        nodes[nodeSize++] = await this.parse(item);
       }
     }
-  }
-  for (let i = 0; i < size; i++) {
-    if (i in deferred) {
-      nodes[i] = await generateTreeAsync(ctx, deferred[i]);
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = await this.parse(deferred[i]);
     }
-  }
-  return nodes;
-}
-async function generateArrayNode(ctx, current, id) {
-  return {
-    t: 7 /* Array */,
-    i: id,
-    a: await generateNodeList(ctx, current),
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    n: void 0
-  };
-}
-async function generateAggregateErrorNode(ctx, current, id) {
-  const options = getErrorOptions(current);
-  const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
-  return {
-    t: 12 /* AggregateError */,
-    i: id,
-    a: void 0,
-    s: void 0,
-    l: void 0,
-    m: current.message,
-    c: void 0,
-    d: optionsNode,
-    n: await generateTreeAsync(ctx, current.errors)
-  };
-}
-async function generateErrorNode(ctx, current, id) {
-  const options = getErrorOptions(current);
-  const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
-  return {
-    t: 11 /* Error */,
-    i: id,
-    a: void 0,
-    s: void 0,
-    l: void 0,
-    m: current.message,
-    c: getErrorConstructor(current),
-    d: optionsNode,
-    n: void 0
-  };
-}
-async function generateIterableNode(ctx, current, id) {
-  assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
-  const options = getIterableOptions(current);
-  return {
-    t: 13 /* Iterable */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    // Parse options first before the items
-    d: options ? await serializePropertiesAsync(ctx, options) : void 0,
-    a: await generateNodeList(ctx, Array.from(current)),
-    n: void 0
-  };
-}
-async function generateObjectNode(ctx, current, id, empty) {
-  if (Symbol.iterator in current) {
-    return generateIterableNode(ctx, current, id);
-  }
-  if ("then" in current && typeof current.then === "function") {
-    return generatePromiseNode(ctx, current, id);
-  }
-  return {
-    t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: await serializePropertiesAsync(ctx, current),
-    a: void 0,
-    n: void 0
-  };
-}
-async function generatePromiseNode(ctx, current, id) {
-  assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
-  return current.then(async (value) => ({
-    t: 10 /* Promise */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    // Parse options first before the items
-    d: void 0,
-    a: void 0,
-    n: await generateTreeAsync(ctx, value)
-  }));
-}
-async function generateTreeAsync(ctx, current) {
-  switch (typeof current) {
-    case "boolean":
-      return current ? TRUE_NODE : FALSE_NODE;
-    case "undefined":
-      return UNDEFINED_NODE;
-    case "string":
-      return createPrimitiveNode(quote(current));
-    case "number":
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
-      }
-      if (Object.is(current, Infinity)) {
-        return createPrimitiveNode("1/0");
-      }
-      if (Object.is(current, -Infinity)) {
-        return createPrimitiveNode("-1/0");
-      }
-      return createPrimitiveNode(current);
-    case "bigint":
-      return createBigIntNode(ctx, current);
-    case "object": {
-      if (!current) {
-        return NULL_NODE;
-      }
-      const id = createRef(ctx, current, true);
-      if (ctx.markedRefs[id]) {
-        return createReferenceNode(id);
-      }
-      if (Array.isArray(current)) {
-        return generateArrayNode(ctx, current, id);
-      }
-      switch (current.constructor) {
-        case Date:
-          return createDateNode(id, current);
-        case RegExp:
-          return createRegExpNode(id, current);
-        case Promise:
-          return generatePromiseNode(ctx, current, id);
-        case Map:
-          return generateMapNode(ctx, current, id);
-        case Set:
-          return generateSetNode(ctx, current, id);
-        case Object:
-          return generateObjectNode(ctx, current, id, false);
-        case void 0:
-          return generateObjectNode(ctx, current, id, true);
-        case Int8Array:
-        case Int16Array:
-        case Int32Array:
-        case Uint8Array:
-        case Uint16Array:
-        case Uint32Array:
-        case Uint8ClampedArray:
-        case Float32Array:
-        case Float64Array:
-          return createTypedArrayNode(ctx, id, current);
-        case BigInt64Array:
-        case BigUint64Array:
-          return createBigIntTypedArrayNode(ctx, id, current);
-        case AggregateError:
-          if (ctx.features & 1 /* AggregateError */) {
-            return generateAggregateErrorNode(ctx, current, id);
-          }
-          return generateErrorNode(ctx, current, id);
-        case Error:
-        case EvalError:
-        case RangeError:
-        case ReferenceError:
-        case SyntaxError:
-        case TypeError:
-        case URIError:
-          return generateErrorNode(ctx, current, id);
-        default:
-          break;
-      }
-      if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-        return generateAggregateErrorNode(ctx, current, id);
-      }
-      if (current instanceof Error) {
-        return generateErrorNode(ctx, current, id);
-      }
-      if (current instanceof Promise) {
-        return generatePromiseNode(ctx, current, id);
-      }
-      if (Symbol.iterator in current) {
-        return generateIterableNode(ctx, current, id);
+    return new SerovalSetNode(id, nodes);
+  }
+  async generateProperties(properties) {
+    const keys = Object.keys(properties);
+    const size = keys.length;
+    const keyNodes = new Array(size);
+    const valueNodes = new Array(size);
+    const deferredKeys = new Array(size);
+    const deferredValues = new Array(size);
+    let deferredSize = 0;
+    let nodesSize = 0;
+    let item;
+    for (const key of keys) {
+      item = properties[key];
+      if (isIterable(item)) {
+        deferredKeys[deferredSize] = key;
+        deferredValues[deferredSize] = item;
+        deferredSize++;
+      } else {
+        keyNodes[nodesSize] = key;
+        valueNodes[nodesSize] = await this.parse(item);
+        nodesSize++;
       }
-      if ("then" in current && typeof current.then === "function") {
-        return generatePromiseNode(ctx, current, id);
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes[nodesSize + i] = deferredKeys[i];
+      valueNodes[nodesSize + i] = await this.parse(deferredValues[i]);
+    }
+    return new SerovalObjectRecordNode(keyNodes, valueNodes, size);
+  }
+  async generateIterableNode(id, current) {
+    assert(this.ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+    const options = getIterableOptions(current);
+    return new SerovalIterableNode(
+      id,
+      // Parse options first before the items
+      options ? await this.generateProperties(options) : void 0,
+      await this.generateNodeList(Array.from(current))
+    );
+  }
+  async generatePromiseNode(id, current) {
+    assert(this.ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
+    return current.then(async (value) => new SerovalPromiseNode(id, await this.parse(value)));
+  }
+  async generateObjectNode(id, current, empty) {
+    if (Symbol.iterator in current) {
+      return this.generateIterableNode(id, current);
+    }
+    if ("then" in current && typeof current.then === "function") {
+      return this.generatePromiseNode(id, current);
+    }
+    const properties = await this.generateProperties(current);
+    if (empty) {
+      return new SerovalNullConstructorNode(id, properties);
+    }
+    return new SerovalObjectNode(id, properties);
+  }
+  async generateAggregateErrorNode(id, current) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? await this.generateProperties(options) : void 0;
+    return new SerovalAggregateErrorNode(
+      id,
+      current.message,
+      optionsNode,
+      await this.parse(current.errors)
+    );
+  }
+  async generateErrorNode(id, current) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? await this.generateProperties(options) : void 0;
+    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
+  }
+  async parse(current) {
+    switch (typeof current) {
+      case "boolean":
+        return current ? TRUE_NODE : FALSE_NODE;
+      case "undefined":
+        return UNDEFINED_NODE;
+      case "string":
+        return new SerovalPrimitiveNode(quote(current));
+      case "number":
+        if (Object.is(current, -0)) {
+          return NEG_ZERO_NODE;
+        }
+        if (Object.is(current, Infinity)) {
+          return INFINITY_NODE;
+        }
+        if (Object.is(current, -Infinity)) {
+          return NEG_INFINITY_NODE;
+        }
+        return new SerovalPrimitiveNode(current);
+      case "bigint":
+        assert(this.ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+        return new SerovalBigIntNode(current);
+      case "object": {
+        if (!current) {
+          return NULL_NODE;
+        }
+        const id = createRef(this.ctx, current, true);
+        if (this.ctx.markedRefs[id]) {
+          return new SerovalReferenceNode(id);
+        }
+        if (Array.isArray(current)) {
+          return this.generateArrayNode(id, current);
+        }
+        switch (current.constructor) {
+          case Date:
+            return new SerovalDateNode(id, current);
+          case RegExp:
+            return new SerovalRegExpNode(id, current);
+          case Promise:
+            return this.generatePromiseNode(id, current);
+          case Int8Array:
+          case Int16Array:
+          case Int32Array:
+          case Uint8Array:
+          case Uint16Array:
+          case Uint32Array:
+          case Uint8ClampedArray:
+          case Float32Array:
+          case Float64Array:
+            assert(this.ctx.features & 1024 /* TypedArray */, `Unsupported value type "${current.constructor.name}"`);
+            return new SerovalTypedArrayNode(id, current);
+          case BigInt64Array:
+          case BigUint64Array:
+            assert(
+              this.ctx.features & 2048 /* BigIntTypedArray */,
+              `Unsupported value type "${current.constructor.name}"`
+            );
+            return new SerovalBigIntTypedArrayNode(id, current);
+          case Map:
+            return this.generateMapNode(id, current);
+          case Set:
+            return this.generateSetNode(id, current);
+          case Object:
+            return this.generateObjectNode(id, current, false);
+          case void 0:
+            return this.generateObjectNode(id, current, true);
+          case AggregateError:
+            if (this.ctx.features & 1 /* AggregateError */) {
+              return this.generateAggregateErrorNode(id, current);
+            }
+            return this.generateErrorNode(id, current);
+          case Error:
+          case EvalError:
+          case RangeError:
+          case ReferenceError:
+          case SyntaxError:
+          case TypeError:
+          case URIError:
+            return this.generateErrorNode(id, current);
+          default:
+            break;
+        }
+        if (current instanceof AggregateError && this.ctx.features & 1 /* AggregateError */) {
+          return this.generateAggregateErrorNode(id, current);
+        }
+        if (current instanceof Error) {
+          return this.generateErrorNode(id, current);
+        }
+        if (current instanceof Promise) {
+          return this.generatePromiseNode(id, current);
+        }
+        if (Symbol.iterator in current) {
+          return this.generateIterableNode(id, current);
+        }
+        if ("then" in current && typeof current.then === "function") {
+          return this.generatePromiseNode(id, current);
+        }
+        throw new Error("Unsupported type");
       }
-      throw new Error("Unsupported type");
+      default:
+        throw new Error("Unsupported type");
     }
-    default:
-      throw new Error("Unsupported type");
   }
-}
+};
 async function parseAsync(ctx, current) {
-  const result = await generateTreeAsync(ctx, current);
+  const result = await new AsyncParser(ctx).parse(current);
   const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
   return [result, createRef(ctx, current, false), isObject];
 }
@@ -1237,291 +1271,245 @@ function serializeTree(ctx, node) {
 }
 
 // src/tree/sync.ts
-function serializePropertiesSync(ctx, properties) {
-  const keys = Object.keys(properties);
-  const size = keys.length;
-  const keyNodes = new Array(size);
-  const valueNodes = new Array(size);
-  const deferredKeys = new Array(size);
-  const deferredValues = new Array(size);
-  let deferredSize = 0;
-  let nodesSize = 0;
-  let item;
-  for (const key of keys) {
-    item = properties[key];
-    if (isIterable(item)) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = item;
-      deferredSize++;
-    } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = generateTreeSync(ctx, item);
-      nodesSize++;
+var SyncParser = class {
+  constructor(ctx) {
+    __publicField(this, "ctx");
+    this.ctx = ctx;
+  }
+  generateNodeList(current) {
+    const size = current.length;
+    const nodes = new Array(size);
+    const deferred = new Array(size);
+    let item;
+    for (let i = 0; i < size; i++) {
+      if (i in current) {
+        item = current[i];
+        if (isIterable(item)) {
+          deferred[i] = item;
+        } else {
+          nodes[i] = this.parse(item);
+        }
+      }
     }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodesSize + i] = deferredKeys[i];
-    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
-  }
-  return {
-    k: keyNodes,
-    v: valueNodes,
-    s: size
-  };
-}
-function generateSetNode2(ctx, current, id) {
-  assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
-  const len = current.size;
-  const nodes = new Array(len);
-  const deferred = new Array(len);
-  let deferredSize = 0;
-  let nodeSize = 0;
-  for (const item of current.keys()) {
-    if (isIterable(item)) {
-      deferred[deferredSize++] = item;
-    } else {
-      nodes[nodeSize++] = generateTreeSync(ctx, item);
+    for (let i = 0; i < size; i++) {
+      if (i in deferred) {
+        nodes[i] = this.parse(deferred[i]);
+      }
     }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
-  }
-  return {
-    t: 5 /* Set */,
-    i: id,
-    a: nodes,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    n: void 0
-  };
-}
-function generateMapNode2(ctx, current, id) {
-  assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
-  const len = current.size;
-  const keyNodes = new Array(len);
-  const valueNodes = new Array(len);
-  const deferredKey = new Array(len);
-  const deferredValue = new Array(len);
-  let deferredSize = 0;
-  let nodeSize = 0;
-  for (const [key, value] of current.entries()) {
-    if (isIterable(key) || isIterable(value)) {
-      deferredKey[deferredSize] = key;
-      deferredValue[deferredSize] = value;
-      deferredSize++;
-    } else {
-      keyNodes[nodeSize] = generateTreeSync(ctx, key);
-      valueNodes[nodeSize] = generateTreeSync(ctx, value);
-      nodeSize++;
+    return nodes;
+  }
+  generateArrayNode(id, current) {
+    return new SerovalArrayNode(id, this.generateNodeList(current));
+  }
+  generateMapNode(id, current) {
+    assert(this.ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+    const len = current.size;
+    const keyNodes = new Array(len);
+    const valueNodes = new Array(len);
+    const deferredKey = new Array(len);
+    const deferredValue = new Array(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
+    for (const [key, value] of current.entries()) {
+      if (isIterable(key) || isIterable(value)) {
+        deferredKey[deferredSize] = key;
+        deferredValue[deferredSize] = value;
+        deferredSize++;
+      } else {
+        keyNodes[nodeSize] = this.parse(key);
+        valueNodes[nodeSize] = this.parse(value);
+        nodeSize++;
+      }
     }
-  }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
-    valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
-  }
-  return {
-    t: 6 /* Map */,
-    i: id,
-    a: void 0,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: { k: keyNodes, v: valueNodes, s: len },
-    n: void 0
-  };
-}
-function generateNodeList2(ctx, current) {
-  const size = current.length;
-  const nodes = new Array(size);
-  const deferred = new Array(size);
-  let item;
-  for (let i = 0; i < size; i++) {
-    if (i in current) {
-      item = current[i];
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes[nodeSize + i] = this.parse(deferredKey[i]);
+      valueNodes[nodeSize + i] = this.parse(deferredValue[i]);
+    }
+    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
+  }
+  generateSetNode(id, current) {
+    assert(this.ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+    const len = current.size;
+    const nodes = new Array(len);
+    const deferred = new Array(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
+    for (const item of current.keys()) {
       if (isIterable(item)) {
-        deferred[i] = item;
+        deferred[deferredSize++] = item;
       } else {
-        nodes[i] = generateTreeSync(ctx, item);
+        nodes[nodeSize++] = this.parse(item);
       }
     }
-  }
-  for (let i = 0; i < size; i++) {
-    if (i in deferred) {
-      nodes[i] = generateTreeSync(ctx, deferred[i]);
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = this.parse(deferred[i]);
     }
-  }
-  return nodes;
-}
-function generateArrayNode2(ctx, current, id) {
-  return {
-    t: 7 /* Array */,
-    i: id,
-    a: generateNodeList2(ctx, current),
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: void 0,
-    n: void 0
-  };
-}
-function generateAggregateErrorNode2(ctx, current, id) {
-  const options = getErrorOptions(current);
-  const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
-  return {
-    t: 12 /* AggregateError */,
-    i: id,
-    a: void 0,
-    s: void 0,
-    l: void 0,
-    m: current.message,
-    c: void 0,
-    d: optionsNode,
-    n: generateTreeSync(ctx, current.errors)
-  };
-}
-function generateErrorNode2(ctx, current, id) {
-  const options = getErrorOptions(current);
-  const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
-  return {
-    t: 11 /* Error */,
-    i: id,
-    a: void 0,
-    s: void 0,
-    l: void 0,
-    m: current.message,
-    c: getErrorConstructor(current),
-    d: optionsNode,
-    n: void 0
-  };
-}
-function generateIterableNode2(ctx, current, id) {
-  assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
-  const options = getIterableOptions(current);
-  return {
-    t: 13 /* Iterable */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    // Parse options first before the items
-    d: options ? serializePropertiesSync(ctx, options) : void 0,
-    a: generateNodeList2(ctx, Array.from(current)),
-    n: void 0
-  };
-}
-function generateObjectNode2(ctx, current, id, empty) {
-  if (Symbol.iterator in current) {
-    return generateIterableNode2(ctx, current, id);
-  }
-  return {
-    t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
-    i: id,
-    s: void 0,
-    l: void 0,
-    m: void 0,
-    c: void 0,
-    d: serializePropertiesSync(ctx, current),
-    a: void 0,
-    n: void 0
-  };
-}
-function generateTreeSync(ctx, current) {
-  switch (typeof current) {
-    case "boolean":
-      return current ? TRUE_NODE : FALSE_NODE;
-    case "undefined":
-      return UNDEFINED_NODE;
-    case "string":
-      return createPrimitiveNode(quote(current));
-    case "number":
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
-      }
-      if (Object.is(current, Infinity)) {
-        return createPrimitiveNode("1/0");
-      }
-      if (Object.is(current, -Infinity)) {
-        return createPrimitiveNode("-1/0");
-      }
-      return createPrimitiveNode(current);
-    case "bigint":
-      return createBigIntNode(ctx, current);
-    case "object": {
-      if (!current) {
-        return NULL_NODE;
-      }
-      const id = createRef(ctx, current, true);
-      if (ctx.markedRefs[id]) {
-        return createReferenceNode(id);
-      }
-      if (Array.isArray(current)) {
-        return generateArrayNode2(ctx, current, id);
-      }
-      switch (current.constructor) {
-        case Date:
-          return createDateNode(id, current);
-        case RegExp:
-          return createRegExpNode(id, current);
-        case Map:
-          return generateMapNode2(ctx, current, id);
-        case Set:
-          return generateSetNode2(ctx, current, id);
-        case Object:
-          return generateObjectNode2(ctx, current, id, false);
-        case void 0:
-          return generateObjectNode2(ctx, current, id, true);
-        case Int8Array:
-        case Int16Array:
-        case Int32Array:
-        case Uint8Array:
-        case Uint16Array:
-        case Uint32Array:
-        case Uint8ClampedArray:
-        case Float32Array:
-        case Float64Array:
-          return createTypedArrayNode(ctx, id, current);
-        case BigInt64Array:
-        case BigUint64Array:
-          return createBigIntTypedArrayNode(ctx, id, current);
-        case AggregateError:
-          if (ctx.features & 1 /* AggregateError */) {
-            return generateAggregateErrorNode2(ctx, current, id);
-          }
-          return generateErrorNode2(ctx, current, id);
-        case Error:
-        case EvalError:
-        case RangeError:
-        case ReferenceError:
-        case SyntaxError:
-        case TypeError:
-        case URIError:
-          return generateErrorNode2(ctx, current, id);
-        default:
-          break;
-      }
-      if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-        return generateAggregateErrorNode2(ctx, current, id);
-      }
-      if (current instanceof Error) {
-        return generateErrorNode2(ctx, current, id);
+    return new SerovalSetNode(id, nodes);
+  }
+  generateProperties(properties) {
+    const keys = Object.keys(properties);
+    const size = keys.length;
+    const keyNodes = new Array(size);
+    const valueNodes = new Array(size);
+    const deferredKeys = new Array(size);
+    const deferredValues = new Array(size);
+    let deferredSize = 0;
+    let nodesSize = 0;
+    let item;
+    for (const key of keys) {
+      item = properties[key];
+      if (isIterable(item)) {
+        deferredKeys[deferredSize] = key;
+        deferredValues[deferredSize] = item;
+        deferredSize++;
+      } else {
+        keyNodes[nodesSize] = key;
+        valueNodes[nodesSize] = this.parse(item);
+        nodesSize++;
       }
-      if (Symbol.iterator in current) {
-        return generateIterableNode2(ctx, current, id);
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes[nodesSize + i] = deferredKeys[i];
+      valueNodes[nodesSize + i] = this.parse(deferredValues[i]);
+    }
+    return {
+      k: keyNodes,
+      v: valueNodes,
+      s: size
+    };
+  }
+  generateIterableNode(id, current) {
+    assert(this.ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+    const options = getIterableOptions(current);
+    return new SerovalIterableNode(
+      id,
+      // Parse options first before the items
+      options ? this.generateProperties(options) : void 0,
+      this.generateNodeList(Array.from(current))
+    );
+  }
+  generateObjectNode(id, current, empty) {
+    if (Symbol.iterator in current) {
+      return this.generateIterableNode(id, current);
+    }
+    if (empty) {
+      return new SerovalNullConstructorNode(id, this.generateProperties(current));
+    }
+    return new SerovalObjectNode(id, this.generateProperties(current));
+  }
+  generateAggregateErrorNode(id, current) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? this.generateProperties(options) : void 0;
+    return new SerovalAggregateErrorNode(
+      id,
+      current.message,
+      optionsNode,
+      this.parse(current.errors)
+    );
+  }
+  generateErrorNode(id, current) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? this.generateProperties(options) : void 0;
+    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
+  }
+  parse(current) {
+    switch (typeof current) {
+      case "boolean":
+        return current ? TRUE_NODE : FALSE_NODE;
+      case "undefined":
+        return UNDEFINED_NODE;
+      case "string":
+        return new SerovalPrimitiveNode(quote(current));
+      case "number":
+        if (Object.is(current, -0)) {
+          return NEG_ZERO_NODE;
+        }
+        if (Object.is(current, Infinity)) {
+          return INFINITY_NODE;
+        }
+        if (Object.is(current, -Infinity)) {
+          return NEG_INFINITY_NODE;
+        }
+        return new SerovalPrimitiveNode(current);
+      case "bigint":
+        assert(this.ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+        return new SerovalBigIntNode(current);
+      case "object": {
+        if (!current) {
+          return NULL_NODE;
+        }
+        const id = createRef(this.ctx, current, true);
+        if (this.ctx.markedRefs[id]) {
+          return new SerovalReferenceNode(id);
+        }
+        if (Array.isArray(current)) {
+          return this.generateArrayNode(id, current);
+        }
+        switch (current.constructor) {
+          case Date:
+            return new SerovalDateNode(id, current);
+          case RegExp:
+            return new SerovalRegExpNode(id, current);
+          case Int8Array:
+          case Int16Array:
+          case Int32Array:
+          case Uint8Array:
+          case Uint16Array:
+          case Uint32Array:
+          case Uint8ClampedArray:
+          case Float32Array:
+          case Float64Array:
+            assert(this.ctx.features & 1024 /* TypedArray */, `Unsupported value type "${current.constructor.name}"`);
+            return new SerovalTypedArrayNode(id, current);
+          case BigInt64Array:
+          case BigUint64Array:
+            assert(
+              this.ctx.features & 2048 /* BigIntTypedArray */,
+              `Unsupported value type "${current.constructor.name}"`
+            );
+            return new SerovalBigIntTypedArrayNode(id, current);
+          case Map:
+            return this.generateMapNode(id, current);
+          case Set:
+            return this.generateSetNode(id, current);
+          case Object:
+            return this.generateObjectNode(id, current, false);
+          case void 0:
+            return this.generateObjectNode(id, current, true);
+          case AggregateError:
+            if (this.ctx.features & 1 /* AggregateError */) {
+              return this.generateAggregateErrorNode(id, current);
+            }
+            return this.generateErrorNode(id, current);
+          case Error:
+          case EvalError:
+          case RangeError:
+          case ReferenceError:
+          case SyntaxError:
+          case TypeError:
+          case URIError:
+            return this.generateErrorNode(id, current);
+          default:
+            break;
+        }
+        if (current instanceof AggregateError && this.ctx.features & 1 /* AggregateError */) {
+          return this.generateAggregateErrorNode(id, current);
+        }
+        if (current instanceof Error) {
+          return this.generateErrorNode(id, current);
+        }
+        if (Symbol.iterator in current) {
+          return this.generateIterableNode(id, current);
+        }
+        throw new Error("Unsupported type");
       }
-      throw new Error("Unsupported type");
+      default:
+        throw new Error("Unsupported type");
     }
-    default:
-      throw new Error("Unsupported type");
   }
-}
+};
 function parseSync(ctx, current) {
-  const result = generateTreeSync(ctx, current);
+  const result = new SyncParser(ctx).parse(current);
   const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
   return [result, createRef(ctx, current, false), isObject];
 }
@@ -1552,16 +1540,16 @@ function finalize(ctx, rootID, isObject, result) {
   return result;
 }
 function serialize(source, options) {
-  const ctx = createParserContext(options);
+  const ctx = new ParserContext(options);
   const [tree, rootID, isObject] = parseSync(ctx, source);
-  const serial = createSerializationContext(ctx);
+  const serial = new SerializationContext(ctx);
   const result = serializeTree(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
 async function serializeAsync(source, options) {
-  const ctx = createParserContext(options);
+  const ctx = new ParserContext(options);
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
-  const serial = createSerializationContext(ctx);
+  const serial = new SerializationContext(ctx);
   const result = serializeTree(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
@@ -1569,7 +1557,7 @@ function deserialize(source) {
   return (0, eval)(source);
 }
 function toJSON(source, options) {
-  const ctx = createParserContext(options);
+  const ctx = new ParserContext(options);
   const [tree, root, isObject] = parseSync(ctx, source);
   return JSON.stringify([
     tree,
@@ -1580,7 +1568,7 @@ function toJSON(source, options) {
   ]);
 }
 async function toJSONAsync(source, options) {
-  const ctx = createParserContext(options);
+  const ctx = new ParserContext(options);
   const [tree, root, isObject] = await parseAsync(ctx, source);
   return JSON.stringify([
     tree,
@@ -1592,7 +1580,7 @@ async function toJSONAsync(source, options) {
 }
 function compileJSON(source) {
   const parsed = JSON.parse(source);
-  const serial = createSerializationContext({
+  const serial = new SerializationContext({
     features: parsed[3],
     markedRefs: parsed[4]
   });