seroval 0.4.0-alpha.1 → 0.4.0-alpha.10

package/dist/cjs/development/index.cjs

@@ -20,10 +20,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  compileJSON: () => compileJSON,
   default: () => src_default,
   deserialize: () => deserialize,
+  fromJSON: () => fromJSON,
   serialize: () => serialize,
-  serializeAsync: () => serializeAsync
+  serializeAsync: () => serializeAsync,
+  toJSON: () => toJSON,
+  toJSONAsync: () => toJSONAsync
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -33,28 +37,22 @@ function isPrimitive(current) {
     return true;
   }
   const type = typeof current;
-  return type === "number" || type === "string" || type === "bigint";
+  return type === "number" || type === "string";
 }
 function isPromise(obj) {
   return !!obj && (typeof obj === "object" || typeof obj === "function") && "then" in obj && typeof obj.then === "function";
 }
-function constructorCheck(value, constructor) {
-  return value.constructor === constructor;
-}
 function isIterableBuiltin(obj) {
-  return Array.isArray(obj) || constructorCheck(obj, Set) || constructorCheck(obj, Map);
+  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/assert.ts
-function assert(cond, error) {
-  if (!cond) {
-    throw new Error(error);
-  }
-}
-
 // src/compat.ts
 function compareVersion(left, right) {
   let diff = left[0] - right[0];
@@ -68,7 +66,7 @@ function compareVersion(left, right) {
 }
 var VERSION_TABLE = {
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError#browser_compatibility
-  [0 /* AggregateError */]: {
+  [1 /* AggregateError */]: {
     es: [2021, 0, 0],
     chrome: [85, 0, 0],
     edge: [85, 0, 0],
@@ -81,7 +79,7 @@ var VERSION_TABLE = {
     node: [15, 0, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values#browser_compatibility
-  [1 /* ArrayPrototypeValues */]: {
+  [2 /* ArrayPrototypeValues */]: {
     es: [6, 0, 0],
     chrome: [66, 0, 0],
     edge: [14, 0, 0],
@@ -94,7 +92,7 @@ var VERSION_TABLE = {
     node: [10, 9, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions#browser_compatibility
-  [2 /* ArrowFunction */]: {
+  [4 /* ArrowFunction */]: {
     es: [6, 0, 0],
     chrome: [45, 0, 0],
     edge: [12, 0, 0],
@@ -107,7 +105,7 @@ var VERSION_TABLE = {
     node: [4, 0, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#browser_compatibility
-  [3 /* BigInt */]: {
+  [8 /* BigInt */]: {
     es: [2020, 0, 0],
     chrome: [67, 0, 0],
     edge: [79, 0, 0],
@@ -120,7 +118,7 @@ var VERSION_TABLE = {
     node: [10, 4, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#browser_compatibility
-  [4 /* Map */]: {
+  [16 /* Map */]: {
     es: [6, 0, 0],
     chrome: [38, 0, 0],
     edge: [12, 0, 0],
@@ -133,7 +131,7 @@ var VERSION_TABLE = {
     node: [0, 12, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions#browser_compatibility
-  [5 /* MethodShorthand */]: {
+  [32 /* MethodShorthand */]: {
     es: [6, 0, 0],
     chrome: [39, 0, 0],
     edge: [12, 0, 0],
@@ -146,7 +144,7 @@ var VERSION_TABLE = {
     node: [4, 0, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#browser_compatibility
-  [6 /* ObjectAssign */]: {
+  [64 /* ObjectAssign */]: {
     es: [6, 0, 0],
     chrome: [45, 0, 0],
     edge: [12, 0, 0],
@@ -159,7 +157,7 @@ var VERSION_TABLE = {
     node: [4, 0, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#browser_compatibility
-  [7 /* Promise */]: {
+  [128 /* Promise */]: {
     es: [6, 0, 0],
     chrome: [32, 0, 0],
     edge: [12, 0, 0],
@@ -172,7 +170,7 @@ var VERSION_TABLE = {
     node: [0, 12, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#browser_compatibility
-  [8 /* Set */]: {
+  [256 /* Set */]: {
     es: [6, 0, 0],
     chrome: [38, 0, 0],
     edge: [12, 0, 0],
@@ -185,7 +183,7 @@ var VERSION_TABLE = {
     node: [0, 12, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator#browser_compatibility
-  [9 /* SymbolIterator */]: {
+  [512 /* SymbolIterator */]: {
     es: [6, 0, 0],
     chrome: [43, 0, 0],
     edge: [12, 0, 0],
@@ -198,7 +196,7 @@ var VERSION_TABLE = {
     node: [0, 12, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#browser_compatibility
-  [10 /* TypedArray */]: {
+  [1024 /* TypedArray */]: {
     es: [6, 0, 0],
     chrome: [7, 0, 0],
     edge: [12, 0, 0],
@@ -209,21 +207,53 @@ var VERSION_TABLE = {
     samsung: [1, 0, 0],
     deno: [1, 0, 0],
     node: [0, 10, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt64Array#browser_compatibility
+  [2048 /* BigIntTypedArray */]: {
+    es: [2020, 0, 0],
+    chrome: [67, 0, 0],
+    edge: [79, 0, 0],
+    firefox: [68, 0, 0],
+    opera: [54, 6, 0],
+    safari: [15, 1, 0],
+    ios: [15, 2, 0],
+    samsung: [9, 0, 0],
+    deno: [1, 0, 0],
+    node: [10, 4, 0]
   }
 };
-var TARGET_REGEX = /^(es|chrome|edge|safari|firefox|opera|ios|samsung|deno|node)([0-9]+(\.[0-9]+(\.[0-9]+)?)?)$/i;
+var platforms = [
+  "chrome",
+  "deno",
+  "edge",
+  "es",
+  "firefox",
+  "ios",
+  "node",
+  "opera",
+  "safari",
+  "samsung"
+];
+function getPlatform(target) {
+  for (let i = 0, len = platforms.length; i < len; i++) {
+    const platform = target.substring(0, platforms[i].length);
+    if (platform === platforms[i]) {
+      return platform;
+    }
+  }
+  throw new Error(`Invalid target "${target}"`);
+}
 function parseTarget(target) {
-  const result = TARGET_REGEX.exec(target);
-  assert(result, `Invalid target "${target}"`);
-  const [, platform, version] = result;
+  const platform = getPlatform(target);
+  const version = target.substring(platform.length);
   const [major, minor = "0", patch = "0"] = version.split(".");
   return [platform, [Number(major), Number(minor), Number(patch)]];
 }
 function getTargetVersions(targets) {
   if (Array.isArray(targets)) {
     const versions = [];
-    for (const target of targets) {
-      versions.push(parseTarget(target));
+    for (let i = 0, len = targets.length; i < len; i++) {
+      versions.push(parseTarget(targets[i]));
     }
     return versions;
   }
@@ -231,8 +261,8 @@ function getTargetVersions(targets) {
 }
 function parseTargets(targets) {
   const parsed = getTargetVersions(targets);
-  const flags = /* @__PURE__ */ new Set();
-  for (const key in VERSION_TABLE) {
+  let flags = 0;
+  for (const key of Object.keys(VERSION_TABLE)) {
     const base = VERSION_TABLE[key];
     let flag = true;
     for (const [platform, version] of parsed) {
@@ -240,12 +270,93 @@ function parseTargets(targets) {
       flag = flag && !!baseVersion && compareVersion(baseVersion, version) <= 0;
     }
     if (flag) {
-      flags.add(Number(key));
+      flags |= Number(key);
     }
   }
   return flags;
 }
 
+// src/get-identifier.ts
+var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
+var REF_START_CHARS_LEN = REF_START_CHARS.length;
+var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
+var REF_CHARS_LEN = REF_CHARS.length;
+function getIdentifier(index) {
+  let mod = index % REF_START_CHARS_LEN;
+  let ref = REF_START_CHARS[mod];
+  index = (index - mod) / REF_START_CHARS_LEN;
+  while (index > 0) {
+    mod = index % REF_CHARS_LEN;
+    ref += REF_CHARS[mod];
+    index = (index - mod) / REF_CHARS_LEN;
+  }
+  return ref;
+}
+
+// src/context.ts
+var DEFAULT_OPTIONS = {
+  target: "es2023"
+};
+function createParserContext(options = {}) {
+  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+  return {
+    markedRefs: {},
+    refs: /* @__PURE__ */ new Map(),
+    features: parseTargets(result.target)
+  };
+}
+function createSerializationContext(options) {
+  return {
+    stack: [],
+    vars: [],
+    assignments: [],
+    validRefs: [],
+    refSize: 0,
+    features: options.features,
+    markedRefs: options.markedRefs
+  };
+}
+function markRef(ctx, current) {
+  ctx.markedRefs[current] = 1;
+}
+function createValidRef(ctx, index) {
+  const current = ctx.validRefs[index];
+  if (current == null) {
+    const value = ctx.refSize++;
+    ctx.validRefs[index] = value;
+    return value;
+  }
+  return current;
+}
+function getRefParam(ctx, index) {
+  const actualIndex = createValidRef(ctx, index);
+  if (ctx.vars[actualIndex]) {
+    return ctx.vars[actualIndex];
+  }
+  const result = getIdentifier(actualIndex);
+  ctx.vars[actualIndex] = result;
+  return result;
+}
+function createRef(ctx, current, mark) {
+  const ref = ctx.refs.get(current);
+  if (ref != null) {
+    if (mark) {
+      markRef(ctx, ref);
+    }
+    return ref;
+  }
+  const id = ctx.refs.size;
+  ctx.refs.set(current, id);
+  return id;
+}
+
+// src/assert.ts
+function assert(cond, error) {
+  if (!cond) {
+    throw new Error(error);
+  }
+}
+
 // src/quote.ts
 function quote(str) {
   let result = "";
@@ -288,39 +399,448 @@ function quote(str) {
   return `"${result}"`;
 }
 
-// src/get-identifier.ts
-var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
-var REF_START_CHARS_LEN = REF_START_CHARS.length;
-var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
-var REF_CHARS_LEN = REF_CHARS.length;
-function getIdentifier(index) {
-  let mod = index % REF_START_CHARS_LEN;
-  let ref = REF_START_CHARS[mod];
-  index = (index - mod) / REF_START_CHARS_LEN;
-  while (index > 0) {
-    mod = index % REF_CHARS_LEN;
-    ref += REF_CHARS[mod];
-    index = (index - mod) / REF_CHARS_LEN;
+// src/tree/shared.ts
+function getErrorConstructor(error) {
+  if (error instanceof EvalError) {
+    return "EvalError";
   }
-  return ref;
+  if (error instanceof RangeError) {
+    return "RangeError";
+  }
+  if (error instanceof ReferenceError) {
+    return "ReferenceError";
+  }
+  if (error instanceof SyntaxError) {
+    return "SyntaxError";
+  }
+  if (error instanceof TypeError) {
+    return "TypeError";
+  }
+  if (error instanceof URIError) {
+    return "URIError";
+  }
+  return "Error";
+}
+function getErrorOptions(error) {
+  let options;
+  const constructor = getErrorConstructor(error);
+  if (error.name !== constructor) {
+    options = { name: error.name };
+  } else if (error.constructor.name !== constructor) {
+    options = { name: error.constructor.name };
+  }
+  const names = Object.getOwnPropertyNames(error);
+  for (const name of names) {
+    if (name !== "name" && name !== "message") {
+      options = options || {};
+      options[name] = error[name];
+    }
+  }
+  return options;
+}
+function getIterableOptions(obj) {
+  const names = Object.getOwnPropertyNames(obj);
+  if (names.length) {
+    const options = {};
+    for (const name of names) {
+      options[name] = obj[name];
+    }
+    return options;
+  }
+  return void 0;
+}
+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
+      };
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    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 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
+      };
+    }
+    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;
+  }
+  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;
 }
 
-// src/tree.ts
-var DEFAULT_OPTIONS = {
-  target: "es2023"
-};
-function createSerializationContext(options = {}) {
-  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+// 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 {
-    markedRefs: [],
-    stack: [],
-    refs: /* @__PURE__ */ new Map(),
-    vars: [],
-    assignments: [],
-    validRefs: /* @__PURE__ */ new Map(),
-    features: parseTargets(result.target)
+    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]);
+      }
+    }
+  }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = await generateTreeAsync(ctx, deferred[i]);
+    }
+  }
+  return nodes;
+}
+async function generateArrayNode(ctx, current, id) {
+  return {
+    t: 7 /* Array */,
+    i: id,
+    a: await generateNodeList(ctx, current),
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
+}
+async function generateAggregateErrorNode(ctx, current, id) {
+  const options = getErrorOptions(current);
+  const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
+  return {
+    t: 12 /* AggregateError */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: current.message,
+    c: void 0,
+    d: optionsNode,
+    n: await generateTreeAsync(ctx, current.errors)
+  };
+}
+async function generateErrorNode(ctx, current, id) {
+  const options = getErrorOptions(current);
+  const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
+  return {
+    t: 11 /* Error */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: current.message,
+    c: getErrorConstructor(current),
+    d: optionsNode,
+    n: void 0
+  };
+}
+async function generateIterableNode(ctx, current, id) {
+  assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  const options = getIterableOptions(current);
+  return {
+    t: 13 /* Iterable */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    // Parse options first before the items
+    d: options ? await serializePropertiesAsync(ctx, options) : void 0,
+    a: await generateNodeList(ctx, Array.from(current)),
+    n: void 0
   };
 }
+async function generateTreeAsync(ctx, current) {
+  if (isPrimitive(current)) {
+    return {
+      t: 0 /* Primitive */,
+      i: void 0,
+      s: serializePrimitive(current),
+      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"');
+    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
+    };
+  }
+  const id = createRef(ctx, current, true);
+  if (ctx.markedRefs[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
+    };
+  }
+  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);
+    }
+    return {
+      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      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,
+      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"');
+    return current.then(async (value) => ({
+      t: 10 /* Promise */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      // Parse options first before the items
+      d: void 0,
+      a: void 0,
+      n: await generateTreeAsync(ctx, value)
+    }));
+  }
+  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+    return generateAggregateErrorNode(ctx, current, id);
+  }
+  if (current instanceof Error) {
+    return generateErrorNode(ctx, current, id);
+  }
+  throw new Error("Unsupported value");
+}
+async function parseAsync(ctx, current) {
+  const result = await generateTreeAsync(ctx, current);
+  return [result, createRef(ctx, current, false), result.t === 8 /* Object */];
+}
+
+// src/tree/serialize.ts
 function getAssignmentExpression(assignment) {
   switch (assignment.type) {
     case "index":
@@ -386,41 +906,11 @@ function resolveAssignments(assignments) {
 function resolvePatches(ctx) {
   return resolveAssignments(ctx.assignments);
 }
-function markRef(ctx, current) {
-  ctx.markedRefs[current] = true;
-}
-function createRef(ctx, index) {
-  const current = ctx.refs.get(index);
-  if (current != null) {
-    return current;
+function assignRef(ctx, index, value) {
+  if (ctx.markedRefs[index]) {
+    return `${getRefParam(ctx, index)}=${value}`;
   }
-  const id = ctx.refs.size;
-  ctx.refs.set(index, id);
-  return id;
-}
-function createValidRef(ctx, index) {
-  const current = ctx.validRefs.get(index);
-  if (current != null) {
-    return current;
-  }
-  const id = ctx.validRefs.size;
-  ctx.validRefs.set(index, id);
-  return id;
-}
-function getRefParam(ctx, index) {
-  const actualIndex = createValidRef(ctx, index);
-  if (ctx.vars[actualIndex]) {
-    return ctx.vars[actualIndex];
-  }
-  const result = getIdentifier(actualIndex);
-  ctx.vars[actualIndex] = result;
-  return result;
-}
-function assignRef(ctx, index, value) {
-  if (ctx.markedRefs[index]) {
-    return `${getRefParam(ctx, index)}=${value}`;
-  }
-  return value;
+  return value;
 }
 function createAssignment(ctx, source, value) {
   ctx.assignments.push({
@@ -450,699 +940,560 @@ function createArrayAssign(ctx, ref, index, value) {
   markRef(ctx, ref);
   createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
 }
-function createObjectIdentifierAssign(ctx, ref, key, value) {
+function createObjectAssign(ctx, ref, key, value) {
   markRef(ctx, ref);
   createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
 }
-function createObjectComputedAssign(ctx, ref, key, value) {
-  markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${key}]`, value);
-}
-function getErrorConstructor(error) {
-  if (error instanceof EvalError) {
-    return "EvalError";
-  }
-  if (error instanceof RangeError) {
-    return "RangeError";
-  }
-  if (error instanceof ReferenceError) {
-    return "ReferenceError";
-  }
-  if (error instanceof SyntaxError) {
-    return "SyntaxError";
-  }
-  if (error instanceof TypeError) {
-    return "TypeError";
-  }
-  if (error instanceof URIError) {
-    return "URIError";
-  }
-  return "Error";
-}
-function getErrorOptions(error) {
-  let options;
-  const constructor = getErrorConstructor(error);
-  if (error.name !== constructor) {
-    options = { name: error.name };
-  } else if (error.constructor.name !== constructor) {
-    options = { name: error.constructor.name };
-  }
-  const names = Object.getOwnPropertyNames(error);
-  for (const name of names) {
-    if (name !== "name" && name !== "message") {
-      options = options || {};
-      options[name] = error[name];
+var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
+function serializeAssignments(ctx, targetRef, node) {
+  ctx.stack.push(targetRef);
+  const mainAssignments = [];
+  for (let i = 0; i < node.s; i++) {
+    const parentStack = ctx.stack;
+    ctx.stack = [];
+    const refParam = serializeTree(ctx, node.v[i]);
+    ctx.stack = parentStack;
+    const key = node.k[i];
+    const check = Number(key);
+    const parentAssignment = ctx.assignments;
+    ctx.assignments = mainAssignments;
+    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    if (isIdentifier && Number.isNaN(check)) {
+      createObjectAssign(ctx, targetRef, key, refParam);
+    } else {
+      createArrayAssign(ctx, targetRef, isIdentifier ? key : quote(key), refParam);
     }
+    ctx.assignments = parentAssignment;
   }
-  return options;
+  ctx.stack.pop();
+  return resolveAssignments(mainAssignments);
 }
-function getIterableOptions(obj) {
-  const names = Object.getOwnPropertyNames(obj);
-  if (names.length) {
-    const options = {};
-    for (const name of names) {
-      options[name] = obj[name];
+function serializeObject(ctx, sourceID, node) {
+  if (node.s === 0) {
+    return "{}";
+  }
+  let result = "";
+  ctx.stack.push(sourceID);
+  for (let i = 0; i < node.s; i++) {
+    const key = node.k[i];
+    const val = node.v[i];
+    const check = Number(key);
+    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    if (isReferenceInStack(ctx, val)) {
+      const refParam = getRefParam(ctx, val.i);
+      if (isIdentifier && Number.isNaN(check)) {
+        createObjectAssign(ctx, sourceID, key, refParam);
+      } else {
+        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+      }
+    } else {
+      result += `${isIdentifier ? key : quote(key)}:${serializeTree(ctx, val)},`;
     }
-    return options;
   }
-  return void 0;
+  ctx.stack.pop();
+  return `{${result.substring(0, result.length - 1)}}`;
 }
-function isReferenceInStack(ctx, node) {
-  return node[0] === 1 /* Reference */ && ctx.stack.includes(node[1]);
-}
-function generateRef(ctx, current) {
-  const ref = ctx.refs.has(current);
-  if (ref) {
-    const refID = ctx.refs.get(current) || 0;
-    markRef(ctx, refID);
-    return [1 /* Reference */, refID];
+function 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 = serializeTree(ctx, node.n);
+    ctx.stack.pop();
+    serialized = `Promise.resolve(${result})`;
   }
-  const id = ctx.refs.size;
-  ctx.refs.set(current, id);
-  return id;
+  return assignRef(ctx, node.i, serialized);
 }
-function generateSemiPrimitiveValue(ctx, current, id) {
-  if (constructorCheck(current, Date)) {
-    return [2 /* Date */, current, id];
-  }
-  if (constructorCheck(current, RegExp)) {
-    return [3 /* RegExp */, current, id];
-  }
-  if (constructorCheck(current, Int8Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int8Array"');
-    return [13 /* TypedArray */, ["Int8Array", current], id];
-  }
-  if (constructorCheck(current, Int16Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int16Array"');
-    return [13 /* TypedArray */, ["Int16Array", current], id];
-  }
-  if (constructorCheck(current, Int32Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int32Array"');
-    return [13 /* TypedArray */, ["Int32Array", current], id];
-  }
-  if (constructorCheck(current, Uint8Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint8Array"');
-    return [13 /* TypedArray */, ["Uint8Array", current], id];
-  }
-  if (constructorCheck(current, Uint16Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint16Array"');
-    return [13 /* TypedArray */, ["Uint16Array", current], id];
-  }
-  if (constructorCheck(current, Uint32Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint32Array"');
-    return [13 /* TypedArray */, ["Uint32Array", current], id];
-  }
-  if (constructorCheck(current, Uint8ClampedArray)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint8ClampedArray"');
-    return [13 /* TypedArray */, ["Uint8ClampedArray", current], id];
-  }
-  if (constructorCheck(current, Float32Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Float32Array"');
-    return [13 /* TypedArray */, ["Float32Array", current], id];
-  }
-  if (constructorCheck(current, Float64Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Float64Array"');
-    return [13 /* TypedArray */, ["Float64Array", current], id];
-  }
-  if (constructorCheck(current, BigInt64Array)) {
-    assert(
-      ctx.features.has(10 /* TypedArray */) && ctx.features.has(3 /* BigInt */),
-      'Unsupported value type "BigInt64Array"'
-    );
-    return [13 /* TypedArray */, ["BigInt64Array", current], id];
-  }
-  if (constructorCheck(current, BigUint64Array)) {
-    assert(
-      ctx.features.has(10 /* TypedArray */) && ctx.features.has(3 /* BigInt */),
-      'Unsupported value type "BigUint64Array"'
-    );
-    return [13 /* TypedArray */, ["BigUint64Array", current], id];
+function serializeTypedArray(ctx, node) {
+  let args = `[${node.s}]`;
+  if (node.l !== 0) {
+    args += `,${node.l}`;
   }
-  return void 0;
+  return assignRef(ctx, node.i, `new ${node.c}(${args})`);
 }
-function generateTreeSync(ctx, current) {
-  function serializeProperties(properties) {
-    const keyNodes = [];
-    const valueNodes = [];
-    const deferredKeys = [];
-    const deferredValues = [];
-    const keys = Object.keys(properties);
-    let deferredSize = 0;
-    for (const key of keys) {
-      if (isIterable(properties[key])) {
-        deferredKeys.push(key);
-        deferredValues.push(properties[key]);
-        deferredSize++;
+function serializeSet(ctx, node) {
+  let serialized = "new Set";
+  const size = node.a.length;
+  if (size) {
+    let result = "";
+    ctx.stack.push(node.i);
+    for (let i = 0; i < size; i++) {
+      const item = node.a[i];
+      if (isReferenceInStack(ctx, item)) {
+        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
       } else {
-        keyNodes.push(key);
-        valueNodes.push(generateTreeSync(ctx, properties[key]));
+        result += `${serializeTree(ctx, item)},`;
       }
     }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(deferredKeys[i]);
-      valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
+    ctx.stack.pop();
+    if (result) {
+      serialized += `([${result.substring(0, result.length - 1)}])`;
     }
-    return [keyNodes, valueNodes, keys.length];
-  }
-  if (isPrimitive(current)) {
-    return [0 /* Primitive */, current];
   }
-  const id = generateRef(ctx, current);
-  if (Array.isArray(id)) {
-    return id;
-  }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
-  }
-  if (constructorCheck(current, Set)) {
-    assert(ctx.features.has(8 /* Set */), 'Unsupported type "Set"');
-    const nodes = [];
-    const deferred = [];
-    for (const item of current.keys()) {
-      if (isIterable(item)) {
-        deferred.push(item);
+  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);
+    for (let i = 0; i < node.d.s; i++) {
+      const key = node.d.k[i];
+      const val = node.d.v[i];
+      if (isReferenceInStack(ctx, key)) {
+        const keyRef = getRefParam(ctx, key.i);
+        if (isReferenceInStack(ctx, val)) {
+          const valueRef = getRefParam(ctx, val.i);
+          createMapSet(ctx, node.i, keyRef, valueRef);
+        } else {
+          const parent = ctx.stack;
+          ctx.stack = [];
+          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
+          ctx.stack = parent;
+        }
+      } else if (isReferenceInStack(ctx, val)) {
+        const valueRef = getRefParam(ctx, val.i);
+        const parent = ctx.stack;
+        ctx.stack = [];
+        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
+        ctx.stack = parent;
       } else {
-        nodes.push(generateTreeSync(ctx, item));
+        result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
       }
     }
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(generateTreeSync(ctx, deferred[i]));
+    ctx.stack.pop();
+    if (result) {
+      serialized += `([${result.substring(0, result.length - 1)}])`;
     }
-    return [4 /* Set */, nodes, id];
-  }
-  if (constructorCheck(current, Map)) {
-    assert(ctx.features.has(4 /* Map */), 'Unsupported type "Map"');
-    const keyNodes = [];
-    const valueNodes = [];
-    const deferredKey = [];
-    const deferredValue = [];
-    let deferredSize = 0;
-    for (const [key, value] of current.entries()) {
-      if (isIterable(key) || isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
-        deferredSize++;
+  }
+  return assignRef(ctx, node.i, serialized);
+}
+function serializeNodeList(ctx, node) {
+  const size = node.a.length;
+  let values = "";
+  for (let i = 0; i < size; i++) {
+    const item = node.a[i];
+    if (item) {
+      if (isReferenceInStack(ctx, item)) {
+        createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
+        values += ",";
       } else {
-        keyNodes.push(generateTreeSync(ctx, key));
-        valueNodes.push(generateTreeSync(ctx, value));
+        values += serializeTree(ctx, item);
+        if (i < size - 1) {
+          values += ",";
+        }
       }
+    } else {
+      values += ",";
     }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(generateTreeSync(ctx, deferredKey[i]));
-      valueNodes.push(generateTreeSync(ctx, deferredValue[i]));
-    }
-    return [5 /* Map */, [keyNodes, valueNodes, current.size], id];
   }
-  if (Array.isArray(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] = generateTreeSync(ctx, current[i]);
-        }
+  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 serializeWithObjectAssign(ctx, value, id, serialized) {
+  const fields = serializeObject(ctx, id, value);
+  if (fields !== "{}") {
+    return `Object.assign(${serialized},${fields})`;
+  }
+  return serialized;
+}
+function serializeAggregateError(ctx, node) {
+  ctx.stack.push(node.i);
+  let serialized = `new AggregateError(${serializeTree(ctx, node.n)},${quote(node.m)})`;
+  ctx.stack.pop();
+  if (node.d) {
+    if (ctx.features & 64 /* ObjectAssign */) {
+      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
+    } else {
+      markRef(ctx, node.i);
+      const assignments = serializeAssignments(ctx, node.i, node.d);
+      if (assignments) {
+        const ref = getRefParam(ctx, node.i);
+        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
       }
     }
-    for (let i = 0; i < size; i++) {
-      if (i in deferred) {
-        nodes[i] = generateTreeSync(ctx, deferred[i]);
+  }
+  return assignRef(ctx, node.i, serialized);
+}
+function serializeError(ctx, node) {
+  let serialized = `new ${node.c}(${quote(node.m)})`;
+  if (node.d) {
+    if (ctx.features & 64 /* ObjectAssign */) {
+      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
+    } else {
+      markRef(ctx, node.i);
+      const assignments = serializeAssignments(ctx, node.i, node.d);
+      if (assignments) {
+        const ref = getRefParam(ctx, node.i);
+        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
       }
     }
-    return [6 /* Array */, nodes, id];
   }
-  if (current instanceof AggregateError && ctx.features.has(0 /* AggregateError */)) {
-    const options = getErrorOptions(current);
-    const optionsNode = options ? serializeProperties(options) : void 0;
-    const errorsNode = generateTreeSync(ctx, current.errors);
-    return [11 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
+  return assignRef(ctx, node.i, serialized);
+}
+function serializeIterable(ctx, node) {
+  const parent = ctx.stack;
+  ctx.stack = [];
+  const values = serializeNodeList(ctx, node);
+  ctx.stack = parent;
+  let serialized;
+  if (ctx.features & 2 /* ArrayPrototypeValues */) {
+    serialized = `${values}.values()`;
+  } else {
+    serialized = `${values}[Symbol.iterator]()`;
   }
-  if (current instanceof Error) {
-    const options = getErrorOptions(current);
-    const optionsNode = options ? serializeProperties(options) : void 0;
-    return [
-      10 /* Error */,
-      [getErrorConstructor(current), current.message, optionsNode],
-      id
-    ];
-  }
-  if (isIterable(current)) {
-    assert(ctx.features.has(9 /* SymbolIterator */), 'Unsupported type "Iterable"');
-    const options = getIterableOptions(current);
-    return [12 /* Iterable */, [
-      // Parse options first before the items
-      options ? serializeProperties(options) : void 0,
-      generateTreeSync(ctx, Array.from(current))
-    ], id];
-  }
-  const empty = current.constructor == null;
-  if (current.constructor === Object || empty) {
-    return [
-      empty ? 8 /* NullConstructor */ : 7 /* Object */,
-      serializeProperties(current),
-      id
-    ];
+  if (ctx.features & 4 /* ArrowFunction */) {
+    serialized = `{[Symbol.iterator]:()=>${serialized}}`;
+  } else if (ctx.features & 32 /* MethodShorthand */) {
+    serialized = `{[Symbol.iterator](){return ${serialized}}}`;
+  } else {
+    serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
   }
-  throw new Error("Unsupported value");
-}
-async function generateTreeAsync(ctx, current) {
-  async function serializeProperties(properties) {
-    const keyNodes = [];
-    const valueNodes = [];
-    const deferredKeys = [];
-    const deferredValues = [];
-    const keys = Object.keys(properties);
-    let deferredSize = 0;
-    for (const key of keys) {
-      if (isIterable(properties[key])) {
-        deferredKeys.push(key);
-        deferredValues.push(properties[key]);
-        deferredSize++;
-      } else {
-        keyNodes.push(key);
-        valueNodes.push(await generateTreeAsync(ctx, properties[key]));
+  if (node.d) {
+    if (ctx.features & 64 /* ObjectAssign */) {
+      serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
+    } else {
+      markRef(ctx, node.i);
+      const assignments = serializeAssignments(ctx, node.i, node.d);
+      if (assignments) {
+        const ref = getRefParam(ctx, node.i);
+        return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
       }
     }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(deferredKeys[i]);
-      valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
+  }
+  return assignRef(ctx, node.i, serialized);
+}
+function serializeNullConstructor(ctx, node) {
+  let serialized = "Object.create(null)";
+  if (ctx.features & 64 /* ObjectAssign */) {
+    serialized = serializeWithObjectAssign(ctx, node.d, node.i, serialized);
+  } else {
+    markRef(ctx, node.i);
+    const assignments = serializeAssignments(ctx, node.i, node.d);
+    if (assignments) {
+      const ref = getRefParam(ctx, node.i);
+      return `(${assignRef(ctx, node.i, serialized)},${assignments}${ref})`;
     }
-    return [keyNodes, valueNodes, keys.length];
   }
-  if (isPrimitive(current)) {
-    return [0 /* Primitive */, current];
+  return assignRef(ctx, node.i, serialized);
+}
+function serializeTree(ctx, node) {
+  switch (node.t) {
+    case 0 /* Primitive */:
+      return String(node.s);
+    case 2 /* Reference */:
+      return getRefParam(ctx, node.i);
+    case 10 /* Promise */:
+      return serializePromise(ctx, node);
+    case 1 /* BigInt */:
+      return node.s;
+    case 3 /* Date */:
+      return assignRef(ctx, node.i, `new Date("${node.s}")`);
+    case 4 /* RegExp */:
+      return assignRef(ctx, node.i, node.s);
+    case 15 /* BigIntTypedArray */:
+    case 14 /* TypedArray */:
+      return serializeTypedArray(ctx, node);
+    case 5 /* Set */:
+      return serializeSet(ctx, node);
+    case 6 /* Map */:
+      return serializeMap(ctx, node);
+    case 7 /* Array */:
+      return serializeArray(ctx, node);
+    case 12 /* AggregateError */:
+      return serializeAggregateError(ctx, node);
+    case 11 /* Error */:
+      return serializeError(ctx, node);
+    case 13 /* Iterable */:
+      return serializeIterable(ctx, node);
+    case 9 /* NullConstructor */:
+      return serializeNullConstructor(ctx, node);
+    case 8 /* Object */:
+      return assignRef(ctx, node.i, serializeObject(ctx, node.i, node.d));
+    default:
+      throw new Error("Unsupported type");
   }
-  const id = generateRef(ctx, current);
-  if (Array.isArray(id)) {
-    return id;
+}
+
+// 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++;
+    }
   }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
   }
-  if (isPromise(current)) {
-    assert(ctx.features.has(7 /* Promise */), 'Unsupported type "Promise"');
-    return current.then(async (value) => [
-      9 /* Promise */,
-      await generateTreeAsync(ctx, value),
-      id
-    ]);
-  }
-  if (constructorCheck(current, Set)) {
-    assert(ctx.features.has(8 /* Set */), 'Unsupported type "Set"');
-    const nodes = [];
-    const deferred = [];
-    for (const item of current.keys()) {
-      if (isIterable(item)) {
-        deferred.push(item);
-      } else {
-        nodes.push(await generateTreeAsync(ctx, item));
-      }
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
+}
+function generateSetNode2(ctx, current, id) {
+  assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+  const len = current.size;
+  const nodes = new Array(len);
+  const deferred = new Array(len);
+  let deferredSize = 0;
+  let nodeSize = 0;
+  for (const item of current.keys()) {
+    if (isIterable(item)) {
+      deferred[deferredSize++] = item;
+    } else {
+      nodes[nodeSize++] = generateTreeSync(ctx, item);
     }
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(await generateTreeAsync(ctx, deferred[i]));
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
+  }
+  return {
+    t: 5 /* Set */,
+    i: id,
+    a: nodes,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
+}
+function generateMapNode2(ctx, current, id) {
+  assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+  const len = current.size;
+  const keyNodes = new Array(len);
+  const valueNodes = new Array(len);
+  const deferredKey = new Array(len);
+  const deferredValue = new Array(len);
+  let deferredSize = 0;
+  let nodeSize = 0;
+  for (const [key, value] of current.entries()) {
+    if (isIterable(key) || isIterable(value)) {
+      deferredKey[deferredSize] = key;
+      deferredValue[deferredSize] = value;
+      deferredSize++;
+    } else {
+      keyNodes[nodeSize] = generateTreeSync(ctx, key);
+      valueNodes[nodeSize] = generateTreeSync(ctx, value);
+      nodeSize++;
     }
-    return [4 /* Set */, nodes, id];
-  }
-  if (constructorCheck(current, Map)) {
-    assert(ctx.features.has(4 /* Map */), 'Unsupported type "Map"');
-    const keyNodes = [];
-    const valueNodes = [];
-    const deferredKey = [];
-    const deferredValue = [];
-    let deferredSize = 0;
-    for (const [key, value] of current.entries()) {
-      if (isIterable(key) || isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
-        deferredSize++;
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
+  }
+  return {
+    t: 6 /* Map */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: { k: keyNodes, v: valueNodes, s: len },
+    n: void 0
+  };
+}
+function generateNodeList2(ctx, current) {
+  const size = current.length;
+  const nodes = new Array(size);
+  const deferred = new Array(size);
+  for (let i = 0; i < size; i++) {
+    if (i in current) {
+      if (isIterable(current[i])) {
+        deferred[i] = current[i];
       } else {
-        keyNodes.push(await generateTreeAsync(ctx, key));
-        valueNodes.push(await generateTreeAsync(ctx, value));
+        nodes[i] = generateTreeSync(ctx, current[i]);
       }
     }
-    for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(await generateTreeAsync(ctx, deferredKey[i]));
-      valueNodes.push(await generateTreeAsync(ctx, deferredValue[i]));
-    }
-    return [5 /* Map */, [keyNodes, valueNodes, current.size], id];
   }
-  if (Array.isArray(current)) {
-    const size = current.length;
-    const nodes = new Array(size);
-    const deferred = new Array(size);
-    for (let i = 0; i < size; i++) {
-      const item = current[i];
-      if (i in current) {
-        if (isIterable(item)) {
-          deferred[i] = item;
-        } else {
-          nodes[i] = await generateTreeAsync(ctx, item);
-        }
-      }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = generateTreeSync(ctx, deferred[i]);
     }
-    for (let i = 0; i < size; i++) {
-      if (i in deferred) {
-        nodes[i] = await generateTreeAsync(ctx, deferred[i]);
-      }
-    }
-    return [6 /* Array */, nodes, id];
-  }
-  if (current instanceof AggregateError) {
-    const options = getErrorOptions(current);
-    const optionsNode = options ? await serializeProperties(options) : void 0;
-    const errorsNode = await generateTreeAsync(ctx, current.errors);
-    return [11 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
-  }
-  if (current instanceof Error) {
-    const options = getErrorOptions(current);
-    const optionsNode = options ? await serializeProperties(options) : void 0;
-    return [
-      10 /* Error */,
-      [getErrorConstructor(current), current.message, optionsNode],
-      id
-    ];
-  }
-  if (isIterable(current)) {
-    assert(ctx.features.has(9 /* SymbolIterator */), 'Unsupported type "Iterable"');
-    const options = getIterableOptions(current);
-    return [12 /* Iterable */, [
-      options ? await serializeProperties(options) : void 0,
-      await generateTreeAsync(ctx, Array.from(current))
-    ], id];
-  }
-  const empty = current.constructor == null;
-  if (current.constructor === Object || empty) {
-    return [
-      empty ? 8 /* NullConstructor */ : 7 /* Object */,
-      await serializeProperties(current),
-      id
-    ];
   }
-  throw new Error("Unsupported value");
+  return nodes;
 }
-function serializePrimitive(ctx, value) {
-  if (value === true) {
-    return "!0";
+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),
+      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"');
+    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
+    };
+  }
+  const id = createRef(ctx, current, true);
+  if (ctx.markedRefs[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
+    };
   }
-  if (value === false) {
-    return "!1";
+  if (Array.isArray(current)) {
+    return generateArrayNode2(ctx, current, id);
   }
-  if (value === void 0) {
-    return "void 0";
+  const cs = current.constructor;
+  const empty = cs == null;
+  if (cs === Object || empty) {
+    if (Symbol.iterator in current) {
+      return generateIterableNode2(ctx, current, id);
+    }
+    return {
+      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      m: void 0,
+      c: void 0,
+      // Parse options first before the items
+      d: serializePropertiesSync(ctx, current),
+      a: void 0,
+      n: void 0
+    };
   }
-  if (value === null) {
-    return "null";
+  if (cs === Set) {
+    return generateSetNode2(ctx, current, id);
   }
-  if (typeof value === "bigint") {
-    assert(ctx.features.has(3 /* BigInt */), 'Unsupported type "BigInt"');
-    return `${value}n`;
+  if (cs === Map) {
+    return generateMapNode2(ctx, current, id);
   }
-  if (typeof value === "string") {
-    return quote(value);
+  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
+  if (semiPrimitive) {
+    return semiPrimitive;
   }
-  if (Object.is(value, -0)) {
-    return "-0";
+  if (Symbol.iterator in current) {
+    return generateIterableNode2(ctx, current, id);
   }
-  if (Object.is(value, Infinity)) {
-    return "1/0";
+  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+    return generateAggregateErrorNode2(ctx, current, id);
   }
-  if (Object.is(value, -Infinity)) {
-    return "-1/0";
+  if (current instanceof Error) {
+    return generateErrorNode2(ctx, current, id);
   }
-  return String(value);
+  throw new Error("Unsupported value");
 }
-function serializeTree(ctx, [type, value, id]) {
-  function serializeAssignments(targetRef, [keys, values, size]) {
-    ctx.stack.push(targetRef);
-    const mainAssignments = [];
-    for (let i = 0; i < size; i++) {
-      const parentStack = ctx.stack;
-      ctx.stack = [];
-      const refParam = serializeTree(ctx, values[i]);
-      ctx.stack = parentStack;
-      const key = keys[i];
-      const check = Number(key);
-      const parentAssignment = ctx.assignments;
-      ctx.assignments = mainAssignments;
-      if (check >= 0 || Number.isNaN(check) && /^([$A-Z_][0-9A-Z_$]*)$/i.test(key)) {
-        if (!Number.isNaN(check)) {
-          createObjectComputedAssign(ctx, targetRef, key, refParam);
-        } else {
-          createObjectIdentifierAssign(ctx, targetRef, key, refParam);
-        }
-      } else {
-        createObjectComputedAssign(ctx, targetRef, quote(key), refParam);
-      }
-      ctx.assignments = parentAssignment;
-    }
-    ctx.stack.pop();
-    return resolveAssignments(mainAssignments);
-  }
-  function serializeObject(sourceID, [keys, values, size]) {
-    let result = "";
-    ctx.stack.push(sourceID);
-    for (let i = 0; i < size; i++) {
-      const key = keys[i];
-      const val = values[i];
-      const check = Number(key);
-      if (check >= 0 || Number.isNaN(check) && /^([$A-Z_][0-9A-Z_$]*)$/i.test(key)) {
-        if (isReferenceInStack(ctx, val)) {
-          const refParam = getRefParam(ctx, val[1]);
-          if (!Number.isNaN(check)) {
-            createObjectComputedAssign(ctx, sourceID, key, refParam);
-          } else {
-            createObjectIdentifierAssign(ctx, sourceID, key, refParam);
-          }
-        } else {
-          result += `${key}:${serializeTree(ctx, val)},`;
-        }
-      } else if (isReferenceInStack(ctx, val)) {
-        const refParam = getRefParam(ctx, val[1]);
-        createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
-      } else {
-        result += `${quote(key)}:${serializeTree(ctx, val)},`;
-      }
-    }
-    ctx.stack.pop();
-    return `{${result.substring(0, result.length - 1)}}`;
-  }
-  switch (type) {
-    case 0 /* Primitive */:
-      return serializePrimitive(ctx, value);
-    case 1 /* Reference */:
-      return getRefParam(ctx, value);
-    case 9 /* Promise */: {
-      let serialized;
-      if (isReferenceInStack(ctx, value)) {
-        serialized = `Promise.resolve().then(()=>${getRefParam(ctx, value[1])})`;
-      } else {
-        ctx.stack.push(id);
-        const result = serializeTree(ctx, value);
-        ctx.stack.pop();
-        serialized = `Promise.resolve(${result})`;
-      }
-      return assignRef(ctx, id, serialized);
-    }
-    case 2 /* Date */:
-      return assignRef(ctx, id, `new Date("${value.toISOString()}")`);
-    case 3 /* RegExp */:
-      return assignRef(ctx, id, String(value));
-    case 13 /* TypedArray */: {
-      let values = "";
-      for (let i = 0, len = value[1].length; i < len; i++) {
-        values += `${serializePrimitive(ctx, value[1][i])},`;
-      }
-      let args = values ? `[${values.substring(0, values.length - 1)}]` : "[]";
-      if (value[1].byteOffset !== 0) {
-        args += `,${value[1].byteOffset}`;
-      }
-      return assignRef(ctx, id, `new ${value[0]}(${args})`);
-    }
-    case 4 /* Set */: {
-      let serialized = "new Set";
-      const size = value.length;
-      if (size) {
-        let result = "";
-        ctx.stack.push(id);
-        for (let i = 0; i < size; i++) {
-          const item = value[i];
-          if (isReferenceInStack(ctx, item)) {
-            createSetAdd(ctx, id, getRefParam(ctx, item[1]));
-          } else {
-            result += `${serializeTree(ctx, item)},`;
-          }
-        }
-        ctx.stack.pop();
-        if (result) {
-          serialized += `([${result.substring(0, result.length - 1)}])`;
-        }
-      }
-      return assignRef(ctx, id, serialized);
-    }
-    case 5 /* Map */: {
-      let serialized = "new Map";
-      const size = value[2];
-      if (size) {
-        let result = "";
-        ctx.stack.push(id);
-        for (let i = 0; i < size; i++) {
-          const key = value[0][i];
-          const val = value[1][i];
-          if (isReferenceInStack(ctx, key)) {
-            const keyRef = getRefParam(ctx, key[1]);
-            if (isReferenceInStack(ctx, val)) {
-              const valueRef = getRefParam(ctx, val[1]);
-              createMapSet(ctx, id, keyRef, valueRef);
-            } else {
-              const parent = ctx.stack;
-              ctx.stack = [];
-              createMapSet(ctx, id, keyRef, serializeTree(ctx, val));
-              ctx.stack = parent;
-            }
-          } else if (isReferenceInStack(ctx, val)) {
-            const valueRef = getRefParam(ctx, val[1]);
-            const parent = ctx.stack;
-            ctx.stack = [];
-            createMapSet(ctx, id, serializeTree(ctx, key), valueRef);
-            ctx.stack = parent;
-          } else {
-            result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
-          }
-        }
-        ctx.stack.pop();
-        if (result) {
-          serialized += `([${result.substring(0, result.length - 1)}])`;
-        }
-      }
-      return assignRef(ctx, id, serialized);
-    }
-    case 6 /* Array */: {
-      const size = value.length;
-      let values = "";
-      ctx.stack.push(id);
-      for (let i = 0; i < size; i++) {
-        const item = value[i];
-        if (i in value) {
-          if (isReferenceInStack(ctx, item)) {
-            createArrayAssign(ctx, id, i, getRefParam(ctx, item[1]));
-            values += ",";
-          } else {
-            values += serializeTree(ctx, item);
-            if (i < size - 1) {
-              values += ",";
-            }
-          }
-        } else {
-          values += ",";
-        }
-      }
-      ctx.stack.pop();
-      return assignRef(ctx, id, `[${values}]`);
-    }
-    case 11 /* AggregateError */: {
-      ctx.stack.push(id);
-      let serialized = `new AggregateError(${serializeTree(ctx, value[2])},${quote(value[0])})`;
-      ctx.stack.pop();
-      if (value[1]) {
-        if (ctx.features.has(6 /* ObjectAssign */)) {
-          const options = serializeObject(id, value[1]);
-          serialized = `Object.assign(${serialized},${options})`;
-        } else {
-          markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[1]);
-          if (assignments) {
-            const ref = getRefParam(ctx, id);
-            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-          }
-        }
-      }
-      return assignRef(ctx, id, serialized);
-    }
-    case 10 /* Error */: {
-      let serialized = `new ${value[0]}(${quote(value[1])})`;
-      if (value[2]) {
-        if (ctx.features.has(6 /* ObjectAssign */)) {
-          const options = serializeObject(id, value[2]);
-          serialized = `Object.assign(${serialized},${options})`;
-        } else {
-          markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[2]);
-          if (assignments) {
-            const ref = getRefParam(ctx, id);
-            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-          }
-        }
-      }
-      return assignRef(ctx, id, serialized);
-    }
-    case 12 /* Iterable */: {
-      const parent = ctx.stack;
-      ctx.stack = [];
-      const values = serializeTree(ctx, value[1]);
-      ctx.stack = parent;
-      let serialized;
-      if (ctx.features.has(1 /* ArrayPrototypeValues */)) {
-        serialized = `${values}.values()`;
-      } else {
-        serialized = `${values}[Symbol.iterator]()`;
-      }
-      if (ctx.features.has(2 /* ArrowFunction */)) {
-        serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-      } else if (ctx.features.has(5 /* MethodShorthand */)) {
-        serialized = `{[Symbol.iterator](){return ${serialized}}}`;
-      } else {
-        serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
-      }
-      if (value[0]) {
-        if (ctx.features.has(6 /* ObjectAssign */)) {
-          const options = serializeObject(id, value[0]);
-          serialized = `Object.assign(${serialized},${options})`;
-        } else {
-          markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[0]);
-          if (assignments) {
-            const ref = getRefParam(ctx, id);
-            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-          }
-        }
-      }
-      return assignRef(ctx, id, serialized);
-    }
-    case 8 /* NullConstructor */: {
-      let serialized = "Object.create(null)";
-      if (ctx.features.has(6 /* ObjectAssign */)) {
-        const fields = serializeObject(id, value);
-        if (fields !== "{}") {
-          serialized = `Object.assign(${serialized},${fields})`;
-        }
-      } else {
-        markRef(ctx, id);
-        const assignments = serializeAssignments(id, value);
-        if (assignments) {
-          const ref = getRefParam(ctx, id);
-          return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-        }
-      }
-      return assignRef(ctx, id, serialized);
-    }
-    case 7 /* Object */:
-      return assignRef(ctx, id, serializeObject(id, value));
-    default:
-      throw new Error("Unsupported type");
-  }
+function parseSync(ctx, current) {
+  const result = generateTreeSync(ctx, current);
+  return [result, createRef(ctx, current, false), result.t === 8 /* Object */];
 }
 
 // src/index.ts
-function finalize(ctx, source, result) {
+function finalize(ctx, rootID, isObject, result) {
   if (ctx.vars.length) {
     const patches = resolvePatches(ctx);
     let body = result;
     if (patches) {
-      const index = getRefParam(ctx, createRef(ctx, source));
+      const index = getRefParam(ctx, rootID);
       if (result.startsWith(`${index}=`)) {
         body = `${result},${patches}${index}`;
       } else {
@@ -1150,37 +1501,73 @@ function finalize(ctx, source, result) {
       }
     }
     let params = ctx.vars.length > 1 ? ctx.vars.join(",") : ctx.vars[0];
-    if (ctx.features.has(2 /* ArrowFunction */)) {
+    if (ctx.features & 4 /* ArrowFunction */) {
       params = ctx.vars.length > 1 || ctx.vars.length === 0 ? `(${params})` : params;
       return `(${params}=>(${body}))()`;
     }
     return `(function(${params}){return ${body}})()`;
   }
-  if (source.constructor === Object) {
+  if (isObject) {
     return `(${result})`;
   }
   return result;
 }
 function serialize(source, options) {
-  const ctx = createSerializationContext(options);
+  const ctx = createParserContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(ctx, source);
+    return String(serializePrimitive(source));
   }
-  const tree = generateTreeSync(ctx, source);
-  const result = serializeTree(ctx, tree);
-  return finalize(ctx, source, result);
+  const [tree, rootID, isObject] = parseSync(ctx, source);
+  const serial = createSerializationContext(ctx);
+  const result = serializeTree(serial, tree);
+  return finalize(serial, rootID, isObject, result);
 }
 async function serializeAsync(source, options) {
-  const ctx = createSerializationContext(options);
+  const ctx = createParserContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(ctx, source);
+    return String(serializePrimitive(source));
   }
-  const tree = await generateTreeAsync(ctx, source);
-  const result = serializeTree(ctx, tree);
-  return finalize(ctx, source, result);
+  const [tree, rootID, isObject] = await parseAsync(ctx, source);
+  const serial = createSerializationContext(ctx);
+  const result = serializeTree(serial, tree);
+  return finalize(serial, rootID, isObject, result);
 }
 function deserialize(source) {
   return (0, eval)(source);
 }
+function toJSON(source, options) {
+  const ctx = createParserContext(options);
+  const [tree, root, isObject] = parseSync(ctx, source);
+  return JSON.stringify([
+    tree,
+    root,
+    isObject,
+    ctx.features,
+    ctx.markedRefs
+  ]);
+}
+async function toJSONAsync(source, options) {
+  const ctx = createParserContext(options);
+  const [tree, root, isObject] = await parseAsync(ctx, source);
+  return JSON.stringify([
+    tree,
+    root,
+    isObject,
+    ctx.features,
+    ctx.markedRefs
+  ]);
+}
+function compileJSON(source) {
+  const parsed = JSON.parse(source);
+  const serial = createSerializationContext({
+    features: parsed[3],
+    markedRefs: parsed[4]
+  });
+  const result = serializeTree(serial, parsed[0]);
+  return finalize(serial, parsed[1], parsed[2], result);
+}
+function fromJSON(source) {
+  return deserialize(compileJSON(source));
+}
 var src_default = serialize;
 //# sourceMappingURL=index.cjs.map