seroval 0.4.0-alpha.8 → 0.4.0

package/dist/esm/development/index.mjs

@@ -1,234 +1,21 @@
-// src/checks.ts
-function isPrimitive(current) {
-  if (!current || current === true) {
-    return true;
-  }
-  const type = typeof current;
-  return type === "number" || type === "string";
-}
-function isPromise(obj) {
-  return !!obj && (typeof obj === "object" || typeof obj === "function") && "then" in obj && typeof obj.then === "function";
-}
-function constructorCheck(value, constructor) {
-  return value.constructor === constructor;
-}
-function isIterableBuiltin(obj) {
-  return Array.isArray(obj) || constructorCheck(obj, Set) || constructorCheck(obj, Map);
-}
-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];
-  if (diff === 0) {
-    diff = left[1] - right[1];
-  }
-  if (diff === 0) {
-    diff = left[2] - right[2];
-  }
-  return diff;
-}
-var VERSION_TABLE = {
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError#browser_compatibility
-  [1 /* AggregateError */]: {
-    es: [2021, 0, 0],
-    chrome: [85, 0, 0],
-    edge: [85, 0, 0],
-    firefox: [79, 0, 0],
-    opera: [71, 0, 0],
-    safari: [14, 0, 0],
-    ios: [14, 0, 0],
-    samsung: [14, 0, 0],
-    deno: [1, 2, 0],
-    node: [15, 0, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values#browser_compatibility
-  [2 /* ArrayPrototypeValues */]: {
-    es: [6, 0, 0],
-    chrome: [66, 0, 0],
-    edge: [14, 0, 0],
-    firefox: [60, 0, 0],
-    opera: [53, 0, 0],
-    safari: [9, 0, 0],
-    ios: [9, 0, 0],
-    samsung: [9, 0, 0],
-    deno: [1, 0, 0],
-    node: [10, 9, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions#browser_compatibility
-  [4 /* ArrowFunction */]: {
-    es: [6, 0, 0],
-    chrome: [45, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [24, 0, 0],
-    opera: [32, 0, 0],
-    safari: [10, 0, 0],
-    ios: [10, 0, 0],
-    samsung: [5, 0, 0],
-    deno: [1, 0, 0],
-    node: [4, 0, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#browser_compatibility
-  [8 /* BigInt */]: {
-    es: [2020, 0, 0],
-    chrome: [67, 0, 0],
-    edge: [79, 0, 0],
-    firefox: [68, 0, 0],
-    opera: [54, 0, 0],
-    safari: [14, 0, 0],
-    ios: [14, 0, 0],
-    samsung: [9, 0, 0],
-    deno: [1, 0, 0],
-    node: [10, 4, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#browser_compatibility
-  [16 /* Map */]: {
-    es: [6, 0, 0],
-    chrome: [38, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [13, 0, 0],
-    opera: [25, 0, 0],
-    safari: [8, 0, 0],
-    ios: [8, 0, 0],
-    samsung: [3, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 12, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions#browser_compatibility
-  [32 /* MethodShorthand */]: {
-    es: [6, 0, 0],
-    chrome: [39, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [34, 0, 0],
-    opera: [26, 0, 0],
-    safari: [9, 0, 0],
-    ios: [9, 0, 0],
-    samsung: [4, 0, 0],
-    deno: [1, 0, 0],
-    node: [4, 0, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#browser_compatibility
-  [64 /* ObjectAssign */]: {
-    es: [6, 0, 0],
-    chrome: [45, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [34, 0, 0],
-    opera: [32, 0, 0],
-    safari: [9, 0, 0],
-    ios: [9, 0, 0],
-    samsung: [5, 0, 0],
-    deno: [1, 0, 0],
-    node: [4, 0, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#browser_compatibility
-  [128 /* Promise */]: {
-    es: [6, 0, 0],
-    chrome: [32, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [29, 0, 0],
-    opera: [19, 0, 0],
-    safari: [8, 0, 0],
-    ios: [8, 0, 0],
-    samsung: [2, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 12, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#browser_compatibility
-  [256 /* Set */]: {
-    es: [6, 0, 0],
-    chrome: [38, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [13, 0, 0],
-    opera: [25, 0, 0],
-    safari: [8, 0, 0],
-    ios: [8, 0, 0],
-    samsung: [3, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 12, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator#browser_compatibility
-  [512 /* SymbolIterator */]: {
-    es: [6, 0, 0],
-    chrome: [43, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [36, 0, 0],
-    opera: [30, 0, 0],
-    safari: [10, 0, 0],
-    ios: [10, 0, 0],
-    samsung: [4, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 12, 0]
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#browser_compatibility
-  [1024 /* TypedArray */]: {
-    es: [6, 0, 0],
-    chrome: [7, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [4, 0, 0],
-    opera: [11, 6, 0],
-    safari: [5, 1, 0],
-    ios: [4, 2, 0],
-    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;
-function parseTarget(target) {
-  const result = TARGET_REGEX.exec(target);
-  assert(result, `Invalid target "${target}"`);
-  const [, platform, version] = result;
-  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));
-    }
-    return versions;
-  }
-  return [parseTarget(targets)];
-}
-function parseTargets(targets) {
-  const parsed = getTargetVersions(targets);
-  let flags = 0;
-  for (const key in VERSION_TABLE) {
-    const base = VERSION_TABLE[key];
-    let flag = true;
-    for (const [platform, version] of parsed) {
-      const baseVersion = base[platform];
-      flag = flag && !!baseVersion && compareVersion(baseVersion, version) <= 0;
-    }
-    if (flag) {
-      flags |= Number(key);
-    }
-  }
-  return flags;
-}
+var Feature = /* @__PURE__ */ ((Feature2) => {
+  Feature2[Feature2["AggregateError"] = 1] = "AggregateError";
+  Feature2[Feature2["ArrayPrototypeValues"] = 2] = "ArrayPrototypeValues";
+  Feature2[Feature2["ArrowFunction"] = 4] = "ArrowFunction";
+  Feature2[Feature2["BigInt"] = 8] = "BigInt";
+  Feature2[Feature2["ErrorPrototypeStack"] = 16] = "ErrorPrototypeStack";
+  Feature2[Feature2["Map"] = 32] = "Map";
+  Feature2[Feature2["MethodShorthand"] = 64] = "MethodShorthand";
+  Feature2[Feature2["ObjectAssign"] = 128] = "ObjectAssign";
+  Feature2[Feature2["Promise"] = 256] = "Promise";
+  Feature2[Feature2["Set"] = 512] = "Set";
+  Feature2[Feature2["SymbolIterator"] = 1024] = "SymbolIterator";
+  Feature2[Feature2["TypedArray"] = 2048] = "TypedArray";
+  Feature2[Feature2["BigIntTypedArray"] = 4096] = "BigIntTypedArray";
+  return Feature2;
+})(Feature || {});
+var ALL_ENABLED = 8191;
 
 // src/get-identifier.ts
 var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
@@ -249,14 +36,14 @@ function getIdentifier(index) {
 
 // src/context.ts
 var DEFAULT_OPTIONS = {
-  target: "es2023"
+  disabledFeatures: 0
 };
 function createParserContext(options = {}) {
   const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    markedRefs: {},
+    markedRefs: /* @__PURE__ */ new Set(),
     refs: /* @__PURE__ */ new Map(),
-    features: parseTargets(result.target)
+    features: ALL_ENABLED ^ result.disabledFeatures
   };
 }
 function createSerializationContext(options) {
@@ -267,11 +54,11 @@ function createSerializationContext(options) {
     validRefs: [],
     refSize: 0,
     features: options.features,
-    markedRefs: options.markedRefs
+    markedRefs: new Set(options.markedRefs)
   };
 }
 function markRef(ctx, current) {
-  ctx.markedRefs[current] = 1;
+  ctx.markedRefs.add(current);
 }
 function createValidRef(ctx, index) {
   const current = ctx.validRefs[index];
@@ -291,16 +78,26 @@ function getRefParam(ctx, index) {
   ctx.vars[actualIndex] = result;
   return result;
 }
-function createRef(ctx, index) {
-  const current = ctx.refs.get(index);
-  if (current != null) {
-    return current;
+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(index, id);
+  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 = "";
@@ -340,7 +137,123 @@ function quote(str) {
   } else {
     result += str.slice(lastPos);
   }
-  return `"${result}"`;
+  return '"' + result + '"';
+}
+
+// src/tree/primitives.ts
+function createPrimitiveNode(value) {
+  return {
+    t: 0 /* Primitive */,
+    i: void 0,
+    s: value,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+var TRUE_NODE = createPrimitiveNode("!0");
+var FALSE_NODE = createPrimitiveNode("!1");
+var UNDEFINED_NODE = createPrimitiveNode("void 0");
+var NULL_NODE = createPrimitiveNode(null);
+var NEG_ZERO_NODE = createPrimitiveNode("-0");
+var INFINITY_NODE = createPrimitiveNode("1/0");
+var NEG_INFINITY_NODE = createPrimitiveNode("-1/0");
+function createBigIntNode(ctx, current) {
+  assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+  return {
+    t: 1 /* BigInt */,
+    i: void 0,
+    s: current.toString() + "n",
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+function createReferenceNode(id) {
+  return {
+    t: 2 /* Reference */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+function createDateNode(id, current) {
+  return {
+    t: 3 /* Date */,
+    i: id,
+    s: current.toISOString(),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    n: void 0,
+    a: void 0
+  };
+}
+function createRegExpNode(id, current) {
+  return {
+    t: 4 /* RegExp */,
+    i: id,
+    s: String(current),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+function createTypedArrayNode(ctx, id, current) {
+  const constructor = current.constructor.name;
+  assert(ctx.features & 2048 /* TypedArray */, `Unsupported value type "${constructor}"`);
+  return {
+    t: 14 /* TypedArray */,
+    i: id,
+    s: current.toString(),
+    l: current.byteOffset,
+    c: constructor,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+var BIGINT_FLAG = 4096 /* BigIntTypedArray */ | 8 /* BigInt */;
+function createBigIntTypedArrayNode(ctx, id, current) {
+  const constructor = current.constructor.name;
+  assert(
+    (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
+    `Unsupported value type "${constructor}"`
+  );
+  let result = "";
+  for (let i = 0, len = current.length; i < len; i++) {
+    if (i !== 0) {
+      result += ",";
+    }
+    result += current[i].toString() + "n";
+  }
+  return {
+    t: 15 /* BigIntTypedArray */,
+    i: id,
+    s: result,
+    l: current.byteOffset,
+    c: constructor,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
 }
 
 // src/tree/shared.ts
@@ -365,7 +278,7 @@ function getErrorConstructor(error) {
   }
   return "Error";
 }
-function getErrorOptions(error) {
+function getErrorOptions(ctx, error) {
   let options;
   const constructor = getErrorConstructor(error);
   if (error.name !== constructor) {
@@ -376,8 +289,15 @@ function getErrorOptions(error) {
   const names = Object.getOwnPropertyNames(error);
   for (const name of names) {
     if (name !== "name" && name !== "message") {
-      options = options || {};
-      options[name] = error[name];
+      if (name === "stack") {
+        if (ctx.features & 16 /* ErrorPrototypeStack */) {
+          options = options || {};
+          options[name] = error[name];
+        }
+      } else {
+        options = options || {};
+        options[name] = error[name];
+      }
     }
   }
   return options;
@@ -393,113 +313,108 @@ function getIterableOptions(obj) {
   }
   return void 0;
 }
-function isReferenceInStack(ctx, node) {
-  return node[0] === 2 /* 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 [2 /* Reference */, refID];
+function isIterable(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  switch (value.constructor) {
+    case Map:
+    case Set:
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+    case BigInt64Array:
+    case BigUint64Array:
+      return false;
+    default:
+      break;
   }
-  const id = ctx.refs.size;
-  ctx.refs.set(current, id);
-  return id;
+  return Symbol.iterator in value;
 }
-function generateSemiPrimitiveValue(ctx, current, id) {
-  if (typeof current === "bigint") {
-    assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
-    return [1 /* BigInt */, `${current}n`];
-  }
-  if (constructorCheck(current, Date)) {
-    return [3 /* Date */, current.toISOString(), id];
-  }
-  if (constructorCheck(current, RegExp)) {
-    return [4 /* RegExp */, String(current), id];
-  }
-  if (constructorCheck(current, Int8Array) || constructorCheck(current, Int16Array) || constructorCheck(current, Int32Array) || constructorCheck(current, Uint8Array) || constructorCheck(current, Uint16Array) || constructorCheck(current, Uint32Array) || constructorCheck(current, Uint8ClampedArray) || constructorCheck(current, Float32Array) || constructorCheck(current, Float64Array)) {
-    const constructor = current.constructor.name;
-    assert(ctx.features & 1024 /* TypedArray */, `Unsupported value type "${constructor}"`);
-    return [14 /* TypedArray */, [constructor, current.toString(), current.byteOffset], id];
+
+// src/tree/async.ts
+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[i] = item;
+      } else {
+        nodes[i] = await parse(ctx, item);
+      }
+    }
   }
-  if (constructorCheck(current, BigInt64Array) || constructorCheck(current, BigUint64Array)) {
-    const constructor = current.constructor.name;
-    assert(
-      ctx.features & 2048 /* BigIntTypedArray */,
-      `Unsupported value type "${constructor}"`
-    );
-    let result = "";
-    const cap = current.length - 1;
-    for (let i = 0; i < cap; i++) {
-      result += `${current[i]}n,`;
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = await parse(ctx, deferred[i]);
     }
-    result += `"${current[cap]}"`;
-    return [
-      15 /* BigIntTypedArray */,
-      [constructor, result, current.byteOffset],
-      id
-    ];
   }
-  return void 0;
+  return nodes;
 }
-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;
+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
+  };
 }
-
-// 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);
+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 nodesSize = 0;
-  for (const key of keys) {
-    if (isIterable(properties[key])) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key];
+  let nodeSize = 0;
+  for (const [key, value] of current.entries()) {
+    if (isIterable(key) || isIterable(value)) {
+      deferredKey[deferredSize] = key;
+      deferredValue[deferredSize] = value;
       deferredSize++;
     } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key]);
-      nodesSize++;
+      keyNodes[nodeSize] = await parse(ctx, key);
+      valueNodes[nodeSize] = await parse(ctx, value);
+      nodeSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodesSize + i] = deferredKeys[i];
-    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
+    keyNodes[nodeSize + i] = await parse(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = await parse(ctx, deferredValue[i]);
   }
-  return [keyNodes, valueNodes, size];
+  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, current, id) {
-  assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+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);
@@ -509,153 +424,266 @@ async function generateSetNode(ctx, current, id) {
     if (isIterable(item)) {
       deferred[deferredSize++] = item;
     } else {
-      nodes[nodeSize++] = await generateTreeAsync(ctx, item);
+      nodes[nodeSize++] = await parse(ctx, item);
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
+    nodes[nodeSize + i] = await parse(ctx, deferred[i]);
   }
-  return [5 /* Set */, nodes, id];
+  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 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);
+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 nodeSize = 0;
-  for (const [key, value] of current.entries()) {
-    if (isIterable(key) || isIterable(value)) {
-      deferredKey[deferredSize] = key;
-      deferredValue[deferredSize] = value;
+  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[nodeSize] = await generateTreeAsync(ctx, key);
-      valueNodes[nodeSize] = await generateTreeAsync(ctx, value);
-      nodeSize++;
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = await parse(ctx, item);
+      nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
-    valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
-  }
-  return [6 /* Map */, [keyNodes, valueNodes, len], id];
-}
-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]);
-    }
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await parse(ctx, deferredValues[i]);
   }
-  return nodes;
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
 }
-async function generateArrayNode(ctx, current, id) {
-  return [7 /* Array */, await generateNodeList(ctx, current), id];
-}
-async function generateAggregateErrorNode(ctx, current, id) {
-  const options = getErrorOptions(current);
-  const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
-  const errorsNode = await generateTreeAsync(ctx, current.errors);
-  return [
-    12 /* AggregateError */,
-    [current.message, optionsNode, errorsNode],
-    id
-  ];
-}
-async function generateErrorNode(ctx, current, id) {
-  const options = getErrorOptions(current);
-  const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
-  return [
-    11 /* Error */,
-    [getErrorConstructor(current), current.message, optionsNode],
-    id
-  ];
-}
-async function generateIterableNode(ctx, current, id) {
-  assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+async function generateIterableNode(ctx, id, current) {
+  assert(ctx.features & 1024 /* SymbolIterator */, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
-  return [13 /* Iterable */, [
+  return {
+    t: 13 /* Iterable */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
     // Parse options first before the items
-    options ? await serializePropertiesAsync(ctx, options) : void 0,
-    await generateNodeList(ctx, Array.from(current))
-  ], id];
+    d: options ? await generateProperties(ctx, options) : void 0,
+    a: await generateNodeList(ctx, Array.from(current)),
+    n: void 0
+  };
 }
-async function generateTreeAsync(ctx, current) {
-  if (isPrimitive(current)) {
-    return [0 /* Primitive */, serializePrimitive(current)];
-  }
-  const id = generateRef(ctx, current);
-  if (Array.isArray(id)) {
-    return id;
-  }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
-  }
-  if (isPromise(current)) {
-    assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
-    return current.then(async (value) => [
-      10 /* Promise */,
-      await generateTreeAsync(ctx, value),
-      id
-    ]);
-  }
-  if (constructorCheck(current, Set)) {
-    return generateSetNode(ctx, current, id);
-  }
-  if (constructorCheck(current, Map)) {
-    return generateMapNode(ctx, current, id);
-  }
-  if (Array.isArray(current)) {
-    return generateArrayNode(ctx, current, id);
-  }
-  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-    return generateAggregateErrorNode(ctx, current, id);
-  }
-  if (current instanceof Error) {
-    return generateErrorNode(ctx, current, id);
+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);
   }
-  if (isIterable(current)) {
-    return generateIterableNode(ctx, current, id);
+  if ("then" in current && typeof current.then === "function") {
+    return generatePromiseNode(ctx, id, current);
   }
-  const empty = current.constructor == null;
-  if (current.constructor === Object || empty) {
-    return [
-      empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      await serializePropertiesAsync(ctx, current),
-      id
-    ];
+  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;
+      }
+      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");
   }
-  throw new Error("Unsupported value");
 }
 async function parseAsync(ctx, current) {
-  const result = await generateTreeAsync(ctx, current);
-  return [result, createRef(ctx, current), result[0] === 8 /* Object */];
+  const result = await parse(ctx, current);
+  const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
+  return [result, createRef(ctx, current, false), isObject];
 }
 
 // src/tree/serialize.ts
 function getAssignmentExpression(assignment) {
-  switch (assignment.type) {
+  switch (assignment.t) {
     case "index":
-      return `${assignment.source}=${assignment.value}`;
+      return assignment.s + "=" + assignment.v;
     case "map":
-      return `${assignment.source}.set(${assignment.key},${assignment.value})`;
+      return assignment.s + ".set(" + assignment.k + "," + assignment.v + ")";
     case "set":
-      return `${assignment.source}.add(${assignment.value})`;
+      return assignment.s + ".add(" + assignment.v + ")";
     default:
       return "";
   }
@@ -664,27 +692,30 @@ function mergeAssignments(assignments) {
   const newAssignments = [];
   let current = assignments[0];
   let prev = current;
+  let item;
   for (let i = 1, len = assignments.length; i < len; i++) {
-    const item = assignments[i];
-    if (item.type === prev.type) {
-      if (item.type === "index" && item.value === prev.value) {
+    item = assignments[i];
+    if (item.t === prev.t) {
+      if (item.t === "index" && item.v === prev.v) {
         current = {
-          type: "index",
-          source: item.source,
-          value: getAssignmentExpression(current)
+          t: "index",
+          s: item.s,
+          k: void 0,
+          v: getAssignmentExpression(current)
         };
-      } else if (item.type === "map" && item.source === prev.source) {
+      } else if (item.t === "map" && item.s === prev.s) {
         current = {
-          type: "map",
-          source: getAssignmentExpression(current),
-          key: item.key,
-          value: item.value
+          t: "map",
+          s: getAssignmentExpression(current),
+          k: item.k,
+          v: item.v
         };
-      } else if (item.type === "set" && item.source === prev.source) {
+      } else if (item.t === "set" && item.s === prev.s) {
         current = {
-          type: "set",
-          source: getAssignmentExpression(current),
-          value: item.value
+          t: "set",
+          s: getAssignmentExpression(current),
+          k: void 0,
+          v: item.v
         };
       } else {
         newAssignments.push(current);
@@ -704,7 +735,7 @@ function resolveAssignments(assignments) {
     let result = "";
     const merged = mergeAssignments(assignments);
     for (let i = 0, len = merged.length; i < len; i++) {
-      result += `${getAssignmentExpression(merged[i])},`;
+      result += getAssignmentExpression(merged[i]) + ",";
     }
     return result;
   }
@@ -713,350 +744,412 @@ function resolveAssignments(assignments) {
 function resolvePatches(ctx) {
   return resolveAssignments(ctx.assignments);
 }
-function assignRef(ctx, index, value) {
-  if (ctx.markedRefs[index]) {
-    return `${getRefParam(ctx, index)}=${value}`;
-  }
-  return value;
-}
 function createAssignment(ctx, source, value) {
   ctx.assignments.push({
-    type: "index",
-    source,
-    value
+    t: "index",
+    s: source,
+    k: void 0,
+    v: value
   });
 }
 function createSetAdd(ctx, ref, value) {
   markRef(ctx, ref);
   ctx.assignments.push({
-    type: "set",
-    source: getRefParam(ctx, ref),
-    value
+    t: "set",
+    s: getRefParam(ctx, ref),
+    k: void 0,
+    v: value
   });
 }
 function createMapSet(ctx, ref, key, value) {
   markRef(ctx, ref);
   ctx.assignments.push({
-    type: "map",
-    source: getRefParam(ctx, ref),
-    key,
-    value
+    t: "map",
+    s: getRefParam(ctx, ref),
+    k: key,
+    v: value
   });
 }
 function createArrayAssign(ctx, ref, index, value) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
+  createAssignment(ctx, getRefParam(ctx, ref) + "[" + index.toString() + "]", value);
 }
 function createObjectAssign(ctx, ref, key, value) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
+  createAssignment(ctx, getRefParam(ctx, ref) + "." + key, value);
+}
+function assignRef(ctx, index, value) {
+  if (ctx.markedRefs.has(index)) {
+    return getRefParam(ctx, index) + "=" + value;
+  }
+  return value;
+}
+function isReferenceInStack(ctx, node) {
+  return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
 }
 var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
-function serializeAssignments(ctx, targetRef, [keys, values, size]) {
-  ctx.stack.push(targetRef);
-  const mainAssignments = [];
+function serializeNodeList(ctx, node) {
+  const size = node.a.length;
+  let values = "";
+  let item;
+  let isHoley = false;
   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;
-    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-    if (isIdentifier && Number.isNaN(check)) {
-      createObjectAssign(ctx, targetRef, key, refParam);
+    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 += serializeTree(ctx, item);
+        isHoley = false;
+      }
     } else {
-      createArrayAssign(ctx, targetRef, isIdentifier ? key : quote(key), refParam);
+      isHoley = true;
     }
-    ctx.assignments = parentAssignment;
   }
+  if (isHoley) {
+    values += ",";
+  }
+  return "[" + values + "]";
+}
+function serializeArray(ctx, node) {
+  ctx.stack.push(node.i);
+  const result = serializeNodeList(ctx, node);
   ctx.stack.pop();
-  return resolveAssignments(mainAssignments);
+  return assignRef(ctx, node.i, result);
 }
-function serializeObject(ctx, sourceID, [keys, values, size]) {
-  if (size === 0) {
+function serializeObject(ctx, sourceID, node) {
+  if (node.s === 0) {
     return "{}";
   }
   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);
-    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+  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)) {
-      const refParam = getRefParam(ctx, val[1]);
+      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)},`;
+      if (hasPrev) {
+        result += ",";
+      }
+      result += isIdentifier ? key : quote(key);
+      result += ":" + serializeTree(ctx, val);
+      hasPrev = true;
     }
   }
   ctx.stack.pop();
-  return `{${result.substring(0, result.length - 1)}}`;
+  return "{" + result + "}";
 }
-function serializePromise(ctx, value, id) {
-  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})`;
+function serializeWithObjectAssign(ctx, value, id, serialized) {
+  const fields = serializeObject(ctx, id, value);
+  if (fields !== "{}") {
+    return "Object.assign(" + serialized + "," + fields + ")";
   }
-  return assignRef(ctx, id, serialized);
+  return serialized;
 }
-function serializeTypedArray(ctx, constructor, init, byteOffset, id) {
-  let args = `[${init}]`;
-  if (byteOffset !== 0) {
-    args += `,${byteOffset}`;
+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);
+    }
+    ctx.assignments = parentAssignment;
   }
-  return assignRef(ctx, id, `new ${constructor}(${args})`);
+  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 + ")";
+      }
+    }
+  }
+  return assignRef(ctx, i, init);
+}
+function serializeNullConstructor(ctx, node) {
+  return serializeDictionary(ctx, node.i, node.d, "Object.create(null)");
 }
-function serializeSet(ctx, value, id) {
+function serializeSet(ctx, node) {
   let serialized = "new Set";
-  const size = value.length;
+  const size = node.a.length;
   if (size) {
     let result = "";
-    ctx.stack.push(id);
+    ctx.stack.push(node.i);
+    let item;
+    let hasPrev = false;
     for (let i = 0; i < size; i++) {
-      const item = value[i];
+      item = node.a[i];
       if (isReferenceInStack(ctx, item)) {
-        createSetAdd(ctx, id, getRefParam(ctx, item[1]));
+        createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
       } else {
-        result += `${serializeTree(ctx, item)},`;
+        if (hasPrev) {
+          result += ",";
+        }
+        result += serializeTree(ctx, item);
+        hasPrev = true;
       }
     }
     ctx.stack.pop();
     if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
+      serialized += "([" + result + "])";
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeMap(ctx, keys, values, size, id) {
+function serializeMap(ctx, node) {
   let serialized = "new Map";
-  if (size) {
+  if (node.d.s) {
     let result = "";
-    ctx.stack.push(id);
-    for (let i = 0; i < size; i++) {
-      const key = keys[i];
-      const val = values[i];
+    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)) {
-        const keyRef = getRefParam(ctx, key[1]);
+        keyRef = getRefParam(ctx, key.i);
         if (isReferenceInStack(ctx, val)) {
-          const valueRef = getRefParam(ctx, val[1]);
-          createMapSet(ctx, id, keyRef, valueRef);
+          valueRef = getRefParam(ctx, val.i);
+          createMapSet(ctx, node.i, keyRef, valueRef);
         } else {
-          const parent = ctx.stack;
+          parent = ctx.stack;
           ctx.stack = [];
-          createMapSet(ctx, id, keyRef, serializeTree(ctx, val));
+          createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
           ctx.stack = parent;
         }
       } else if (isReferenceInStack(ctx, val)) {
-        const valueRef = getRefParam(ctx, val[1]);
-        const parent = ctx.stack;
+        valueRef = getRefParam(ctx, val.i);
+        parent = ctx.stack;
         ctx.stack = [];
-        createMapSet(ctx, id, serializeTree(ctx, key), valueRef);
+        createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
         ctx.stack = parent;
       } else {
-        result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
+        if (hasPrev) {
+          result += ",";
+        }
+        result += "[" + serializeTree(ctx, key) + "," + serializeTree(ctx, val) + "]";
+        hasPrev = true;
       }
     }
     ctx.stack.pop();
     if (result) {
-      serialized += `([${result.substring(0, result.length - 1)}])`;
+      serialized += "([" + result + "])";
     }
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeNodeList(ctx, value, id) {
-  const size = value.length;
-  let values = "";
-  for (let i = 0; i < size; i++) {
-    const item = value[i];
-    if (item) {
-      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 += ",";
-    }
-  }
-  return `[${values}]`;
-}
-function serializeArray(ctx, value, id) {
-  ctx.stack.push(id);
-  const result = serializeNodeList(ctx, value, id);
+function serializeAggregateError(ctx, node) {
+  ctx.stack.push(node.i);
+  const serialized = "new AggregateError(" + serializeTree(ctx, node.n) + "," + quote(node.m) + ")";
   ctx.stack.pop();
-  return assignRef(ctx, id, result);
+  return serializeDictionary(ctx, node.i, node.d, serialized);
 }
-function serializeWithObjectAssign(ctx, value, id, serialized) {
-  const fields = serializeObject(ctx, id, value);
-  if (fields !== "{}") {
-    return `Object.assign(${serialized},${fields})`;
-  }
-  return serialized;
+function serializeError(ctx, node) {
+  const serialized = "new " + node.c + "(" + quote(node.m) + ")";
+  return serializeDictionary(ctx, node.i, node.d, serialized);
 }
-function serializeAggregateError(ctx, message, options, errors, id) {
-  ctx.stack.push(id);
-  let serialized = `new AggregateError(${serializeTree(ctx, errors)},${quote(message)})`;
-  ctx.stack.pop();
-  if (options) {
-    if (ctx.features & 64 /* ObjectAssign */) {
-      serialized = serializeWithObjectAssign(ctx, options, id, 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 = "Promise.resolve().then(()=>" + ref + ")";
     } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
-      if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-      }
+      serialized = "Promise.resolve().then(function(){return " + ref + "})";
     }
+  } else {
+    ctx.stack.push(node.i);
+    const result = serializeTree(ctx, node.n);
+    ctx.stack.pop();
+    serialized = "Promise.resolve(" + result + ")";
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, serialized);
 }
-function serializeError(ctx, constructor, message, options, id) {
-  let serialized = `new ${constructor}(${quote(message)})`;
-  if (options) {
-    if (ctx.features & 64 /* ObjectAssign */) {
-      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
-    } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
-      if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-      }
-    }
+function serializeTypedArray(ctx, node) {
+  let args = "[" + node.s + "]";
+  if (node.l !== 0) {
+    args += "," + node.l.toString();
   }
-  return assignRef(ctx, id, serialized);
+  return assignRef(ctx, node.i, "new " + node.c + "(" + args + ")");
 }
-function serializeIterable(ctx, options, items, id) {
+function serializeIterable(ctx, node) {
   const parent = ctx.stack;
   ctx.stack = [];
-  const values = serializeNodeList(ctx, items, id);
+  const values = serializeNodeList(ctx, node);
   ctx.stack = parent;
-  let serialized;
+  let serialized = values;
   if (ctx.features & 2 /* ArrayPrototypeValues */) {
-    serialized = `${values}.values()`;
+    serialized += ".values()";
   } else {
-    serialized = `${values}[Symbol.iterator]()`;
+    serialized += "[Symbol.iterator]()";
   }
   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}}}`;
-  }
-  if (options) {
-    if (ctx.features & 64 /* ObjectAssign */) {
-      serialized = serializeWithObjectAssign(ctx, options, id, serialized);
-    } else {
-      markRef(ctx, id);
-      const assignments = serializeAssignments(ctx, id, options);
-      if (assignments) {
-        const ref = getRefParam(ctx, id);
-        return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-      }
-    }
-  }
-  return assignRef(ctx, id, serialized);
-}
-function serializeNullConstructor(ctx, value, id) {
-  let serialized = "Object.create(null)";
-  if (ctx.features & 64 /* ObjectAssign */) {
-    serialized = serializeWithObjectAssign(ctx, value, id, serialized);
+    serialized = "{[Symbol.iterator]:()=>" + serialized + "}";
+  } else if (ctx.features & 64 /* MethodShorthand */) {
+    serialized = "{[Symbol.iterator](){return " + serialized + "}}";
   } else {
-    markRef(ctx, id);
-    const assignments = serializeAssignments(ctx, id, value);
-    if (assignments) {
-      const ref = getRefParam(ctx, id);
-      return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
-    }
+    serialized = "{[Symbol.iterator]:function(){return " + serialized + "}}";
   }
-  return assignRef(ctx, id, serialized);
+  return serializeDictionary(ctx, node.i, node.d, serialized);
 }
-function serializeTree(ctx, [type, value, id]) {
-  switch (type) {
+function serializeTree(ctx, node) {
+  switch (node.t) {
     case 0 /* Primitive */:
-      return String(value);
-    case 2 /* Reference */:
-      return getRefParam(ctx, value);
-    case 10 /* Promise */:
-      return serializePromise(ctx, value, id);
+      return String(node.s);
     case 1 /* BigInt */:
-      return value;
+      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, id, `new Date("${value}")`);
+      return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
     case 4 /* RegExp */:
-      return assignRef(ctx, id, value);
-    case 15 /* BigIntTypedArray */:
-    case 14 /* TypedArray */:
-      return serializeTypedArray(ctx, value[0], value[1], value[2], id);
+      return assignRef(ctx, node.i, node.s);
     case 5 /* Set */:
-      return serializeSet(ctx, value, id);
+      return serializeSet(ctx, node);
     case 6 /* Map */:
-      return serializeMap(ctx, value[0], value[1], value[2], id);
-    case 7 /* Array */:
-      return serializeArray(ctx, value, id);
+      return serializeMap(ctx, node);
+    case 15 /* BigIntTypedArray */:
+    case 14 /* TypedArray */:
+      return serializeTypedArray(ctx, node);
     case 12 /* AggregateError */:
-      return serializeAggregateError(ctx, value[0], value[1], value[2], id);
+      return serializeAggregateError(ctx, node);
     case 11 /* Error */:
-      return serializeError(ctx, value[0], value[1], value[2], id);
+      return serializeError(ctx, node);
     case 13 /* Iterable */:
-      return serializeIterable(ctx, value[0], value[1], id);
-    case 9 /* NullConstructor */:
-      return serializeNullConstructor(ctx, value, id);
-    case 8 /* Object */:
-      return assignRef(ctx, id, serializeObject(ctx, id, value));
+      return serializeIterable(ctx, node);
+    case 10 /* Promise */:
+      return serializePromise(ctx, node);
     default:
       throw new Error("Unsupported type");
   }
 }
 
 // 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);
+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[i] = item;
+      } else {
+        nodes[i] = parse2(ctx, item);
+      }
+    }
+  }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = parse2(ctx, deferred[i]);
+    }
+  }
+  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 nodesSize = 0;
-  for (const key of keys) {
-    if (isIterable(properties[key])) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key];
+  let nodeSize = 0;
+  for (const [key, value] of current.entries()) {
+    if (isIterable(key) || isIterable(value)) {
+      deferredKey[deferredSize] = key;
+      deferredValue[deferredSize] = value;
       deferredSize++;
     } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key]);
-      nodesSize++;
+      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] = generateTreeSync(ctx, deferredValues[i]);
+    keyNodes[nodeSize + i] = parse2(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = parse2(ctx, deferredValue[i]);
   }
-  return [keyNodes, valueNodes, size];
+  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, current, id) {
-  assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+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);
@@ -1066,130 +1159,211 @@ function generateSetNode2(ctx, current, id) {
     if (isIterable(item)) {
       deferred[deferredSize++] = item;
     } else {
-      nodes[nodeSize++] = generateTreeSync(ctx, item);
+      nodes[nodeSize++] = parse2(ctx, item);
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
+    nodes[nodeSize + i] = parse2(ctx, deferred[i]);
   }
-  return [5 /* Set */, nodes, id];
+  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 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);
+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 nodeSize = 0;
-  for (const [key, value] of current.entries()) {
-    if (isIterable(key) || isIterable(value)) {
-      deferredKey[deferredSize] = key;
-      deferredValue[deferredSize] = value;
+  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[nodeSize] = generateTreeSync(ctx, key);
-      valueNodes[nodeSize] = generateTreeSync(ctx, value);
-      nodeSize++;
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = parse2(ctx, item);
+      nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
-    valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
-  }
-  return [6 /* Map */, [keyNodes, valueNodes, len], id];
-}
-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 {
-        nodes[i] = generateTreeSync(ctx, current[i]);
-      }
-    }
-  }
-  for (let i = 0; i < size; i++) {
-    if (i in deferred) {
-      nodes[i] = generateTreeSync(ctx, deferred[i]);
-    }
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = parse2(ctx, deferredValues[i]);
   }
-  return nodes;
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size
+  };
 }
-function generateArrayNode2(ctx, current, id) {
-  return [7 /* Array */, generateNodeList2(ctx, current), id];
-}
-function generateAggregateErrorNode2(ctx, current, id) {
-  const options = getErrorOptions(current);
-  const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
-  const errorsNode = generateTreeSync(ctx, current.errors);
-  return [12 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
-}
-function generateErrorNode2(ctx, current, id) {
-  const options = getErrorOptions(current);
-  const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
-  return [
-    11 /* Error */,
-    [getErrorConstructor(current), current.message, optionsNode],
-    id
-  ];
-}
-function generateIterableNode2(ctx, current, id) {
-  assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
+function generateIterableNode2(ctx, id, current) {
+  assert(ctx.features & 1024 /* SymbolIterator */, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
-  return [13 /* Iterable */, [
+  return {
+    t: 13 /* Iterable */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    c: void 0,
+    m: void 0,
     // Parse options first before the items
-    options ? serializePropertiesSync(ctx, options) : void 0,
-    generateNodeList2(ctx, Array.from(current))
-  ], id];
+    d: options ? generateProperties2(ctx, options) : void 0,
+    a: generateNodeList2(ctx, Array.from(current)),
+    n: void 0
+  };
 }
-function generateTreeSync(ctx, current) {
-  if (isPrimitive(current)) {
-    return [0 /* Primitive */, serializePrimitive(current)];
-  }
-  const id = generateRef(ctx, current);
-  if (Array.isArray(id)) {
-    return id;
-  }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
+function generateObjectNode2(ctx, id, current, empty) {
+  if (Symbol.iterator in current) {
+    return generateIterableNode2(ctx, id, current);
   }
-  if (constructorCheck(current, Set)) {
-    return generateSetNode2(ctx, current, id);
-  }
-  if (constructorCheck(current, Map)) {
-    return generateMapNode2(ctx, current, id);
-  }
-  if (Array.isArray(current)) {
-    return generateArrayNode2(ctx, current, id);
-  }
-  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-    return generateAggregateErrorNode2(ctx, current, id);
-  }
-  if (current instanceof Error) {
-    return generateErrorNode2(ctx, current, id);
-  }
-  if (isIterable(current)) {
-    return generateIterableNode2(ctx, current, id);
-  }
-  const empty = current.constructor == null;
-  if (current.constructor === Object || empty) {
-    return [
-      empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      serializePropertiesSync(ctx, current),
-      id
-    ];
+  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;
+      }
+      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");
   }
-  throw new Error("Unsupported value");
 }
 function parseSync(ctx, current) {
-  const result = generateTreeSync(ctx, current);
-  return [result, createRef(ctx, current), result[0] === 8 /* Object */];
+  const result = parse2(ctx, current);
+  const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
+  return [result, createRef(ctx, current, false), isObject];
 }
 
 // src/index.ts
@@ -1199,29 +1373,25 @@ function finalize(ctx, rootID, isObject, result) {
     let body = result;
     if (patches) {
       const index = getRefParam(ctx, rootID);
-      if (result.startsWith(`${index}=`)) {
-        body = `${result},${patches}${index}`;
-      } else {
-        body = `${index}=${result},${patches}${index}`;
+      body = result + "," + patches + index;
+      if (!result.startsWith(index + "=")) {
+        body = index + "=" + body;
       }
     }
     let params = ctx.vars.length > 1 ? ctx.vars.join(",") : ctx.vars[0];
     if (ctx.features & 4 /* ArrowFunction */) {
-      params = ctx.vars.length > 1 || ctx.vars.length === 0 ? `(${params})` : params;
-      return `(${params}=>(${body}))()`;
+      params = ctx.vars.length > 1 || ctx.vars.length === 0 ? "(" + params + ")" : params;
+      return "(" + params + "=>(" + body + "))()";
     }
-    return `(function(${params}){return ${body}})()`;
+    return "(function(" + params + "){return " + body + "})()";
   }
   if (isObject) {
-    return `(${result})`;
+    return "(" + result + ")";
   }
   return result;
 }
 function serialize(source, options) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
@@ -1229,9 +1399,6 @@ function serialize(source, options) {
 }
 async function serializeAsync(source, options) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
@@ -1243,39 +1410,40 @@ function deserialize(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
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(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
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(ctx.markedRefs)
+  });
 }
 function compileJSON(source) {
   const parsed = JSON.parse(source);
   const serial = createSerializationContext({
-    features: parsed[3],
-    markedRefs: parsed[4]
+    features: parsed.f,
+    markedRefs: parsed.m
   });
-  const result = serializeTree(serial, parsed[0]);
-  return finalize(serial, parsed[1], parsed[2], result);
+  const result = serializeTree(serial, parsed.t);
+  return finalize(serial, parsed.r, parsed.i, result);
 }
 function fromJSON(source) {
   return deserialize(compileJSON(source));
 }
 var src_default = serialize;
 export {
+  Feature,
   compileJSON,
   src_default as default,
   deserialize,