seroval 0.4.0-alpha.16 → 0.4.0-alpha.18

package/dist/cjs/development/index.cjs

@@ -263,10 +263,11 @@ function createTypedArrayNode(ctx, id, current) {
     n: void 0
   };
 }
+var BIGINT_FLAG = 4096 /* BigIntTypedArray */ | 8 /* BigInt */;
 function createBigIntTypedArrayNode(ctx, id, current) {
   const constructor = current.constructor.name;
   assert(
-    ctx.features & 4096 /* BigIntTypedArray */,
+    (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
     `Unsupported value type "${constructor}"`
   );
   let result = "";
@@ -375,337 +376,335 @@ function isIterable(value) {
 }
 
 // src/tree/async.ts
-var AsyncParser = class {
-  static async 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];
-        if (isIterable(item)) {
-          deferred[i] = item;
-        } else {
-          nodes[i] = await this.parse(ctx, item);
-        }
-      }
-    }
-    for (let i = 0; i < size; i++) {
-      if (i in deferred) {
-        nodes[i] = await this.parse(ctx, deferred[i]);
-      }
-    }
-    return nodes;
-  }
-  static async generateArrayNode(ctx, id, current) {
-    return {
-      t: 7 /* Array */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      d: void 0,
-      a: await this.generateNodeList(ctx, current),
-      n: void 0
-    };
-  }
-  static async generateMapNode(ctx, id, current) {
-    assert(ctx.features & 32 /* 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(ctx, key);
-        valueNodes[nodeSize] = await this.parse(ctx, value);
-        nodeSize++;
-      }
-    }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodeSize + i] = await this.parse(ctx, deferredKey[i]);
-      valueNodes[nodeSize + i] = await this.parse(ctx, deferredValue[i]);
-    }
-    return {
-      t: 6 /* Map */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      d: { k: keyNodes, v: valueNodes, s: len },
-      a: void 0,
-      n: void 0
-    };
-  }
-  static async generateSetNode(ctx, id, current) {
-    assert(ctx.features & 512 /* 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()) {
+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];
       if (isIterable(item)) {
-        deferred[deferredSize++] = item;
+        deferred[i] = item;
       } else {
-        nodes[nodeSize++] = await this.parse(ctx, item);
+        nodes[i] = await parse(ctx, item);
       }
     }
-    for (let i = 0; i < deferredSize; i++) {
-      nodes[nodeSize + i] = await this.parse(ctx, deferred[i]);
-    }
-    return {
-      t: 5 /* Set */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      d: void 0,
-      a: nodes,
-      n: void 0
-    };
   }
-  static async generateProperties(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 this.parse(ctx, item);
-        nodesSize++;
-      }
-    }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodesSize + i] = deferredKeys[i];
-      valueNodes[nodesSize + i] = await this.parse(ctx, deferredValues[i]);
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = await parse(ctx, deferred[i]);
     }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: size
-    };
   }
-  static async generateIterableNode(ctx, id, current) {
-    assert(ctx.features & 1024 /* SymbolIterator */, 'Unsupported type "Iterable"');
-    const options = getIterableOptions(current);
-    return {
-      t: 13 /* Iterable */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      // Parse options first before the items
-      d: options ? await this.generateProperties(ctx, options) : void 0,
-      a: await this.generateNodeList(ctx, Array.from(current)),
-      n: void 0
-    };
+  return nodes;
+}
+async function generateArrayNode(ctx, id, current) {
+  return {
+    t: 7 /* Array */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: await generateNodeList(ctx, current),
+    n: void 0
+  };
+}
+async function generateMapNode(ctx, id, current) {
+  assert(ctx.features & 32 /* 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 parse(ctx, key);
+      valueNodes[nodeSize] = await parse(ctx, value);
+      nodeSize++;
+    }
   }
-  static async generatePromiseNode(ctx, id, current) {
-    assert(ctx.features & 256 /* Promise */, 'Unsupported type "Promise"');
-    return current.then(async (value) => ({
-      t: 10 /* Promise */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      // Parse options first before the items
-      d: void 0,
-      a: void 0,
-      n: await this.parse(ctx, value)
-    }));
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodeSize + i] = await parse(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = await parse(ctx, deferredValue[i]);
   }
-  static async generateObjectNode(ctx, id, current, empty) {
-    if (Symbol.iterator in current) {
-      return this.generateIterableNode(ctx, id, current);
+  return {
+    t: 6 /* Map */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: { k: keyNodes, v: valueNodes, s: len },
+    a: void 0,
+    n: void 0
+  };
+}
+async function generateSetNode(ctx, id, current) {
+  assert(ctx.features & 512 /* 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 parse(ctx, item);
     }
-    if ("then" in current && typeof current.then === "function") {
-      return this.generatePromiseNode(ctx, id, current);
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    nodes[nodeSize + i] = await parse(ctx, deferred[i]);
+  }
+  return {
+    t: 5 /* Set */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: nodes,
+    n: void 0
+  };
+}
+async function generateProperties(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 parse(ctx, item);
+      nodesSize++;
     }
-    return {
-      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      d: await this.generateProperties(ctx, current),
-      a: void 0,
-      n: void 0
-    };
   }
-  static async generateAggregateErrorNode(ctx, id, current) {
-    const options = getErrorOptions(ctx, current);
-    const optionsNode = options ? await this.generateProperties(ctx, options) : void 0;
-    return {
-      t: 12 /* AggregateError */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: current.message,
-      d: optionsNode,
-      a: void 0,
-      n: await this.parse(ctx, current.errors)
-    };
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await parse(ctx, deferredValues[i]);
   }
-  static async generateErrorNode(ctx, id, current) {
-    const options = getErrorOptions(ctx, current);
-    const optionsNode = options ? await this.generateProperties(ctx, options) : void 0;
-    return {
-      t: 11 /* Error */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: getErrorConstructor(current),
-      m: current.message,
-      d: optionsNode,
-      a: void 0,
-      n: void 0
-    };
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
+}
+async function generateIterableNode(ctx, id, current) {
+  assert(ctx.features & 1024 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  const options = getIterableOptions(current);
+  return {
+    t: 13 /* Iterable */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    // Parse options first before the items
+    d: options ? await generateProperties(ctx, options) : void 0,
+    a: await generateNodeList(ctx, Array.from(current)),
+    n: void 0
+  };
+}
+async function generatePromiseNode(ctx, id, current) {
+  assert(ctx.features & 256 /* Promise */, 'Unsupported type "Promise"');
+  return current.then(async (value) => ({
+    t: 10 /* Promise */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    // Parse options first before the items
+    d: void 0,
+    a: void 0,
+    n: await parse(ctx, value)
+  }));
+}
+async function generateObjectNode(ctx, id, current, empty) {
+  if (Symbol.iterator in current) {
+    return generateIterableNode(ctx, id, current);
   }
-  static async parse(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.has(id)) {
-          return createReferenceNode(id);
-        }
-        if (Array.isArray(current)) {
-          return this.generateArrayNode(ctx, id, current);
-        }
-        switch (current.constructor) {
-          case Date:
-            return createDateNode(id, current);
-          case RegExp:
-            return createRegExpNode(id, current);
-          case Promise:
-            return this.generatePromiseNode(ctx, id, current);
-          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 Map:
-            return this.generateMapNode(
-              ctx,
-              id,
-              current
-            );
-          case Set:
-            return this.generateSetNode(
-              ctx,
-              id,
-              current
-            );
-          case Object:
-            return this.generateObjectNode(
-              ctx,
-              id,
-              current,
-              false
-            );
-          case void 0:
-            return this.generateObjectNode(
-              ctx,
-              id,
-              current,
-              true
-            );
-          case AggregateError:
-            if (ctx.features & 1 /* AggregateError */) {
-              return this.generateAggregateErrorNode(ctx, id, current);
-            }
-            return this.generateErrorNode(ctx, id, current);
-          case Error:
-          case EvalError:
-          case RangeError:
-          case ReferenceError:
-          case SyntaxError:
-          case TypeError:
-          case URIError:
-            return this.generateErrorNode(ctx, id, current);
-          default:
-            break;
-        }
-        if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-          return this.generateAggregateErrorNode(ctx, id, current);
-        }
-        if (current instanceof Error) {
-          return this.generateErrorNode(ctx, id, current);
-        }
-        if (current instanceof Promise) {
-          return this.generatePromiseNode(ctx, id, current);
-        }
-        if (Symbol.iterator in current) {
-          return this.generateIterableNode(ctx, id, current);
-        }
-        if ("then" in current && typeof current.then === "function") {
-          return this.generatePromiseNode(ctx, id, current);
-        }
-        throw new Error("Unsupported type");
+  if ("then" in current && typeof current.then === "function") {
+    return generatePromiseNode(ctx, id, current);
+  }
+  return {
+    t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: await generateProperties(ctx, current),
+    a: void 0,
+    n: void 0
+  };
+}
+async function generateAggregateErrorNode(ctx, id, current) {
+  const options = getErrorOptions(ctx, current);
+  const optionsNode = options ? await generateProperties(ctx, options) : void 0;
+  return {
+    t: 12 /* AggregateError */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: current.message,
+    d: optionsNode,
+    a: void 0,
+    n: await parse(ctx, current.errors)
+  };
+}
+async function generateErrorNode(ctx, id, current) {
+  const options = getErrorOptions(ctx, current);
+  const optionsNode = options ? await generateProperties(ctx, options) : void 0;
+  return {
+    t: 11 /* Error */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: getErrorConstructor(current),
+    m: current.message,
+    d: optionsNode,
+    a: void 0,
+    n: void 0
+  };
+}
+async function parse(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;
       }
-      default:
-        throw new Error("Unsupported type");
+      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.has(id)) {
+        return createReferenceNode(id);
+      }
+      if (Array.isArray(current)) {
+        return generateArrayNode(ctx, id, current);
+      }
+      switch (current.constructor) {
+        case Date:
+          return createDateNode(id, current);
+        case RegExp:
+          return createRegExpNode(id, current);
+        case Promise:
+          return generatePromiseNode(ctx, id, current);
+        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 Map:
+          return generateMapNode(
+            ctx,
+            id,
+            current
+          );
+        case Set:
+          return generateSetNode(
+            ctx,
+            id,
+            current
+          );
+        case Object:
+          return generateObjectNode(
+            ctx,
+            id,
+            current,
+            false
+          );
+        case void 0:
+          return generateObjectNode(
+            ctx,
+            id,
+            current,
+            true
+          );
+        case AggregateError:
+          if (ctx.features & 1 /* AggregateError */) {
+            return generateAggregateErrorNode(ctx, id, current);
+          }
+          return generateErrorNode(ctx, id, current);
+        case Error:
+        case EvalError:
+        case RangeError:
+        case ReferenceError:
+        case SyntaxError:
+        case TypeError:
+        case URIError:
+          return generateErrorNode(ctx, id, current);
+        default:
+          break;
+      }
+      if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+        return generateAggregateErrorNode(ctx, id, current);
+      }
+      if (current instanceof Error) {
+        return generateErrorNode(ctx, id, current);
+      }
+      if (current instanceof Promise) {
+        return generatePromiseNode(ctx, id, current);
+      }
+      if (Symbol.iterator in current) {
+        return generateIterableNode(ctx, id, current);
+      }
+      if ("then" in current && typeof current.then === "function") {
+        return generatePromiseNode(ctx, id, current);
+      }
+      throw new Error("Unsupported type");
     }
+    default:
+      throw new Error("Unsupported type");
   }
-};
+}
 async function parseAsync(ctx, current) {
-  const result = await AsyncParser.parse(ctx, current);
+  const result = await parse(ctx, current);
   const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
   return [result, createRef(ctx, current, false), isObject];
 }
@@ -823,579 +822,580 @@ function isReferenceInStack(ctx, node) {
   return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
 }
 var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
-var SerovalSerializer = class {
-  static serializeNodeList(ctx, node) {
-    const size = node.a.length;
-    let values = "";
-    let item;
-    let isHoley = false;
-    for (let i = 0; i < size; i++) {
-      if (i !== 0) {
-        values += ",";
-      }
-      item = node.a[i];
-      if (item) {
-        if (isReferenceInStack(ctx, item)) {
-          createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
-          isHoley = true;
-        } else {
-          values += this.serialize(ctx, item);
-          isHoley = false;
-        }
-      } else {
-        isHoley = true;
-      }
-    }
-    if (isHoley) {
+function serializeNodeList(ctx, node) {
+  const size = node.a.length;
+  let values = "";
+  let item;
+  let isHoley = false;
+  for (let i = 0; i < size; i++) {
+    if (i !== 0) {
       values += ",";
     }
-    return "[" + values + "]";
-  }
-  static serializeArray(ctx, node) {
-    ctx.stack.push(node.i);
-    const result = this.serializeNodeList(ctx, node);
-    ctx.stack.pop();
-    return assignRef(ctx, node.i, result);
-  }
-  static serializeObject(ctx, sourceID, node) {
-    if (node.s === 0) {
-      return "{}";
-    }
-    let result = "";
-    ctx.stack.push(sourceID);
-    let key;
-    let val;
-    let check;
-    let isIdentifier;
-    let refParam;
-    let hasPrev = false;
-    for (let i = 0; i < node.s; i++) {
-      key = node.k[i];
-      val = node.v[i];
-      check = Number(key);
-      isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-      if (isReferenceInStack(ctx, val)) {
-        refParam = getRefParam(ctx, val.i);
-        if (isIdentifier && Number.isNaN(check)) {
-          createObjectAssign(ctx, sourceID, key, refParam);
-        } else {
-          createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
-        }
+    item = node.a[i];
+    if (item) {
+      if (isReferenceInStack(ctx, item)) {
+        createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
+        isHoley = true;
       } else {
-        if (hasPrev) {
-          result += ",";
-        }
-        result += isIdentifier ? key : quote(key);
-        result += ":" + this.serialize(ctx, val);
-        hasPrev = true;
+        values += serializeTree(ctx, item);
+        isHoley = false;
       }
+    } else {
+      isHoley = true;
     }
-    ctx.stack.pop();
-    return "{" + result + "}";
   }
-  static serializeWithObjectAssign(ctx, value, id, serialized) {
-    const fields = this.serializeObject(ctx, id, value);
-    if (fields !== "{}") {
-      return "Object.assign(" + serialized + "," + fields + ")";
-    }
-    return serialized;
+  if (isHoley) {
+    values += ",";
   }
-  static serializeAssignments(ctx, sourceID, node) {
-    ctx.stack.push(sourceID);
-    const mainAssignments = [];
-    let parentStack;
-    let refParam;
-    let key;
-    let check;
-    let parentAssignment;
-    let isIdentifier;
-    for (let i = 0; i < node.s; i++) {
-      parentStack = ctx.stack;
-      ctx.stack = [];
-      refParam = this.serialize(ctx, node.v[i]);
-      ctx.stack = parentStack;
-      key = node.k[i];
-      check = Number(key);
-      parentAssignment = ctx.assignments;
-      ctx.assignments = mainAssignments;
-      isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+  return "[" + values + "]";
+}
+function serializeArray(ctx, node) {
+  ctx.stack.push(node.i);
+  const result = serializeNodeList(ctx, node);
+  ctx.stack.pop();
+  return assignRef(ctx, node.i, result);
+}
+function serializeObject(ctx, sourceID, node) {
+  if (node.s === 0) {
+    return "{}";
+  }
+  let result = "";
+  ctx.stack.push(sourceID);
+  let key;
+  let val;
+  let check;
+  let isIdentifier;
+  let refParam;
+  let hasPrev = false;
+  for (let i = 0; i < node.s; i++) {
+    key = node.k[i];
+    val = node.v[i];
+    check = Number(key);
+    isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    if (isReferenceInStack(ctx, val)) {
+      refParam = getRefParam(ctx, val.i);
       if (isIdentifier && Number.isNaN(check)) {
         createObjectAssign(ctx, sourceID, key, refParam);
       } else {
         createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
       }
-      ctx.assignments = parentAssignment;
+    } else {
+      if (hasPrev) {
+        result += ",";
+      }
+      result += isIdentifier ? key : quote(key);
+      result += ":" + serializeTree(ctx, val);
+      hasPrev = true;
     }
-    ctx.stack.pop();
-    return resolveAssignments(mainAssignments);
   }
-  static serializeDictionary(ctx, i, d, init) {
-    if (d) {
-      if (ctx.features & 128 /* ObjectAssign */) {
-        init = this.serializeWithObjectAssign(ctx, d, i, init);
-      } else {
-        markRef(ctx, i);
-        const assignments = this.serializeAssignments(ctx, i, d);
-        if (assignments) {
-          const ref = getRefParam(ctx, i);
-          return "(" + assignRef(ctx, i, init) + "," + assignments + ref + ")";
-        }
-      }
+  ctx.stack.pop();
+  return "{" + result + "}";
+}
+function serializeWithObjectAssign(ctx, value, id, serialized) {
+  const fields = serializeObject(ctx, id, value);
+  if (fields !== "{}") {
+    return "Object.assign(" + serialized + "," + fields + ")";
+  }
+  return serialized;
+}
+function serializeAssignments(ctx, sourceID, node) {
+  ctx.stack.push(sourceID);
+  const mainAssignments = [];
+  let parentStack;
+  let refParam;
+  let key;
+  let check;
+  let parentAssignment;
+  let isIdentifier;
+  for (let i = 0; i < node.s; i++) {
+    parentStack = ctx.stack;
+    ctx.stack = [];
+    refParam = serializeTree(ctx, node.v[i]);
+    ctx.stack = parentStack;
+    key = node.k[i];
+    check = Number(key);
+    parentAssignment = ctx.assignments;
+    ctx.assignments = mainAssignments;
+    isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    if (isIdentifier && Number.isNaN(check)) {
+      createObjectAssign(ctx, sourceID, key, refParam);
+    } else {
+      createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
     }
-    return assignRef(ctx, i, init);
+    ctx.assignments = parentAssignment;
   }
-  static serializeNullConstructor(ctx, node) {
-    return this.serializeDictionary(ctx, node.i, node.d, "Object.create(null)");
+  ctx.stack.pop();
+  return resolveAssignments(mainAssignments);
+}
+function serializeDictionary(ctx, i, d, init) {
+  if (d) {
+    if (ctx.features & 128 /* ObjectAssign */) {
+      init = serializeWithObjectAssign(ctx, d, i, init);
+    } else {
+      markRef(ctx, i);
+      const assignments = serializeAssignments(ctx, i, d);
+      if (assignments) {
+        const ref = getRefParam(ctx, i);
+        return "(" + assignRef(ctx, i, init) + "," + assignments + ref + ")";
+      }
+    }
   }
-  static serializeSet(ctx, node) {
-    let serialized = "new Set";
-    const size = node.a.length;
-    if (size) {
-      let result = "";
-      ctx.stack.push(node.i);
-      let item;
-      let hasPrev = false;
-      for (let i = 0; i < size; i++) {
-        item = node.a[i];
-        if (isReferenceInStack(ctx, item)) {
-          createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
-        } else {
-          if (hasPrev) {
-            result += ",";
-          }
-          result += this.serialize(ctx, item);
-          hasPrev = true;
+  return assignRef(ctx, i, init);
+}
+function serializeNullConstructor(ctx, node) {
+  return serializeDictionary(ctx, node.i, node.d, "Object.create(null)");
+}
+function serializeSet(ctx, node) {
+  let serialized = "new Set";
+  const size = node.a.length;
+  if (size) {
+    let result = "";
+    ctx.stack.push(node.i);
+    let item;
+    let hasPrev = false;
+    for (let i = 0; i < size; i++) {
+      item = node.a[i];
+      if (isReferenceInStack(ctx, item)) {
+        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
+      } else {
+        if (hasPrev) {
+          result += ",";
         }
-      }
-      ctx.stack.pop();
-      if (result) {
-        serialized += "([" + result + "])";
+        result += serializeTree(ctx, item);
+        hasPrev = true;
       }
     }
-    return assignRef(ctx, node.i, serialized);
+    ctx.stack.pop();
+    if (result) {
+      serialized += "([" + result + "])";
+    }
   }
-  static serializeMap(ctx, node) {
-    let serialized = "new Map";
-    if (node.d.s) {
-      let result = "";
-      ctx.stack.push(node.i);
-      let key;
-      let val;
-      let keyRef;
-      let valueRef;
-      let parent;
-      let hasPrev = false;
-      for (let i = 0; i < node.d.s; i++) {
-        key = node.d.k[i];
-        val = node.d.v[i];
-        if (isReferenceInStack(ctx, key)) {
-          keyRef = getRefParam(ctx, key.i);
-          if (isReferenceInStack(ctx, val)) {
-            valueRef = getRefParam(ctx, val.i);
-            createMapSet(ctx, node.i, keyRef, valueRef);
-          } else {
-            parent = ctx.stack;
-            ctx.stack = [];
-            createMapSet(ctx, node.i, keyRef, this.serialize(ctx, val));
-            ctx.stack = parent;
-          }
-        } else if (isReferenceInStack(ctx, val)) {
+  return assignRef(ctx, node.i, serialized);
+}
+function serializeMap(ctx, node) {
+  let serialized = "new Map";
+  if (node.d.s) {
+    let result = "";
+    ctx.stack.push(node.i);
+    let key;
+    let val;
+    let keyRef;
+    let valueRef;
+    let parent;
+    let hasPrev = false;
+    for (let i = 0; i < node.d.s; i++) {
+      key = node.d.k[i];
+      val = node.d.v[i];
+      if (isReferenceInStack(ctx, key)) {
+        keyRef = getRefParam(ctx, key.i);
+        if (isReferenceInStack(ctx, val)) {
           valueRef = getRefParam(ctx, val.i);
+          createMapSet(ctx, node.i, keyRef, valueRef);
+        } else {
           parent = ctx.stack;
           ctx.stack = [];
-          createMapSet(ctx, node.i, this.serialize(ctx, key), valueRef);
+          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
           ctx.stack = parent;
-        } else {
-          if (hasPrev) {
-            result += ",";
-          }
-          result += "[" + this.serialize(ctx, key) + "," + this.serialize(ctx, val) + "]";
-          hasPrev = true;
         }
-      }
-      ctx.stack.pop();
-      if (result) {
-        serialized += "([" + result + "])";
+      } else if (isReferenceInStack(ctx, val)) {
+        valueRef = getRefParam(ctx, val.i);
+        parent = ctx.stack;
+        ctx.stack = [];
+        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
+        ctx.stack = parent;
+      } else {
+        if (hasPrev) {
+          result += ",";
+        }
+        result += "[" + serializeTree(ctx, key) + "," + serializeTree(ctx, val) + "]";
+        hasPrev = true;
       }
     }
-    return assignRef(ctx, node.i, serialized);
-  }
-  static serializeAggregateError(ctx, node) {
-    ctx.stack.push(node.i);
-    const serialized = "new AggregateError(" + this.serialize(ctx, node.n) + "," + quote(node.m) + ")";
     ctx.stack.pop();
-    return this.serializeDictionary(ctx, node.i, node.d, serialized);
-  }
-  static serializeError(ctx, node) {
-    const serialized = "new " + node.c + "(" + quote(node.m) + ")";
-    return this.serializeDictionary(ctx, node.i, node.d, serialized);
-  }
-  static serializePromise(ctx, node) {
-    let serialized;
-    if (isReferenceInStack(ctx, node.n)) {
-      serialized = "Promise.resolve().then(()=>" + getRefParam(ctx, node.n.i) + ")";
-    } else {
-      ctx.stack.push(node.i);
-      const result = this.serialize(ctx, node.n);
-      ctx.stack.pop();
-      serialized = "Promise.resolve(" + result + ")";
+    if (result) {
+      serialized += "([" + result + "])";
     }
-    return assignRef(ctx, node.i, serialized);
   }
-  static serializeTypedArray(ctx, node) {
-    let args = "[" + node.s + "]";
-    if (node.l !== 0) {
-      args += "," + node.l.toString();
-    }
-    return assignRef(ctx, node.i, "new " + node.c + "(" + args + ")");
-  }
-  static serializeIterable(ctx, node) {
-    const parent = ctx.stack;
-    ctx.stack = [];
-    const values = this.serializeNodeList(ctx, node);
-    ctx.stack = parent;
-    let serialized = values;
-    if (ctx.features & 2 /* ArrayPrototypeValues */) {
-      serialized += ".values()";
-    } else {
-      serialized += "[Symbol.iterator]()";
-    }
+  return assignRef(ctx, node.i, serialized);
+}
+function serializeAggregateError(ctx, node) {
+  ctx.stack.push(node.i);
+  const serialized = "new AggregateError(" + serializeTree(ctx, node.n) + "," + quote(node.m) + ")";
+  ctx.stack.pop();
+  return serializeDictionary(ctx, node.i, node.d, serialized);
+}
+function serializeError(ctx, node) {
+  const serialized = "new " + node.c + "(" + quote(node.m) + ")";
+  return serializeDictionary(ctx, node.i, node.d, serialized);
+}
+function serializePromise(ctx, node) {
+  let serialized;
+  if (isReferenceInStack(ctx, node.n)) {
+    const ref = getRefParam(ctx, node.n.i);
     if (ctx.features & 4 /* ArrowFunction */) {
-      serialized = "{[Symbol.iterator]:()=>" + serialized + "}";
-    } else if (ctx.features & 64 /* MethodShorthand */) {
-      serialized = "{[Symbol.iterator](){return " + serialized + "}}";
+      serialized = "Promise.resolve().then(()=>" + ref + ")";
     } else {
-      serialized = "{[Symbol.iterator]:function(){return " + serialized + "}}";
+      serialized = "Promise.resolve().then(function(){return " + ref + "})";
     }
-    return this.serializeDictionary(ctx, node.i, node.d, serialized);
+  } else {
+    ctx.stack.push(node.i);
+    const result = serializeTree(ctx, node.n);
+    ctx.stack.pop();
+    serialized = "Promise.resolve(" + result + ")";
   }
-  static serialize(ctx, node) {
-    switch (node.t) {
-      case 0 /* Primitive */:
-        return String(node.s);
-      case 1 /* BigInt */:
-        return node.s;
-      case 2 /* Reference */:
-        return getRefParam(ctx, node.i);
-      case 7 /* Array */:
-        return this.serializeArray(ctx, node);
-      case 8 /* Object */:
-        return assignRef(ctx, node.i, this.serializeObject(ctx, node.i, node.d));
-      case 9 /* NullConstructor */:
-        return this.serializeNullConstructor(ctx, node);
-      case 3 /* Date */:
-        return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
-      case 4 /* RegExp */:
-        return assignRef(ctx, node.i, node.s);
-      case 5 /* Set */:
-        return this.serializeSet(ctx, node);
-      case 6 /* Map */:
-        return this.serializeMap(ctx, node);
-      case 15 /* BigIntTypedArray */:
-      case 14 /* TypedArray */:
-        return this.serializeTypedArray(ctx, node);
-      case 12 /* AggregateError */:
-        return this.serializeAggregateError(ctx, node);
-      case 11 /* Error */:
-        return this.serializeError(ctx, node);
-      case 13 /* Iterable */:
-        return this.serializeIterable(ctx, node);
-      case 10 /* Promise */:
-        return this.serializePromise(ctx, node);
-      default:
-        throw new Error("Unsupported type");
-    }
+  return assignRef(ctx, node.i, serialized);
+}
+function serializeTypedArray(ctx, node) {
+  let args = "[" + node.s + "]";
+  if (node.l !== 0) {
+    args += "," + node.l.toString();
   }
-};
-
-// src/tree/sync.ts
-var SyncParser = class {
-  static 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];
-        if (isIterable(item)) {
-          deferred[i] = item;
-        } else {
-          nodes[i] = this.parse(ctx, item);
-        }
-      }
-    }
-    for (let i = 0; i < size; i++) {
-      if (i in deferred) {
-        nodes[i] = this.parse(ctx, deferred[i]);
-      }
-    }
-    return nodes;
+  return assignRef(ctx, node.i, "new " + node.c + "(" + args + ")");
+}
+function serializeIterable(ctx, node) {
+  const parent = ctx.stack;
+  ctx.stack = [];
+  const values = serializeNodeList(ctx, node);
+  ctx.stack = parent;
+  let serialized = values;
+  if (ctx.features & 2 /* ArrayPrototypeValues */) {
+    serialized += ".values()";
+  } else {
+    serialized += "[Symbol.iterator]()";
   }
-  static generateArrayNode(ctx, id, current) {
-    return {
-      t: 7 /* Array */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      d: void 0,
-      a: this.generateNodeList(ctx, current),
-      n: void 0
-    };
+  if (ctx.features & 4 /* ArrowFunction */) {
+    serialized = "{[Symbol.iterator]:()=>" + serialized + "}";
+  } else if (ctx.features & 64 /* MethodShorthand */) {
+    serialized = "{[Symbol.iterator](){return " + serialized + "}}";
+  } else {
+    serialized = "{[Symbol.iterator]:function(){return " + serialized + "}}";
   }
-  static generateMapNode(ctx, id, current) {
-    assert(ctx.features & 32 /* 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(ctx, key);
-        valueNodes[nodeSize] = this.parse(ctx, value);
-        nodeSize++;
-      }
-    }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodeSize + i] = this.parse(ctx, deferredKey[i]);
-      valueNodes[nodeSize + i] = this.parse(ctx, deferredValue[i]);
-    }
-    return {
-      t: 6 /* Map */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      d: { k: keyNodes, v: valueNodes, s: len },
-      a: void 0,
-      n: void 0
-    };
+  return serializeDictionary(ctx, node.i, node.d, serialized);
+}
+function serializeTree(ctx, node) {
+  switch (node.t) {
+    case 0 /* Primitive */:
+      return String(node.s);
+    case 1 /* BigInt */:
+      return node.s;
+    case 2 /* Reference */:
+      return getRefParam(ctx, node.i);
+    case 7 /* Array */:
+      return serializeArray(ctx, node);
+    case 8 /* Object */:
+      return assignRef(ctx, node.i, serializeObject(ctx, node.i, node.d));
+    case 9 /* NullConstructor */:
+      return serializeNullConstructor(ctx, node);
+    case 3 /* Date */:
+      return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
+    case 4 /* RegExp */:
+      return assignRef(ctx, node.i, node.s);
+    case 5 /* Set */:
+      return serializeSet(ctx, node);
+    case 6 /* Map */:
+      return serializeMap(ctx, node);
+    case 15 /* BigIntTypedArray */:
+    case 14 /* TypedArray */:
+      return serializeTypedArray(ctx, node);
+    case 12 /* AggregateError */:
+      return serializeAggregateError(ctx, node);
+    case 11 /* Error */:
+      return serializeError(ctx, node);
+    case 13 /* Iterable */:
+      return serializeIterable(ctx, node);
+    case 10 /* Promise */:
+      return serializePromise(ctx, node);
+    default:
+      throw new Error("Unsupported type");
   }
-  static generateSetNode(ctx, id, current) {
-    assert(ctx.features & 512 /* 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()) {
+}
+
+// src/tree/sync.ts
+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];
       if (isIterable(item)) {
-        deferred[deferredSize++] = item;
+        deferred[i] = item;
       } else {
-        nodes[nodeSize++] = this.parse(ctx, item);
+        nodes[i] = parse2(ctx, item);
       }
     }
-    for (let i = 0; i < deferredSize; i++) {
-      nodes[nodeSize + i] = this.parse(ctx, deferred[i]);
+  }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = parse2(ctx, deferred[i]);
     }
-    return {
-      t: 5 /* Set */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      d: void 0,
-      a: nodes,
-      n: void 0
-    };
   }
-  static generateProperties(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] = this.parse(ctx, item);
-        nodesSize++;
-      }
+  return nodes;
+}
+function generateArrayNode2(ctx, id, current) {
+  return {
+    t: 7 /* Array */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: generateNodeList2(ctx, current),
+    n: void 0
+  };
+}
+function generateMapNode2(ctx, id, current) {
+  assert(ctx.features & 32 /* 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] = parse2(ctx, key);
+      valueNodes[nodeSize] = parse2(ctx, value);
+      nodeSize++;
     }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodesSize + i] = deferredKeys[i];
-      valueNodes[nodesSize + i] = this.parse(ctx, deferredValues[i]);
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodeSize + i] = parse2(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = parse2(ctx, deferredValue[i]);
+  }
+  return {
+    t: 6 /* Map */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: { k: keyNodes, v: valueNodes, s: len },
+    a: void 0,
+    n: void 0
+  };
+}
+function generateSetNode2(ctx, id, current) {
+  assert(ctx.features & 512 /* 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++] = parse2(ctx, item);
     }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: size
-    };
   }
-  static generateIterableNode(ctx, id, current) {
-    assert(ctx.features & 1024 /* SymbolIterator */, 'Unsupported type "Iterable"');
-    const options = getIterableOptions(current);
-    return {
-      t: 13 /* Iterable */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      // Parse options first before the items
-      d: options ? this.generateProperties(ctx, options) : void 0,
-      a: this.generateNodeList(ctx, Array.from(current)),
-      n: void 0
-    };
+  for (let i = 0; i < deferredSize; i++) {
+    nodes[nodeSize + i] = parse2(ctx, deferred[i]);
   }
-  static generateObjectNode(ctx, id, current, empty) {
-    if (Symbol.iterator in current) {
-      return this.generateIterableNode(ctx, id, current);
+  return {
+    t: 5 /* Set */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: nodes,
+    n: void 0
+  };
+}
+function generateProperties2(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] = parse2(ctx, item);
+      nodesSize++;
     }
-    return {
-      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      d: this.generateProperties(ctx, current),
-      a: void 0,
-      n: void 0
-    };
   }
-  static generateAggregateErrorNode(ctx, id, current) {
-    const options = getErrorOptions(ctx, current);
-    const optionsNode = options ? this.generateProperties(ctx, options) : void 0;
-    return {
-      t: 12 /* AggregateError */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: current.message,
-      d: optionsNode,
-      a: void 0,
-      n: this.parse(ctx, current.errors)
-    };
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = parse2(ctx, deferredValues[i]);
   }
-  static generateErrorNode(ctx, id, current) {
-    const options = getErrorOptions(ctx, current);
-    const optionsNode = options ? this.generateProperties(ctx, options) : void 0;
-    return {
-      t: 11 /* Error */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: getErrorConstructor(current),
-      m: current.message,
-      d: optionsNode,
-      a: void 0,
-      n: void 0
-    };
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
+}
+function generateIterableNode2(ctx, id, current) {
+  assert(ctx.features & 1024 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  const options = getIterableOptions(current);
+  return {
+    t: 13 /* Iterable */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    // Parse options first before the items
+    d: options ? generateProperties2(ctx, options) : void 0,
+    a: generateNodeList2(ctx, Array.from(current)),
+    n: void 0
+  };
+}
+function generateObjectNode2(ctx, id, current, empty) {
+  if (Symbol.iterator in current) {
+    return generateIterableNode2(ctx, id, current);
   }
-  static parse(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.has(id)) {
-          return createReferenceNode(id);
-        }
-        if (Array.isArray(current)) {
-          return this.generateArrayNode(ctx, 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(ctx, id, current);
-          case BigInt64Array:
-          case BigUint64Array:
-            return createBigIntTypedArrayNode(ctx, id, current);
-          case Map:
-            return this.generateMapNode(ctx, id, current);
-          case Set:
-            return this.generateSetNode(ctx, id, current);
-          case Object:
-            return this.generateObjectNode(ctx, id, current, false);
-          case void 0:
-            return this.generateObjectNode(ctx, id, current, true);
-          case AggregateError:
-            if (ctx.features & 1 /* AggregateError */) {
-              return this.generateAggregateErrorNode(ctx, id, current);
-            }
-            return this.generateErrorNode(ctx, id, current);
-          case Error:
-          case EvalError:
-          case RangeError:
-          case ReferenceError:
-          case SyntaxError:
-          case TypeError:
-          case URIError:
-            return this.generateErrorNode(ctx, id, current);
-          default:
-            break;
-        }
-        if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-          return this.generateAggregateErrorNode(ctx, id, current);
-        }
-        if (current instanceof Error) {
-          return this.generateErrorNode(ctx, id, current);
-        }
-        if (Symbol.iterator in current) {
-          return this.generateIterableNode(ctx, id, current);
-        }
-        throw new Error("Unsupported type");
+  return {
+    t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: generateProperties2(ctx, current),
+    a: void 0,
+    n: void 0
+  };
+}
+function generateAggregateErrorNode2(ctx, id, current) {
+  const options = getErrorOptions(ctx, current);
+  const optionsNode = options ? generateProperties2(ctx, options) : void 0;
+  return {
+    t: 12 /* AggregateError */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: current.message,
+    d: optionsNode,
+    a: void 0,
+    n: parse2(ctx, current.errors)
+  };
+}
+function generateErrorNode2(ctx, id, current) {
+  const options = getErrorOptions(ctx, current);
+  const optionsNode = options ? generateProperties2(ctx, options) : void 0;
+  return {
+    t: 11 /* Error */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: getErrorConstructor(current),
+    m: current.message,
+    d: optionsNode,
+    a: void 0,
+    n: void 0
+  };
+}
+function parse2(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;
       }
-      default:
-        throw new Error("Unsupported type");
+      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.has(id)) {
+        return createReferenceNode(id);
+      }
+      if (Array.isArray(current)) {
+        return generateArrayNode2(ctx, 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(ctx, id, current);
+        case BigInt64Array:
+        case BigUint64Array:
+          return createBigIntTypedArrayNode(ctx, id, current);
+        case Map:
+          return generateMapNode2(ctx, id, current);
+        case Set:
+          return generateSetNode2(ctx, id, current);
+        case Object:
+          return generateObjectNode2(ctx, id, current, false);
+        case void 0:
+          return generateObjectNode2(ctx, id, current, true);
+        case AggregateError:
+          if (ctx.features & 1 /* AggregateError */) {
+            return generateAggregateErrorNode2(ctx, id, current);
+          }
+          return generateErrorNode2(ctx, id, current);
+        case Error:
+        case EvalError:
+        case RangeError:
+        case ReferenceError:
+        case SyntaxError:
+        case TypeError:
+        case URIError:
+          return generateErrorNode2(ctx, id, current);
+        default:
+          break;
+      }
+      if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+        return generateAggregateErrorNode2(ctx, id, current);
+      }
+      if (current instanceof Error) {
+        return generateErrorNode2(ctx, id, current);
+      }
+      if (Symbol.iterator in current) {
+        return generateIterableNode2(ctx, id, current);
+      }
+      throw new Error("Unsupported type");
     }
+    default:
+      throw new Error("Unsupported type");
   }
-};
+}
 function parseSync(ctx, current) {
-  const result = SyncParser.parse(ctx, current);
+  const result = parse2(ctx, current);
   const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
   return [result, createRef(ctx, current, false), isObject];
 }
@@ -1428,14 +1428,14 @@ function serialize(source, options) {
   const ctx = createParserContext(options);
   const [tree, rootID, isObject] = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
-  const result = SerovalSerializer.serialize(serial, tree);
+  const result = serializeTree(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
 async function serializeAsync(source, options) {
   const ctx = createParserContext(options);
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
-  const result = SerovalSerializer.serialize(serial, tree);
+  const result = serializeTree(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
 function deserialize(source) {
@@ -1469,7 +1469,7 @@ function compileJSON(source) {
     features: parsed.f,
     markedRefs: parsed.m
   });
-  const result = SerovalSerializer.serialize(serial, parsed.t);
+  const result = serializeTree(serial, parsed.t);
   return finalize(serial, parsed.r, parsed.i, result);
 }
 function fromJSON(source) {