seroval 0.4.0-alpha.10 → 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 = {};
@@ -31,28 +36,6 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/checks.ts
-function isPrimitive(current) {
-  if (!current || current === true) {
-    return true;
-  }
-  const type = typeof current;
-  return type === "number" || type === "string";
-}
-function isPromise(obj) {
-  return !!obj && (typeof obj === "object" || typeof obj === "function") && "then" in obj && typeof obj.then === "function";
-}
-function isIterableBuiltin(obj) {
-  if (!!obj && typeof obj === "object") {
-    const cons = obj.constructor;
-    return Array.isArray(obj) || cons === Set || cons === Map;
-  }
-  return false;
-}
-function isIterable(obj) {
-  return !!obj && typeof obj === "object" && !isIterableBuiltin(obj) && Symbol.iterator in obj && typeof obj[Symbol.iterator] === "function";
-}
-
 // src/compat.ts
 function compareVersion(left, right) {
   let diff = left[0] - right[0];
@@ -399,6 +382,120 @@ function quote(str) {
   return `"${result}"`;
 }
 
+// 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
+  };
+}
+
 // src/tree/shared.ts
 function getErrorConstructor(error) {
   if (error instanceof EvalError) {
@@ -452,33 +549,16 @@ function getIterableOptions(obj) {
 function isReferenceInStack(ctx, node) {
   return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
 }
-function generateSemiPrimitiveValue(ctx, current, id) {
-  const cs = current.constructor;
-  switch (cs) {
-    case Date:
-      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
-      };
-    case RegExp:
-      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 isIterable(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  switch (value.constructor) {
+    case Map:
+    case Set:
     case Int8Array:
     case Int16Array:
     case Int32Array:
@@ -487,288 +567,114 @@ function generateSemiPrimitiveValue(ctx, current, id) {
     case Uint32Array:
     case Uint8ClampedArray:
     case Float32Array:
-    case Float64Array: {
-      const constructor = cs.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
-      };
-    }
+    case Float64Array:
     case BigInt64Array:
-    case BigUint64Array: {
-      const constructor = cs.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: 14 /* TypedArray */,
-        i: id,
-        a: void 0,
-        s: result,
-        l: current.byteOffset,
-        m: void 0,
-        c: constructor,
-        d: void 0,
-        n: void 0
-      };
-    }
+    case BigUint64Array:
+      return false;
     default:
-      return void 0;
-  }
-}
-function serializePrimitive(value) {
-  if (value === true) {
-    return "!0";
-  }
-  if (value === false) {
-    return "!1";
-  }
-  if (value === void 0) {
-    return "void 0";
-  }
-  if (value === null) {
-    return null;
+      break;
   }
-  if (typeof value === "string") {
-    return quote(value);
-  }
-  if (Object.is(value, -0)) {
-    return "-0";
-  }
-  if (Object.is(value, Infinity)) {
-    return "1/0";
-  }
-  if (Object.is(value, -Infinity)) {
-    return "-1/0";
-  }
-  return value;
+  return Symbol.iterator in 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;
-  for (const key of keys) {
-    if (isIterable(properties[key])) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key];
-      deferredSize++;
-    } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key]);
-      nodesSize++;
-    }
-  }
-  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 < 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++;
-    }
-  }
-  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);
-  for (let i = 0; i < size; i++) {
-    if (i in current) {
-      if (isIterable(current[i])) {
-        deferred[i] = current[i];
-      } else {
-        nodes[i] = await generateTreeAsync(ctx, current[i]);
+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 < size; i++) {
-    if (i in deferred) {
-      nodes[i] = await generateTreeAsync(ctx, deferred[i]);
+    for (let i = 0; i < size; i++) {
+      if (i in deferred) {
+        nodes[i] = await this.parse(deferred[i]);
+      }
     }
+    return nodes;
   }
-  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 generateTreeAsync(ctx, current) {
-  if (isPrimitive(current)) {
+  async generateArrayNode(id, current) {
     return {
-      t: 0 /* Primitive */,
-      i: void 0,
-      s: serializePrimitive(current),
+      t: 7 /* Array */,
+      i: id,
+      a: await this.generateNodeList(current),
+      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: void 0
     };
   }
-  if (typeof current === "bigint") {
-    assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+  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 this.parse(deferredKey[i]);
+      valueNodes[nodeSize + i] = await this.parse(deferredValue[i]);
+    }
     return {
-      t: 1 /* BigInt */,
-      i: void 0,
+      t: 6 /* Map */,
+      i: id,
       a: void 0,
-      s: `${current}n`,
+      s: void 0,
       l: void 0,
       m: void 0,
       c: void 0,
-      d: void 0,
+      d: { k: keyNodes, v: valueNodes, s: len },
       n: void 0
     };
   }
-  const id = createRef(ctx, current, true);
-  if (ctx.markedRefs[id]) {
+  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[deferredSize++] = item;
+      } else {
+        nodes[nodeSize++] = await this.parse(item);
+      }
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = await this.parse(deferred[i]);
+    }
     return {
-      t: 2 /* Reference */,
+      t: 5 /* Set */,
       i: id,
-      a: void 0,
+      a: nodes,
       s: void 0,
       l: void 0,
       m: void 0,
@@ -777,43 +683,56 @@ async function generateTreeAsync(ctx, current) {
       n: void 0
     };
   }
-  if (Array.isArray(current)) {
-    return generateArrayNode(ctx, current, id);
-  }
-  const cs = current.constructor;
-  const empty = cs == null;
-  if (cs === Object || empty) {
-    if (Symbol.iterator in current) {
-      return generateIterableNode(ctx, current, id);
+  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++;
+      }
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes[nodesSize + i] = deferredKeys[i];
+      valueNodes[nodesSize + i] = await this.parse(deferredValues[i]);
     }
     return {
-      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      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: await serializePropertiesAsync(ctx, current),
-      a: void 0,
+      d: options ? await this.generateProperties(options) : void 0,
+      a: await this.generateNodeList(Array.from(current)),
       n: void 0
     };
   }
-  if (cs === Set) {
-    return generateSetNode(ctx, current, id);
-  }
-  if (cs === Map) {
-    return generateMapNode(ctx, current, id);
-  }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
-  }
-  if (Symbol.iterator in current) {
-    return generateIterableNode(ctx, current, id);
-  }
-  if (isPromise(current)) {
-    assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
+  async generatePromiseNode(id, current) {
+    assert(this.ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
     return current.then(async (value) => ({
       t: 10 /* Promise */,
       i: id,
@@ -824,20 +743,160 @@ async function generateTreeAsync(ctx, current) {
       // Parse options first before the items
       d: void 0,
       a: void 0,
-      n: await generateTreeAsync(ctx, value)
+      n: await this.parse(value)
     }));
   }
-  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-    return generateAggregateErrorNode(ctx, current, id);
+  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
+    };
   }
-  if (current instanceof Error) {
-    return generateErrorNode(ctx, current, id);
+  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)
+    };
   }
-  throw new Error("Unsupported value");
-}
+  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");
+      }
+      default:
+        throw new Error("Unsupported type");
+    }
+  }
+};
 async function parseAsync(ctx, current) {
-  const result = await generateTreeAsync(ctx, current);
-  return [result, createRef(ctx, current, false), result.t === 8 /* Object */];
+  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];
 }
 
 // src/tree/serialize.ts
@@ -1222,202 +1281,104 @@ 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;
-  for (const key of keys) {
-    if (isIterable(properties[key])) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key];
-      deferredSize++;
-    } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key]);
-      nodesSize++;
-    }
-  }
-  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);
+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++) {
-    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++;
+    for (let i = 0; i < size; i++) {
+      if (i in deferred) {
+        nodes[i] = this.parse(deferred[i]);
+      }
     }
+    return nodes;
   }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
-    valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
+  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
+    };
   }
-  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);
-  for (let i = 0; i < size; i++) {
-    if (i in current) {
-      if (isIterable(current[i])) {
-        deferred[i] = current[i];
+  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 {
-        nodes[i] = generateTreeSync(ctx, current[i]);
+        keyNodes[nodeSize] = this.parse(key);
+        valueNodes[nodeSize] = this.parse(value);
+        nodeSize++;
       }
     }
-  }
-  for (let i = 0; i < size; i++) {
-    if (i in deferred) {
-      nodes[i] = generateTreeSync(ctx, deferred[i]);
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes[nodeSize + i] = this.parse(deferredKey[i]);
+      valueNodes[nodeSize + i] = this.parse(deferredValue[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 generateTreeSync(ctx, current) {
-  if (isPrimitive(current)) {
     return {
-      t: 0 /* Primitive */,
-      i: void 0,
-      s: serializePrimitive(current),
+      t: 6 /* Map */,
+      i: id,
+      a: void 0,
+      s: void 0,
       l: void 0,
       m: void 0,
       c: void 0,
-      // Parse options first before the items
-      d: void 0,
-      a: void 0,
+      d: { k: keyNodes, v: valueNodes, s: len },
       n: void 0
     };
   }
-  if (typeof current === "bigint") {
-    assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+  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[deferredSize++] = item;
+      } else {
+        nodes[nodeSize++] = this.parse(item);
+      }
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = this.parse(deferred[i]);
+    }
     return {
-      t: 1 /* BigInt */,
-      i: void 0,
-      a: void 0,
-      s: `${current}n`,
+      t: 5 /* Set */,
+      i: id,
+      a: nodes,
+      s: void 0,
       l: void 0,
       m: void 0,
       c: void 0,
@@ -1425,28 +1386,57 @@ function generateTreeSync(ctx, current) {
       n: void 0
     };
   }
-  const id = createRef(ctx, current, true);
-  if (ctx.markedRefs[id]) {
+  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++;
+      }
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes[nodesSize + i] = deferredKeys[i];
+      valueNodes[nodesSize + i] = this.parse(deferredValues[i]);
+    }
     return {
-      t: 2 /* Reference */,
+      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,
-      a: void 0,
       s: void 0,
       l: void 0,
       m: void 0,
       c: void 0,
-      d: void 0,
+      // Parse options first before the items
+      d: options ? this.generateProperties(options) : void 0,
+      a: this.generateNodeList(Array.from(current)),
       n: void 0
     };
   }
-  if (Array.isArray(current)) {
-    return generateArrayNode2(ctx, current, id);
-  }
-  const cs = current.constructor;
-  const empty = cs == null;
-  if (cs === Object || empty) {
+  generateObjectNode(id, current, empty) {
     if (Symbol.iterator in current) {
-      return generateIterableNode2(ctx, current, id);
+      return this.generateIterableNode(id, current);
     }
     return {
       t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
@@ -1455,36 +1445,135 @@ function generateTreeSync(ctx, current) {
       l: void 0,
       m: void 0,
       c: void 0,
-      // Parse options first before the items
-      d: serializePropertiesSync(ctx, current),
+      d: this.generateProperties(current),
       a: void 0,
       n: void 0
     };
   }
-  if (cs === Set) {
-    return generateSetNode2(ctx, current, id);
-  }
-  if (cs === Map) {
-    return generateMapNode2(ctx, current, id);
-  }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
-  }
-  if (Symbol.iterator in current) {
-    return generateIterableNode2(ctx, current, id);
+  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)
+    };
   }
-  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-    return generateAggregateErrorNode2(ctx, current, id);
+  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
+    };
   }
-  if (current instanceof Error) {
-    return generateErrorNode2(ctx, current, id);
+  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");
+      }
+      default:
+        throw new Error("Unsupported type");
+    }
   }
-  throw new Error("Unsupported value");
-}
+};
 function parseSync(ctx, current) {
-  const result = generateTreeSync(ctx, current);
-  return [result, createRef(ctx, current, false), result.t === 8 /* Object */];
+  const result = new SyncParser(ctx).parse(current);
+  const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
+  return [result, createRef(ctx, current, false), isObject];
 }
 
 // src/index.ts
@@ -1514,9 +1603,6 @@ function finalize(ctx, rootID, isObject, result) {
 }
 function serialize(source, options) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
@@ -1524,9 +1610,6 @@ function serialize(source, options) {
 }
 async function serializeAsync(source, options) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);