seroval 0.4.0-alpha.11 → 0.4.0-alpha.12

package/dist/cjs/development/index.cjs

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,6 +17,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // src/index.ts
 var src_exports = {};
@@ -573,317 +578,323 @@ 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 {
+      t: 7 /* Array */,
+      i: id,
+      a: await this.generateNodeList(current),
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      d: void 0,
+      n: void 0
+    };
+  }
+  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 {
+      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 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 {
+      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 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 {
+      k: keyNodes,
+      v: valueNodes,
+      s: size
+    };
+  }
+  async generateIterableNode(id, current) {
+    assert(this.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 this.generateProperties(options) : void 0,
+      a: await this.generateNodeList(Array.from(current)),
+      n: void 0
+    };
+  }
+  async generatePromiseNode(id, current) {
+    assert(this.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 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);
+    }
+    return {
+      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      d: await this.generateProperties(current),
+      a: void 0,
+      n: void 0
+    };
+  }
+  async generateAggregateErrorNode(id, current) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? await this.generateProperties(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 this.parse(current.errors)
+    };
+  }
+  async generateErrorNode(id, current) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? await this.generateProperties(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 parse(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(this.ctx, current);
+      case "object": {
+        if (!current) {
+          return NULL_NODE;
+        }
+        const id = createRef(this.ctx, current, true);
+        if (this.ctx.markedRefs[id]) {
+          return createReferenceNode(id);
+        }
+        if (Array.isArray(current)) {
+          return this.generateArrayNode(id, current);
+        }
+        switch (current.constructor) {
+          case Date:
+            return createDateNode(id, current);
+          case RegExp:
+            return createRegExpNode(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:
+            return createTypedArrayNode(this.ctx, id, current);
+          case BigInt64Array:
+          case BigUint64Array:
+            return createBigIntTypedArrayNode(this.ctx, 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];
 }
@@ -1270,291 +1281,297 @@ 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 {
+      t: 7 /* Array */,
+      i: id,
+      a: this.generateNodeList(current),
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      d: void 0,
+      n: void 0
+    };
+  }
+  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 {
+      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
+    };
+  }
+  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 {
+      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
+    };
+  }
+  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 {
+      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 ? this.generateProperties(options) : void 0,
+      a: this.generateNodeList(Array.from(current)),
+      n: void 0
+    };
+  }
+  generateObjectNode(id, current, empty) {
+    if (Symbol.iterator in current) {
+      return this.generateIterableNode(id, current);
+    }
+    return {
+      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      d: this.generateProperties(current),
+      a: void 0,
+      n: void 0
+    };
+  }
+  generateAggregateErrorNode(id, current) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? this.generateProperties(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: this.parse(current.errors)
+    };
+  }
+  generateErrorNode(id, current) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? this.generateProperties(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
+    };
+  }
+  parse(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(this.ctx, current);
+      case "object": {
+        if (!current) {
+          return NULL_NODE;
+        }
+        const id = createRef(this.ctx, current, true);
+        if (this.ctx.markedRefs[id]) {
+          return createReferenceNode(id);
+        }
+        if (Array.isArray(current)) {
+          return this.generateArrayNode(id, current);
+        }
+        switch (current.constructor) {
+          case Date:
+            return createDateNode(id, current);
+          case RegExp:
+            return createRegExpNode(id, current);
+          case Int8Array:
+          case Int16Array:
+          case Int32Array:
+          case Uint8Array:
+          case Uint16Array:
+          case Uint32Array:
+          case Uint8ClampedArray:
+          case Float32Array:
+          case Float64Array:
+            return createTypedArrayNode(this.ctx, id, current);
+          case BigInt64Array:
+          case BigUint64Array:
+            return createBigIntTypedArrayNode(this.ctx, 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];
 }