seroval 0.2.0 → 0.3.0

package/dist/cjs/development/index.cjs

@@ -27,23 +27,99 @@ __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 join(arr, joiner) {
+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/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/serialize-primitive.ts
+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 === "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);
 }
 
 // src/get-identifier.ts
@@ -63,533 +139,664 @@ function getIdentifier(index) {
   return ref;
 }
 
-// src/context.ts
-var EMPTY_SET = "new Set";
-var EMPTY_MAP = "new Map";
-var EMPTY_ARRAY = "[]";
+// src/tree.ts
 function createSerializationContext() {
   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()
   };
 }
-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(ctx) {
+  const newAssignments = [];
+  let current = ctx.assignments[0];
+  let prev = current;
+  for (let i = 1, len = ctx.assignments.length; i < len; i += 1) {
+    const item = ctx.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 resolvePatches(ctx) {
+  if (ctx.assignments.length) {
+    let result = "";
+    for (const assignment of mergeAssignments(ctx)) {
+      result += `${getAssignmentExpression(assignment)},`;
+    }
+    return result;
   }
   return "";
 }
-function resolvePatches(ctx) {
-  return `${resolveAssignments(ctx)}${resolveMapSets(ctx)}${resolveSetAdds(ctx)}`;
-}
-function insertRef(ctx, current) {
-  const count = ctx.refCount.get(current) || 0;
-  ctx.refCount.set(current, count + 1);
-  return count === 0;
-}
-function constructorCheck(value, constructor) {
-  return value.constructor === constructor;
+function markRef(ctx, current) {
+  ctx.markedRefs[current] = true;
 }
-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";
+var EXCLUDED_ERROR_KEYS = {
+  name: true,
+  cause: true,
+  stack: true,
+  message: true
+};
+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 in EXCLUDED_ERROR_KEYS)) {
+      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(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)) {
+    return [13 /* TypedArray */, { constructor: "Int8Array", array: current }, id];
   }
-  if (value === null) {
-    return "null";
+  if (constructorCheck(current, Int16Array)) {
+    return [13 /* TypedArray */, { constructor: "Int16Array", array: current }, id];
   }
-  if (Object.is(value, -0)) {
-    return "-0";
+  if (constructorCheck(current, Int32Array)) {
+    return [13 /* TypedArray */, { constructor: "Int32Array", array: current }, id];
   }
-  if (typeof value === "bigint") {
-    return `BigInt("${value}")`;
+  if (constructorCheck(current, Uint8Array)) {
+    return [13 /* TypedArray */, { constructor: "Uint8Array", array: current }, id];
   }
-  if (typeof value === "string") {
-    return quote(value);
+  if (constructorCheck(current, Uint16Array)) {
+    return [13 /* TypedArray */, { constructor: "Uint16Array", array: current }, id];
   }
-  if (value.constructor === Date) {
-    return `new Date("${value.toISOString()}")`;
+  if (constructorCheck(current, Uint32Array)) {
+    return [13 /* TypedArray */, { constructor: "Uint32Array", array: current }, id];
   }
-  return String(value);
+  if (constructorCheck(current, Uint8ClampedArray)) {
+    return [13 /* TypedArray */, { constructor: "Uint8ClampedArray", array: current }, id];
+  }
+  if (constructorCheck(current, Float32Array)) {
+    return [13 /* TypedArray */, { constructor: "Float32Array", array: current }, id];
+  }
+  if (constructorCheck(current, Float64Array)) {
+    return [13 /* TypedArray */, { constructor: "Float64Array", array: current }, id];
+  }
+  if (constructorCheck(current, BigInt64Array)) {
+    return [13 /* TypedArray */, { constructor: "BigInt64Array", array: current }, id];
+  }
+  if (constructorCheck(current, BigUint64Array)) {
+    return [13 /* TypedArray */, { constructor: "BigUint64Array", array: current }, id];
+  }
+  return void 0;
 }
-
-// src/async.ts
-async function lookupRefsAsync(ctx, current) {
+function generateTreeSync(ctx, current) {
   if (isPrimitive(current)) {
-    return;
+    return [0 /* Primitive */, current];
   }
-  if (isPromise(current)) {
-    if (insertRef(ctx, current)) {
-      await current.then((value) => lookupRefsAsync(ctx, value));
+  const id = generateRef(ctx, current);
+  if (Array.isArray(id)) {
+    return id;
+  }
+  const semiPrimitive = generateSemiPrimitiveValue(current, id);
+  if (semiPrimitive) {
+    return semiPrimitive;
+  }
+  if (constructorCheck(current, Set)) {
+    const nodes = [];
+    const deferred = [];
+    for (const item of current.keys()) {
+      if (isIterable(item)) {
+        deferred.push(item);
+      } else {
+        nodes.push(generateTreeSync(ctx, item));
+      }
+    }
+    for (const item of deferred) {
+      nodes.push(generateTreeSync(ctx, item));
     }
-  } else if (Array.isArray(current)) {
-    if (insertRef(ctx, current)) {
-      for (const value of current) {
-        await lookupRefsAsync(ctx, value);
+    return [4 /* Set */, nodes, id];
+  }
+  if (constructorCheck(current, Map)) {
+    const nodes = [];
+    const deferred = [];
+    for (const [key, value] of current.entries()) {
+      if (isIterable(key) || isIterable(value)) {
+        deferred.push([key, value]);
+      } else {
+        const keyNode = generateTreeSync(ctx, key);
+        const valueNode = generateTreeSync(ctx, value);
+        nodes.push([keyNode, valueNode]);
       }
     }
-  } else if (constructorCheck(current, Set)) {
-    if (insertRef(ctx, current)) {
-      for (const item of current.keys()) {
-        await lookupRefsAsync(ctx, item);
+    for (const [key, value] of deferred) {
+      const keyNode = generateTreeSync(ctx, key);
+      const valueNode = generateTreeSync(ctx, value);
+      nodes.push([keyNode, valueNode]);
+    }
+    return [5 /* Map */, nodes, id];
+  }
+  if (Array.isArray(current)) {
+    const nodes = new Array(current.length);
+    const deferred = new Array(current.length);
+    for (const key in current) {
+      const item = current[key];
+      if (isIterable(item)) {
+        deferred[key] = item;
+      } else {
+        nodes[key] = generateTreeSync(ctx, item);
       }
     }
-  } 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 (const key in deferred) {
+      nodes[key] = generateTreeSync(ctx, deferred[key]);
+    }
+    return [6 /* Array */, nodes, id];
+  }
+  if (current instanceof AggregateError) {
+    const options = getErrorOptions(current);
+    return [11 /* AggregateError */, {
+      message: current.message,
+      options: options ? generateTreeSync(ctx, options) : void 0,
+      cause: "cause" in current ? generateTreeSync(ctx, { cause: current.cause }) : void 0,
+      errors: generateTreeSync(ctx, current.errors)
+    }, id];
+  }
+  if (current instanceof Error) {
+    const options = getErrorOptions(current);
+    return [10 /* Error */, {
+      constructor: getErrorConstructor(current),
+      message: current.message,
+      options: options ? generateTreeSync(ctx, options) : void 0,
+      cause: "cause" in current ? generateTreeSync(ctx, { cause: current.cause }) : void 0
+    }, id];
+  }
+  if (isIterable(current)) {
+    const options = getIterableOptions(current);
+    return [12 /* Iterable */, {
+      // Parse options first before the items
+      options: options ? generateTreeSync(ctx, options) : void 0,
+      items: generateTreeSync(ctx, Array.from(current))
+    }, id];
+  }
+  const empty = current.constructor == null;
+  if (current.constructor === Object || empty) {
+    const nodes = {};
+    const deferred = {};
+    for (const [key, item] of Object.entries(current)) {
+      if (isIterable(item)) {
+        deferred[key] = item;
+      } else {
+        nodes[key] = generateTreeSync(ctx, item);
       }
     }
-  } else if ((current.constructor === Object || current.constructor == null) && insertRef(ctx, current)) {
-    for (const value of Object.values(current)) {
-      await lookupRefsAsync(ctx, value);
+    for (const [key, item] of Object.entries(deferred)) {
+      nodes[key] = generateTreeSync(ctx, item);
     }
+    return [
+      empty ? 8 /* NullConstructor */ : 7 /* Object */,
+      nodes,
+      id
+    ];
   }
+  throw new Error("Unsupported value");
 }
-async function traverseAsync(ctx, current) {
+async function generateTreeAsync(ctx, current) {
   if (isPrimitive(current)) {
-    return serializePrimitive(current);
+    return [0 /* Primitive */, 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;
+  const id = generateRef(ctx, current);
+  if (Array.isArray(id)) {
+    return id;
   }
-  function processRef(value) {
-    if (refResult != null) {
-      return assignRef(ctx, refResult, value);
-    }
-    return value;
+  const semiPrimitive = generateSemiPrimitiveValue(current, id);
+  if (semiPrimitive) {
+    return semiPrimitive;
   }
   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})`;
-      } else {
-        result = `Promise.resolve(${await traverseAsync(ctx, value)})`;
-      }
-      ctx.stack.delete(current);
-      return processRef(result);
-    });
+    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));
-        }
+    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 (const item of deferred) {
+      nodes.push(await generateTreeAsync(ctx, item));
+    }
+    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}]`);
-        }
+    const nodes = [];
+    const deferred = [];
+    for (const [key, value] of current.entries()) {
+      if (isIterable(key) || isIterable(value)) {
+        deferred.push([key, value]);
+      } else {
+        const keyNode = await generateTreeAsync(ctx, key);
+        const valueNode = await generateTreeAsync(ctx, value);
+        nodes.push([keyNode, valueNode]);
       }
-      ctx.stack.delete(current);
-      return processRef(values.length ? `new Map([${join(values, ",")}])` : EMPTY_MAP);
     }
-    return EMPTY_MAP;
+    for (const [key, value] of deferred) {
+      const keyNode = await generateTreeAsync(ctx, key);
+      const valueNode = await generateTreeAsync(ctx, value);
+      nodes.push([keyNode, valueNode]);
+    }
+    return [5 /* Map */, nodes, 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 += ",";
-            }
-          }
-        } else {
-          values += ",";
-        }
+    const nodes = new Array(current.length);
+    const deferred = new Array(current.length);
+    for (const key in current) {
+      const item = current[key];
+      if (isIterable(item)) {
+        deferred[key] = item;
+      } else {
+        nodes[key] = await generateTreeAsync(ctx, item);
       }
-      ctx.stack.delete(current);
-      return processRef(`[${values}]`);
     }
-    return EMPTY_ARRAY;
+    for (const key in deferred) {
+      nodes[key] = await generateTreeAsync(ctx, deferred[key]);
+    }
+    return [6 /* Array */, nodes, id];
+  }
+  if (current instanceof AggregateError) {
+    const options = getErrorOptions(current);
+    return [11 /* AggregateError */, {
+      message: current.message,
+      options: options ? generateTreeSync(ctx, options) : void 0,
+      cause: "cause" in current ? await generateTreeAsync(ctx, { cause: current.cause }) : void 0,
+      errors: await generateTreeAsync(ctx, current.errors)
+    }, id];
+  }
+  if (current instanceof Error) {
+    const options = getErrorOptions(current);
+    return [10 /* Error */, {
+      constructor: getErrorConstructor(current),
+      message: current.message,
+      options: options ? await generateTreeAsync(ctx, options) : void 0,
+      cause: "cause" in current ? await generateTreeAsync(ctx, { cause: current.cause }) : void 0
+    }, id];
+  }
+  if (isIterable(current)) {
+    const options = getIterableOptions(current);
+    return [12 /* Iterable */, {
+      options: options ? await generateTreeAsync(ctx, options) : void 0,
+      items: 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)) {
-      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)) {
-            createObjectIdentifierAssign(ctx, ref, key, refParam);
-          } else {
-            createObjectComputedAssign(ctx, ref, key, refParam);
-          }
-        } else {
-          const valueResult = await traverseAsync(ctx, value2);
-          values.push(`${key}:${valueResult}`);
-        }
-      } else if (ctx.stack.has(value2)) {
-        const refParam = getRefParam(ctx, createRef(ctx, value2));
-        createObjectComputedAssign(ctx, getCurrentRef(), quote(key), refParam);
+    const nodes = {};
+    const deferred = {};
+    for (const [key, item] of Object.entries(current)) {
+      if (isIterable(item)) {
+        deferred[key] = item;
       } else {
-        const valueResult = await traverseAsync(ctx, value2);
-        values.push(`${quote(key)}:${valueResult}`);
+        nodes[key] = await generateTreeAsync(ctx, item);
       }
     }
-    ctx.stack.delete(current);
-    const value = `{${join(values, ",")}}`;
-    if (empty) {
-      return processRef(`Object.assign(Object.create(null),${value})`);
+    for (const [key, item] of Object.entries(deferred)) {
+      nodes[key] = await generateTreeAsync(ctx, item);
     }
-    return processRef(value);
+    return [
+      empty ? 8 /* NullConstructor */ : 7 /* Object */,
+      nodes,
+      id
+    ];
   }
-  throw new Error("Unserializable value");
+  throw new Error("Unsupported value");
 }
-
-// src/sync.ts
-function lookupRefs(ctx, current) {
-  if (isPrimitive(current)) {
-    return;
-  }
-  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);
+function serializeTree(ctx, [type, value, id]) {
+  switch (type) {
+    case 0 /* Primitive */:
+      return serializePrimitive(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 */: {
+      const values = [...value.array].map(serializePrimitive).join(",");
+      let args = `[${values}]`;
+      if (value.array.byteOffset !== 0) {
+        args += `,${value.array.byteOffset}`;
       }
+      return assignRef(ctx, id, `new ${value.constructor}(${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";
+      if (value.length) {
+        const values = [];
+        ctx.stack.push(id);
+        for (const item of value) {
+          if (isReferenceInStack(ctx, item)) {
+            createSetAdd(ctx, id, getRefParam(ctx, item[1]));
+          } else {
+            values.push(serializeTree(ctx, item));
+          }
+        }
+        ctx.stack.pop();
+        if (values.length) {
+          serialized += `([${values.join(",")}])`;
         }
       }
-      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";
+      if (value.length) {
+        const values = [];
+        ctx.stack.push(id);
+        for (const [key, val] of value) {
+          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));
+            values.push(`[${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 (values.length) {
+          serialized += `([${values.join(",")}])`;
         }
       }
-      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 */: {
       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, len = value.length; i < len; 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 < value.length - 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);
+    case 11 /* AggregateError */: {
+      const args = [serializeTree(ctx, value.errors), quote(value.message)];
+      if (value.cause) {
+        args.push(serializeTree(ctx, value.cause));
+      }
+      let serialized = `new AggregateError(${args.join(",")})`;
+      if (value.options) {
+        const options = serializeTree(ctx, value.options);
+        serialized = `Object.assign(${serialized},${options})`;
+      }
+      return assignRef(ctx, id, serialized);
+    }
+    case 10 /* Error */: {
+      const args = [quote(value.message)];
+      if (value.cause) {
+        args.push(serializeTree(ctx, value.cause));
+      }
+      let serialized = `new ${value.constructor}(${args.join(",")})`;
+      if (value.options) {
+        const options = serializeTree(ctx, value.options);
+        serialized = `Object.assign(${serialized},${options})`;
+      }
+      return assignRef(ctx, id, serialized);
+    }
+    case 12 /* Iterable */: {
+      const parent = ctx.stack;
+      ctx.stack = [];
+      const values = serializeTree(ctx, value.items);
+      ctx.stack = parent;
+      let serialized = `{[Symbol.iterator]:()=>${values}.values()}`;
+      if (value.options) {
+        ctx.stack.push(id);
+        const options = serializeTree(ctx, value.options);
+        ctx.stack.pop();
+        serialized = `Object.assign(${serialized},${options})`;
+      }
+      return assignRef(ctx, id, serialized);
+    }
+    case 8 /* NullConstructor */:
+    case 7 /* Object */: {
+      const values = [];
+      ctx.stack.push(id);
+      for (const [key, val] of Object.entries(value)) {
+        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, id, key, refParam);
+            } else {
+              createObjectIdentifierAssign(ctx, id, key, refParam);
+            }
           } else {
-            createObjectIdentifierAssign(ctx, ref, key, refParam);
+            values.push(`${key}:${serializeTree(ctx, val)}`);
           }
+        } else if (isReferenceInStack(ctx, val)) {
+          const refParam = getRefParam(ctx, val[1]);
+          createObjectComputedAssign(ctx, id, quote(key), refParam);
         } else {
-          values.push(`${key}:${traverseSync(ctx, value2)}`);
+          values.push(`${quote(key)}:${serializeTree(ctx, val)}`);
         }
-      } else if (ctx.stack.has(value2)) {
-        const refParam = getRefParam(ctx, createRef(ctx, value2));
-        createObjectComputedAssign(ctx, getCurrentRef(), quote(key), refParam);
-      } else {
-        values.push(`${quote(key)}:${traverseSync(ctx, value2)}`);
       }
-    });
-    ctx.stack.delete(current);
-    const value = `{${join(values, ",")}}`;
-    if (empty) {
-      return processRef(`Object.assign(Object.create(null),${value})`);
+      ctx.stack.pop();
+      let serialized = `{${values.join(",")}}`;
+      if (type === 8 /* NullConstructor */) {
+        serialized = `Object.assign(Object.create(null),${serialized})`;
+      }
+      return assignRef(ctx, id, serialized);
     }
-    return processRef(value);
+    default:
+      throw new Error("Unsupported type");
   }
-  throw new Error("Unserializable value");
 }
 
 // src/index.ts
@@ -597,7 +804,7 @@ 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];
+    const params = ctx.vars.length > 1 ? `(${ctx.vars.join(",")})` : ctx.vars[0];
     if (result.startsWith(`${index}=`)) {
       return `(${params}=>(${result},${patches}${index}))()`;
     }
@@ -613,16 +820,8 @@ function serialize(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");
-  }
+  const tree = generateTreeSync(ctx, source);
+  const result = serializeTree(ctx, tree);
   return finalize(ctx, source, result);
 }
 async function serializeAsync(source) {
@@ -630,16 +829,8 @@ async function serializeAsync(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");
-  }
+  const tree = await generateTreeAsync(ctx, source);
+  const result = serializeTree(ctx, tree);
   return finalize(ctx, source, result);
 }
 function deserialize(source) {