seroval 0.2.1 → 0.4.0-alpha.0

package/dist/cjs/development/index.cjs

@@ -27,23 +27,67 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/array.ts
-function forEach(arr, callback) {
-  for (let i = 0, len = arr.length; i < len; i++) {
-    if (callback(arr[i], i)) {
-      break;
-    }
+// src/checks.ts
+function isPrimitive(current) {
+  if (!current || current === true) {
+    return true;
   }
+  const type = typeof current;
+  return type === "number" || type === "string" || type === "bigint";
+}
+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 join(arr, joiner) {
+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/quote.ts
+function quote(str) {
   let result = "";
-  forEach(arr, (value, index) => {
-    result += value;
-    if (index < arr.length - 1) {
-      result += joiner;
+  let lastPos = 0;
+  for (let i = 0, len = str.length; i < len; i++) {
+    let replacement;
+    switch (str[i]) {
+      case '"':
+        replacement = '\\"';
+        break;
+      case "\\":
+        replacement = "\\\\";
+        break;
+      case "<":
+        replacement = "\\x3C";
+        break;
+      case "\n":
+        replacement = "\\n";
+        break;
+      case "\r":
+        replacement = "\\r";
+        break;
+      case "\u2028":
+        replacement = "\\u2028";
+        break;
+      case "\u2029":
+        replacement = "\\u2029";
+        break;
+      default:
+        continue;
     }
-  });
-  return result;
+    result += str.slice(lastPos, i) + replacement;
+    lastPos = i + 1;
+  }
+  if (lastPos === 0) {
+    result = str;
+  } else {
+    result += str.slice(lastPos);
+  }
+  return `"${result}"`;
 }
 
 // src/get-identifier.ts
@@ -63,583 +107,1079 @@ function getIdentifier(index) {
   return ref;
 }
 
-// src/context.ts
-var EMPTY_SET = "new Set";
-var EMPTY_MAP = "new Map";
-var EMPTY_ARRAY = "[]";
-function createSerializationContext() {
+// 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
+  "aggregate-error": {
+    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
+  "array-values": {
+    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
+  "arrow-function": {
+    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
+  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
+  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
+  "method-shorthand": {
+    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
+  "object-assign": {
+    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
+  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
+  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
+  "symbol-iterator": {
+    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
+  "typed-arrays": {
+    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]
+  }
+};
+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 isFeatureSupported(key, targets) {
+  const base = VERSION_TABLE[key];
+  let flag = true;
+  for (const [platform, version] of targets) {
+    const baseVersion = base[platform];
+    flag = flag && !!baseVersion && compareVersion(baseVersion, version) <= 0;
+  }
+  return flag;
+}
+function parseTargets(targets) {
+  const parsed = getTargetVersions(targets);
+  const flags = /* @__PURE__ */ new Set();
+  for (const key in VERSION_TABLE) {
+    if (isFeatureSupported(key, parsed)) {
+      flags.add(key);
+    }
+  }
+  return flags;
+}
+
+// src/tree.ts
+var DEFAULT_OPTIONS = {
+  target: "es2023"
+};
+function createSerializationContext(options = {}) {
+  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    refCount: /* @__PURE__ */ new Map(),
-    stack: /* @__PURE__ */ new Set(),
+    markedRefs: [],
+    stack: [],
     refs: /* @__PURE__ */ new Map(),
-    assignedRefs: /* @__PURE__ */ new Set(),
     vars: [],
     assignments: [],
-    mapSets: [],
-    setAdds: []
+    validRefs: /* @__PURE__ */ new Map(),
+    features: parseTargets(result.target)
   };
 }
-function resolveAssignments(ctx) {
-  if (ctx.assignments.length) {
-    const result = {};
-    forEach(ctx.assignments, ([source, value]) => {
-      if (value in result) {
-        result[value] = `${source}=${result[value]}`;
-      } else {
-        result[value] = `${source}=${value}`;
-      }
-    });
-    return `${join(Object.values(result), ",")},`;
+function getAssignmentExpression(assignment) {
+  switch (assignment.type) {
+    case "index":
+      return `${assignment.source}=${assignment.value}`;
+    case "map":
+      return `${assignment.source}.set(${assignment.key},${assignment.value})`;
+    case "set":
+      return `${assignment.source}.add(${assignment.value})`;
+    default:
+      return "";
   }
-  return "";
 }
-function resolveMapSets(ctx) {
-  if (ctx.mapSets.length) {
-    const result = {};
-    forEach(ctx.mapSets, ([source, key, value]) => {
-      if (source in result) {
-        result[source] = `${result[source]}.set(${key},${value})`;
+function mergeAssignments(assignments) {
+  const newAssignments = [];
+  let current = assignments[0];
+  let prev = current;
+  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) {
+        current = {
+          type: "index",
+          source: item.source,
+          value: getAssignmentExpression(current)
+        };
+      } else if (item.type === "map" && item.source === prev.source) {
+        current = {
+          type: "map",
+          source: getAssignmentExpression(current),
+          key: item.key,
+          value: item.value
+        };
+      } else if (item.type === "set" && item.source === prev.source) {
+        current = {
+          type: "set",
+          source: getAssignmentExpression(current),
+          value: item.value
+        };
       } else {
-        result[source] = `${source}.set(${key},${value})`;
+        newAssignments.push(current);
+        current = item;
       }
-    });
-    return `${join(Object.values(result), ",")},`;
+    } else {
+      newAssignments.push(current);
+      current = item;
+    }
+    prev = item;
   }
-  return "";
+  newAssignments.push(current);
+  return newAssignments;
 }
-function resolveSetAdds(ctx) {
-  if (ctx.setAdds.length) {
-    const result = {};
-    forEach(ctx.setAdds, ([source, value]) => {
-      if (source in result) {
-        result[source] = `${result[source]}.add(${value})`;
-      } else {
-        result[source] = `${source}.add(${value})`;
-      }
-    });
-    return `${join(Object.values(result), ",")},`;
+function resolveAssignments(assignments) {
+  if (assignments.length) {
+    let result = "";
+    const merged = mergeAssignments(assignments);
+    for (let i = 0, len = merged.length; i < len; i++) {
+      result += `${getAssignmentExpression(merged[i])},`;
+    }
+    return result;
   }
-  return "";
+  return void 0;
 }
 function resolvePatches(ctx) {
-  return `${resolveAssignments(ctx)}${resolveMapSets(ctx)}${resolveSetAdds(ctx)}`;
+  return resolveAssignments(ctx.assignments);
 }
-function insertRef(ctx, current) {
-  const count = ctx.refCount.get(current) || 0;
-  ctx.refCount.set(current, count + 1);
-  return count === 0;
+function markRef(ctx, current) {
+  ctx.markedRefs[current] = true;
 }
-function constructorCheck(value, constructor) {
-  return value.constructor === constructor;
-}
-function createRef(ctx, value) {
-  const current = ctx.refs.get(value);
+function createRef(ctx, index) {
+  const current = ctx.refs.get(index);
   if (current != null) {
     return current;
   }
   const id = ctx.refs.size;
-  ctx.refs.set(value, id);
+  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) {
-  if (ctx.vars[index]) {
-    return ctx.vars[index];
+  const actualIndex = createValidRef(ctx, index);
+  if (ctx.vars[actualIndex]) {
+    return ctx.vars[actualIndex];
   }
-  const result = getIdentifier(index);
-  ctx.vars[index] = result;
+  const result = getIdentifier(actualIndex);
+  ctx.vars[actualIndex] = result;
   return result;
 }
 function assignRef(ctx, index, value) {
-  return `${getRefParam(ctx, index)}=${value}`;
+  if (ctx.markedRefs[index]) {
+    return `${getRefParam(ctx, index)}=${value}`;
+  }
+  return value;
 }
 function createAssignment(ctx, source, value) {
-  ctx.assignments.push([source, value]);
+  ctx.assignments.push({
+    type: "index",
+    source,
+    value
+  });
 }
 function createSetAdd(ctx, ref, value) {
-  ctx.setAdds.push([getRefParam(ctx, ref), value]);
+  markRef(ctx, ref);
+  ctx.assignments.push({
+    type: "set",
+    source: getRefParam(ctx, ref),
+    value
+  });
 }
 function createMapSet(ctx, ref, key, value) {
-  ctx.mapSets.push([getRefParam(ctx, ref), key, value]);
+  markRef(ctx, ref);
+  ctx.assignments.push({
+    type: "map",
+    source: getRefParam(ctx, ref),
+    key,
+    value
+  });
 }
 function createArrayAssign(ctx, ref, index, value) {
+  markRef(ctx, ref);
   createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
 }
 function createObjectIdentifierAssign(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);
 }
-
-// src/is-primitive.ts
-function isPrimitive(current) {
-  if (!current || current === true) {
-    return true;
+function getErrorConstructor(error) {
+  if (error instanceof EvalError) {
+    return "EvalError";
   }
-  const type = typeof current;
-  const classConst = current.constructor;
-  return type === "number" || type === "string" || type === "bigint" || classConst === Date || classConst === RegExp;
+  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";
 }
-
-// src/is-promise.ts
-function isPromise(obj) {
-  return !!obj && (typeof obj === "object" || typeof obj === "function") && "then" in obj && typeof obj.then === "function";
+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;
 }
-
-// src/quote.ts
-function quote(str) {
-  let result = "";
-  let lastPos = 0;
-  for (let i = 0, len = str.length; i < len; i++) {
-    let replacement;
-    switch (str[i]) {
-      case '"':
-        replacement = '\\"';
-        break;
-      case "\\":
-        replacement = "\\\\";
-        break;
-      case "<":
-        replacement = "\\x3C";
-        break;
-      case "\n":
-        replacement = "\\n";
-        break;
-      case "\r":
-        replacement = "\\r";
-        break;
-      case "\u2028":
-        replacement = "\\u2028";
-        break;
-      case "\u2029":
-        replacement = "\\u2029";
-        break;
-      default:
-        continue;
+function getIterableOptions(obj) {
+  const names = Object.getOwnPropertyNames(obj);
+  if (names.length) {
+    const options = {};
+    for (const name of names) {
+      options[name] = obj[name];
     }
-    result += str.slice(lastPos, i) + replacement;
-    lastPos = i + 1;
+    return options;
   }
-  if (lastPos === 0) {
-    result = str;
-  } else {
-    result += str.slice(lastPos);
+  return void 0;
+}
+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];
   }
-  return `"${result}"`;
+  const id = ctx.refs.size;
+  ctx.refs.set(current, id);
+  return id;
 }
-
-// src/serialize-primitive.ts
-function serializePrimitive(value) {
-  if (value === true) {
-    return "!0";
+function generateSemiPrimitiveValue(ctx, current, id) {
+  if (constructorCheck(current, Date)) {
+    return [2 /* Date */, current, id];
   }
-  if (value === false) {
-    return "!1";
+  if (constructorCheck(current, RegExp)) {
+    return [3 /* RegExp */, current, id];
   }
-  if (value === void 0) {
-    return "void 0";
+  if (constructorCheck(current, Int8Array)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int8Array"');
+    return [13 /* TypedArray */, ["Int8Array", current], id];
   }
-  if (value === null) {
-    return "null";
+  if (constructorCheck(current, Int16Array)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int16Array"');
+    return [13 /* TypedArray */, ["Int16Array", current], id];
   }
-  if (Object.is(value, -0)) {
-    return "-0";
+  if (constructorCheck(current, Int32Array)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int32Array"');
+    return [13 /* TypedArray */, ["Int32Array", current], id];
   }
-  if (typeof value === "bigint") {
-    return `BigInt("${value}")`;
+  if (constructorCheck(current, Uint8Array)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint8Array"');
+    return [13 /* TypedArray */, ["Uint8Array", current], id];
   }
-  if (typeof value === "string") {
-    return quote(value);
+  if (constructorCheck(current, Uint16Array)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint16Array"');
+    return [13 /* TypedArray */, ["Uint16Array", current], id];
   }
-  if (value.constructor === Date) {
-    return `new Date("${value.toISOString()}")`;
+  if (constructorCheck(current, Uint32Array)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint32Array"');
+    return [13 /* TypedArray */, ["Uint32Array", current], id];
   }
-  return String(value);
+  if (constructorCheck(current, Uint8ClampedArray)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint8ClampedArray"');
+    return [13 /* TypedArray */, ["Uint8ClampedArray", current], id];
+  }
+  if (constructorCheck(current, Float32Array)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Float32Array"');
+    return [13 /* TypedArray */, ["Float32Array", current], id];
+  }
+  if (constructorCheck(current, Float64Array)) {
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Float64Array"');
+    return [13 /* TypedArray */, ["Float64Array", current], id];
+  }
+  if (constructorCheck(current, BigInt64Array)) {
+    assert(
+      ctx.features.has("typed-arrays") && ctx.features.has("bigint"),
+      'Unsupported value type "BigInt64Array"'
+    );
+    return [13 /* TypedArray */, ["BigInt64Array", current], id];
+  }
+  if (constructorCheck(current, BigUint64Array)) {
+    assert(
+      ctx.features.has("typed-arrays") && ctx.features.has("bigint"),
+      'Unsupported value type "BigUint64Array"'
+    );
+    return [13 /* TypedArray */, ["BigUint64Array", current], id];
+  }
+  return void 0;
 }
-
-// src/async.ts
-async function lookupRefsAsync(ctx, current) {
+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++;
+      } else {
+        keyNodes.push(key);
+        valueNodes.push(generateTreeSync(ctx, properties[key]));
+      }
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes.push(deferredKeys[i]);
+      valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
+    }
+    return [keyNodes, valueNodes, keys.length];
+  }
   if (isPrimitive(current)) {
-    return;
+    return [0 /* Primitive */, current];
   }
-  if (isPromise(current)) {
-    if (insertRef(ctx, current)) {
-      await current.then((value) => lookupRefsAsync(ctx, value));
-    }
-  } else if (Array.isArray(current)) {
-    if (insertRef(ctx, current)) {
-      for (const value of current) {
-        await lookupRefsAsync(ctx, value);
+  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("set"), 'Unsupported type "Set"');
+    const nodes = [];
+    const deferred = [];
+    for (const item of current.keys()) {
+      if (isIterable(item)) {
+        deferred.push(item);
+      } else {
+        nodes.push(generateTreeSync(ctx, item));
       }
     }
-  } else if (constructorCheck(current, Set)) {
-    if (insertRef(ctx, current)) {
-      for (const item of current.keys()) {
-        await lookupRefsAsync(ctx, item);
+    for (let i = 0, len = deferred.length; i < len; i++) {
+      nodes.push(generateTreeSync(ctx, deferred[i]));
+    }
+    return [4 /* Set */, nodes, id];
+  }
+  if (constructorCheck(current, Map)) {
+    assert(ctx.features.has("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++;
+      } else {
+        keyNodes.push(generateTreeSync(ctx, key));
+        valueNodes.push(generateTreeSync(ctx, value));
       }
     }
-  } else if (constructorCheck(current, Map)) {
-    if (insertRef(ctx, current)) {
-      for (const [key, value] of current.entries()) {
-        await lookupRefsAsync(ctx, key);
-        await lookupRefsAsync(ctx, value);
+    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]);
+        }
       }
     }
-  } else if ((current.constructor === Object || current.constructor == null) && insertRef(ctx, current)) {
-    for (const value of Object.values(current)) {
-      await lookupRefsAsync(ctx, value);
+    for (let i = 0; i < size; i++) {
+      if (i in deferred) {
+        nodes[i] = generateTreeSync(ctx, deferred[i]);
+      }
     }
+    return [6 /* Array */, nodes, id];
   }
-}
-async function traverseAsync(ctx, current) {
-  if (isPrimitive(current)) {
-    return serializePrimitive(current);
+  if (current instanceof AggregateError && ctx.features.has("aggregate-error")) {
+    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];
   }
-  let refResult = ctx.refs.get(current);
-  if (refResult != null) {
-    if (ctx.assignedRefs.has(refResult)) {
-      return getRefParam(ctx, refResult);
-    }
-    ctx.assignedRefs.add(refResult);
+  if (current instanceof Error) {
+    const options = getErrorOptions(current);
+    const optionsNode = options ? serializeProperties(options) : void 0;
+    return [
+      10 /* Error */,
+      [getErrorConstructor(current), current.message, optionsNode],
+      id
+    ];
   }
-  function getCurrentRef() {
-    if (refResult == null) {
-      refResult = createRef(ctx, current);
-    }
-    return refResult;
+  if (isIterable(current)) {
+    assert(ctx.features.has("symbol-iterator"), '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];
   }
-  function processRef(value) {
-    if (refResult != null) {
-      return assignRef(ctx, refResult, value);
-    }
-    return value;
+  const empty = current.constructor == null;
+  if (current.constructor === Object || empty) {
+    return [
+      empty ? 8 /* NullConstructor */ : 7 /* Object */,
+      serializeProperties(current),
+      id
+    ];
   }
-  if (isPromise(current)) {
-    return current.then(async (value) => {
-      ctx.stack.add(current);
-      let result;
-      if (ctx.stack.has(value)) {
-        const refParam = getRefParam(ctx, createRef(ctx, value));
-        result = `Promise.resolve().then(()=>${refParam})`;
+  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 {
-        result = `Promise.resolve(${await traverseAsync(ctx, value)})`;
+        keyNodes.push(key);
+        valueNodes.push(await generateTreeAsync(ctx, properties[key]));
       }
-      ctx.stack.delete(current);
-      return processRef(result);
-    });
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes.push(deferredKeys[i]);
+      valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
+    }
+    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 (isPromise(current)) {
+    assert(ctx.features.has("promise"), 'Unsupported type "Promise"');
+    return current.then(async (value) => [
+      9 /* Promise */,
+      await generateTreeAsync(ctx, value),
+      id
+    ]);
   }
   if (constructorCheck(current, Set)) {
-    if (current.size) {
-      const values = [];
-      ctx.stack.add(current);
-      for (const value of current.keys()) {
-        if (ctx.stack.has(value)) {
-          createSetAdd(ctx, getCurrentRef(), getRefParam(ctx, createRef(ctx, value)));
-        } else {
-          values.push(await traverseAsync(ctx, value));
-        }
+    assert(ctx.features.has("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));
       }
-      ctx.stack.delete(current);
-      return processRef(values.length ? `new Set([${join(values, ",")}])` : EMPTY_SET);
     }
-    return EMPTY_SET;
+    for (let i = 0, len = deferred.length; i < len; i++) {
+      nodes.push(await generateTreeAsync(ctx, deferred[i]));
+    }
+    return [4 /* Set */, nodes, id];
   }
   if (constructorCheck(current, Map)) {
-    if (current.size) {
-      const values = [];
-      ctx.stack.add(current);
-      for (const [key, value] of current.entries()) {
-        if (ctx.stack.has(key)) {
-          const ref = getCurrentRef();
-          const keyRef = getRefParam(ctx, createRef(ctx, key));
-          if (ctx.stack.has(value)) {
-            const valueRef = getRefParam(ctx, createRef(ctx, value));
-            createMapSet(ctx, ref, keyRef, valueRef);
-          } else {
-            const valueResult = await traverseAsync(ctx, value);
-            createMapSet(ctx, ref, keyRef, valueResult);
-          }
-        } else if (ctx.stack.has(value)) {
-          const valueRef = getRefParam(ctx, createRef(ctx, value));
-          const keyResult = await traverseAsync(ctx, key);
-          createMapSet(ctx, getCurrentRef(), keyResult, valueRef);
-        } else {
-          const keyResult = await traverseAsync(ctx, key);
-          const valueResult = await traverseAsync(ctx, value);
-          values.push(`[${keyResult},${valueResult}]`);
-        }
+    assert(ctx.features.has("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++;
+      } else {
+        keyNodes.push(await generateTreeAsync(ctx, key));
+        valueNodes.push(await generateTreeAsync(ctx, value));
       }
-      ctx.stack.delete(current);
-      return processRef(values.length ? `new Map([${join(values, ",")}])` : EMPTY_MAP);
     }
-    return EMPTY_MAP;
+    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)) {
-    if (current.length) {
-      let values = "";
-      ctx.stack.add(current);
-      for (let i = 0, len = current.length; i < len; i += 1) {
-        if (i in current) {
-          const item = current[i];
-          if (ctx.stack.has(item)) {
-            const refParam = getRefParam(ctx, createRef(ctx, item));
-            createArrayAssign(ctx, getCurrentRef(), i, refParam);
-            values += ",";
-          } else {
-            values += await traverseAsync(ctx, item);
-            if (i < current.length - 1) {
-              values += ",";
-            }
-          }
+    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 {
-          values += ",";
+          nodes[i] = await generateTreeAsync(ctx, item);
         }
       }
-      ctx.stack.delete(current);
-      return processRef(`[${values}]`);
     }
-    return EMPTY_ARRAY;
+    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("symbol-iterator"), '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) {
-    const values = [];
-    ctx.stack.add(current);
-    for (const [key, value2] of Object.entries(current)) {
+    return [
+      empty ? 8 /* NullConstructor */ : 7 /* Object */,
+      await serializeProperties(current),
+      id
+    ];
+  }
+  throw new Error("Unsupported value");
+}
+function serializePrimitive(ctx, 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 === "bigint") {
+    assert(ctx.features.has("bigint"), 'Unsupported type "BigInt"');
+    return `${value}n`;
+  }
+  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 String(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 (ctx.stack.has(value2)) {
-          const ref = getCurrentRef();
-          const refParam = getRefParam(ctx, createRef(ctx, value2));
-          if (Number.isNaN(check)) {
-            createObjectIdentifierAssign(ctx, ref, key, refParam);
+        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 {
-            createObjectComputedAssign(ctx, ref, key, refParam);
+            createObjectIdentifierAssign(ctx, sourceID, key, refParam);
           }
         } else {
-          const valueResult = await traverseAsync(ctx, value2);
-          values.push(`${key}:${valueResult}`);
+          result += `${key}:${serializeTree(ctx, val)},`;
         }
-      } else if (ctx.stack.has(value2)) {
-        const refParam = getRefParam(ctx, createRef(ctx, value2));
-        createObjectComputedAssign(ctx, getCurrentRef(), quote(key), refParam);
+      } else if (isReferenceInStack(ctx, val)) {
+        const refParam = getRefParam(ctx, val[1]);
+        createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
       } else {
-        const valueResult = await traverseAsync(ctx, value2);
-        values.push(`${quote(key)}:${valueResult}`);
+        result += `${quote(key)}:${serializeTree(ctx, val)},`;
       }
     }
-    ctx.stack.delete(current);
-    const value = `{${join(values, ",")}}`;
-    if (empty) {
-      return processRef(`Object.assign(Object.create(null),${value})`);
-    }
-    return processRef(value);
-  }
-  throw new Error("Unserializable value");
-}
-
-// src/sync.ts
-function lookupRefs(ctx, current) {
-  if (isPrimitive(current)) {
-    return;
+    ctx.stack.pop();
+    return `{${result.substring(0, result.length - 1)}}`;
   }
-  if (Array.isArray(current)) {
-    if (insertRef(ctx, current)) {
-      forEach(current, (value) => {
-        lookupRefs(ctx, value);
-      });
-    }
-  } else if (constructorCheck(current, Set)) {
-    if (insertRef(ctx, current)) {
-      for (const item of current.keys()) {
-        lookupRefs(ctx, item);
+  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);
     }
-  } else if (constructorCheck(current, Map)) {
-    if (insertRef(ctx, current)) {
-      for (const [key, value] of current.entries()) {
-        lookupRefs(ctx, key);
-        lookupRefs(ctx, value);
+    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})`);
     }
-  } else if ((current.constructor === Object || current.constructor == null) && insertRef(ctx, current)) {
-    forEach(Object.values(current), (value) => {
-      lookupRefs(ctx, value);
-    });
-  }
-}
-function traverseSync(ctx, current) {
-  if (isPrimitive(current)) {
-    return serializePrimitive(current);
-  }
-  let refResult = ctx.refs.get(current);
-  if (refResult != null) {
-    if (ctx.assignedRefs.has(refResult)) {
-      return getRefParam(ctx, refResult);
-    }
-    ctx.assignedRefs.add(refResult);
-  }
-  function getCurrentRef() {
-    if (refResult == null) {
-      refResult = createRef(ctx, current);
-    }
-    return refResult;
-  }
-  function processRef(value) {
-    if (refResult != null) {
-      return assignRef(ctx, refResult, value);
-    }
-    return value;
-  }
-  if (constructorCheck(current, Set)) {
-    if (current.size) {
-      const values = [];
-      ctx.stack.add(current);
-      for (const value of current.keys()) {
-        if (ctx.stack.has(value)) {
-          createSetAdd(ctx, getCurrentRef(), getRefParam(ctx, createRef(ctx, value)));
-        } else {
-          values.push(traverseSync(ctx, value));
+    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)}])`;
         }
       }
-      ctx.stack.delete(current);
-      return processRef(values.length ? `new Set([${join(values, ",")}])` : EMPTY_SET);
+      return assignRef(ctx, id, serialized);
     }
-    return EMPTY_SET;
-  }
-  if (constructorCheck(current, Map)) {
-    if (current.size) {
-      const values = [];
-      ctx.stack.add(current);
-      for (const [key, value] of current.entries()) {
-        if (ctx.stack.has(key)) {
-          const ref = getCurrentRef();
-          const keyRef = getRefParam(ctx, createRef(ctx, key));
-          if (ctx.stack.has(value)) {
-            const valueRef = getRefParam(ctx, createRef(ctx, value));
-            createMapSet(ctx, ref, keyRef, valueRef);
+    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 {
-            createMapSet(ctx, ref, keyRef, traverseSync(ctx, value));
+            result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
           }
-        } else if (ctx.stack.has(value)) {
-          const valueRef = getRefParam(ctx, createRef(ctx, value));
-          createMapSet(ctx, getCurrentRef(), traverseSync(ctx, key), valueRef);
-        } else {
-          values.push(`[${traverseSync(ctx, key)},${traverseSync(ctx, value)}]`);
+        }
+        ctx.stack.pop();
+        if (result) {
+          serialized += `([${result.substring(0, result.length - 1)}])`;
         }
       }
-      ctx.stack.delete(current);
-      return processRef(values.length ? `new Map([${join(values, ",")}])` : EMPTY_MAP);
+      return assignRef(ctx, id, serialized);
     }
-    return EMPTY_MAP;
-  }
-  if (Array.isArray(current)) {
-    if (current.length) {
+    case 6 /* Array */: {
+      const size = value.length;
       let values = "";
-      ctx.stack.add(current);
-      forEach(current, (item, i) => {
-        if (i in current) {
-          if (ctx.stack.has(item)) {
-            const refParam = getRefParam(ctx, createRef(ctx, item));
-            createArrayAssign(ctx, getCurrentRef(), i, refParam);
+      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 += traverseSync(ctx, item);
-            if (i < current.length - 1) {
+            values += serializeTree(ctx, item);
+            if (i < size - 1) {
               values += ",";
             }
           }
         } else {
           values += ",";
         }
-      });
-      ctx.stack.delete(current);
-      return processRef(`[${values}]`);
+      }
+      ctx.stack.pop();
+      return assignRef(ctx, id, `[${values}]`);
     }
-    return EMPTY_ARRAY;
-  }
-  const empty = current.constructor == null;
-  if (current.constructor === Object || empty) {
-    const values = [];
-    ctx.stack.add(current);
-    forEach(Object.entries(current), ([key, value2]) => {
-      const check = Number(key);
-      if (check >= 0 || Number.isNaN(check) && /^([$A-Z_][0-9A-Z_$]*)$/i.test(key)) {
-        if (ctx.stack.has(value2)) {
-          const ref = getCurrentRef();
-          const refParam = getRefParam(ctx, createRef(ctx, value2));
-          if (!Number.isNaN(check)) {
-            createObjectComputedAssign(ctx, ref, key, refParam);
-          } else {
-            createObjectIdentifierAssign(ctx, ref, key, refParam);
+    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("object-assign")) {
+          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("object-assign")) {
+          const options = serializeObject(id, value[2]);
+          serialized = `Object.assign(${serialized},${options})`;
         } else {
-          values.push(`${key}:${traverseSync(ctx, value2)}`);
+          markRef(ctx, id);
+          const assignments = serializeAssignments(id, value[2]);
+          if (assignments) {
+            const ref = getRefParam(ctx, id);
+            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+          }
         }
-      } else if (ctx.stack.has(value2)) {
-        const refParam = getRefParam(ctx, createRef(ctx, value2));
-        createObjectComputedAssign(ctx, getCurrentRef(), quote(key), refParam);
+      }
+      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("array-values")) {
+        serialized = `${values}.values()`;
       } else {
-        values.push(`${quote(key)}:${traverseSync(ctx, value2)}`);
+        serialized = `${values}[Symbol.iterator]()`;
       }
-    });
-    ctx.stack.delete(current);
-    const value = `{${join(values, ",")}}`;
-    if (empty) {
-      return processRef(`Object.assign(Object.create(null),${value})`);
+      if (ctx.features.has("arrow-function")) {
+        serialized = `{[Symbol.iterator]:()=>${serialized}}`;
+      } else if (ctx.features.has("method-shorthand")) {
+        serialized = `{[Symbol.iterator](){return ${serialized}}}`;
+      } else {
+        serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
+      }
+      if (value[0]) {
+        if (ctx.features.has("object-assign")) {
+          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("object-assign")) {
+        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);
     }
-    return processRef(value);
+    case 7 /* Object */:
+      return assignRef(ctx, id, serializeObject(id, value));
+    default:
+      throw new Error("Unsupported type");
   }
-  throw new Error("Unserializable value");
 }
 
 // src/index.ts
 function finalize(ctx, source, result) {
   if (ctx.vars.length) {
-    const index = getRefParam(ctx, createRef(ctx, source));
     const patches = resolvePatches(ctx);
-    const params = ctx.vars.length > 1 ? `(${join(ctx.vars, ",")})` : ctx.vars[0];
-    if (result.startsWith(`${index}=`)) {
-      return `(${params}=>(${result},${patches}${index}))()`;
+    let body = result;
+    if (patches) {
+      const index = getRefParam(ctx, createRef(ctx, source));
+      if (result.startsWith(`${index}=`)) {
+        body = `${result},${patches}${index}`;
+      } else {
+        body = `${index}=${result},${patches}${index}`;
+      }
     }
-    return `(${params}=>(${index}=${result},${patches}${index}))()`;
+    let params = ctx.vars.length > 1 ? ctx.vars.join(",") : ctx.vars[0];
+    if (ctx.features.has("arrow-function")) {
+      params = ctx.vars.length > 1 || ctx.vars.length === 0 ? `(${params})` : params;
+      return `(${params}=>(${body}))()`;
+    }
+    return `(function(${params}){return ${body}})()`;
   }
   if (source.constructor === Object) {
     return `(${result})`;
   }
   return result;
 }
-function serialize(source) {
+function serialize(source, options) {
+  const ctx = createSerializationContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(source);
-  }
-  const ctx = createSerializationContext();
-  lookupRefs(ctx, source);
-  for (const [key, value] of ctx.refCount.entries()) {
-    if (value > 1) {
-      createRef(ctx, key);
-    }
-  }
-  const result = traverseSync(ctx, source);
-  if (typeof result !== "string") {
-    throw new Error("Unreachable error");
+    return serializePrimitive(ctx, source);
   }
+  const tree = generateTreeSync(ctx, source);
+  const result = serializeTree(ctx, tree);
   return finalize(ctx, source, result);
 }
-async function serializeAsync(source) {
+async function serializeAsync(source, options) {
+  const ctx = createSerializationContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(source);
-  }
-  const ctx = createSerializationContext();
-  await lookupRefsAsync(ctx, source);
-  for (const [key, value] of ctx.refCount.entries()) {
-    if (value > 1) {
-      createRef(ctx, key);
-    }
-  }
-  const result = await traverseAsync(ctx, source);
-  if (typeof result !== "string") {
-    throw new Error("Unreachable error");
+    return serializePrimitive(ctx, source);
   }
+  const tree = await generateTreeAsync(ctx, source);
+  const result = serializeTree(ctx, tree);
   return finalize(ctx, source, result);
 }
 function deserialize(source) {