seroval 0.1.0 → 0.2.0

package/dist/esm/development/index.mjs

@@ -34,73 +34,26 @@ function getIdentifier(index) {
   return ref;
 }
 
-// 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;
-    }
-    result += str.slice(lastPos, i) + replacement;
-    lastPos = i + 1;
-  }
-  if (lastPos === 0) {
-    result = str;
-  } else {
-    result += str.slice(lastPos);
-  }
-  return `"${result}"`;
-}
-
-// src/index.ts
+// src/context.ts
 var EMPTY_SET = "new Set";
 var EMPTY_MAP = "new Map";
 var EMPTY_ARRAY = "[]";
-var REF_COUNT = /* @__PURE__ */ new Map();
-var STACK = /* @__PURE__ */ new Set();
-var REFS = /* @__PURE__ */ new Map();
-var ASSIGNED_REFS = /* @__PURE__ */ new Set();
-var VARS = [];
-var ASSIGNMENTS = [];
-var MAP_SETS = [];
-var SET_ADDS = [];
-function reset() {
-  ASSIGNMENTS = [];
-  MAP_SETS = [];
-  SET_ADDS = [];
-  VARS = [];
-  REF_COUNT.clear();
-  REFS.clear();
-  ASSIGNED_REFS.clear();
+function createSerializationContext() {
+  return {
+    refCount: /* @__PURE__ */ new Map(),
+    stack: /* @__PURE__ */ new Set(),
+    refs: /* @__PURE__ */ new Map(),
+    assignedRefs: /* @__PURE__ */ new Set(),
+    vars: [],
+    assignments: [],
+    mapSets: [],
+    setAdds: []
+  };
 }
-function resolveAssignments() {
-  if (ASSIGNMENTS.length) {
+function resolveAssignments(ctx) {
+  if (ctx.assignments.length) {
     const result = {};
-    forEach(ASSIGNMENTS, ([source, value]) => {
+    forEach(ctx.assignments, ([source, value]) => {
       if (value in result) {
         result[value] = `${source}=${result[value]}`;
       } else {
@@ -111,10 +64,10 @@ function resolveAssignments() {
   }
   return "";
 }
-function resolveMapSets() {
-  if (MAP_SETS.length) {
+function resolveMapSets(ctx) {
+  if (ctx.mapSets.length) {
     const result = {};
-    forEach(MAP_SETS, ([source, key, value]) => {
+    forEach(ctx.mapSets, ([source, key, value]) => {
       if (source in result) {
         result[source] = `${result[source]}.set(${key},${value})`;
       } else {
@@ -125,10 +78,10 @@ function resolveMapSets() {
   }
   return "";
 }
-function resolveSetAdds() {
-  if (SET_ADDS.length) {
+function resolveSetAdds(ctx) {
+  if (ctx.setAdds.length) {
     const result = {};
-    forEach(SET_ADDS, ([source, value]) => {
+    forEach(ctx.setAdds, ([source, value]) => {
       if (source in result) {
         result[source] = `${result[source]}.add(${value})`;
       } else {
@@ -139,88 +92,114 @@ function resolveSetAdds() {
   }
   return "";
 }
-function resolvePatches() {
-  return `${resolveAssignments()}${resolveMapSets()}${resolveSetAdds()}`;
+function resolvePatches(ctx) {
+  return `${resolveAssignments(ctx)}${resolveMapSets(ctx)}${resolveSetAdds(ctx)}`;
 }
-function insertRef(current) {
-  const count = REF_COUNT.get(current) || 0;
-  REF_COUNT.set(current, count + 1);
+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 isPrimitive(current) {
-  if (!current || current === true) {
-    return true;
-  }
-  const type = typeof current;
-  const classConst = current.constructor;
-  return type === "number" || type === "string" || type === "bigint" || classConst === Date || classConst === RegExp;
-}
-function lookupRefs(current) {
-  if (isPrimitive(current)) {
-    return;
-  }
-  if (Array.isArray(current)) {
-    if (insertRef(current)) {
-      forEach(current, lookupRefs);
-    }
-  } else if (constructorCheck(current, Set)) {
-    if (insertRef(current)) {
-      for (const item of current.keys()) {
-        lookupRefs(item);
-      }
-    }
-  } else if (constructorCheck(current, Map)) {
-    if (insertRef(current)) {
-      for (const [key, value] of current.entries()) {
-        lookupRefs(key);
-        lookupRefs(value);
-      }
-    }
-  } else if (current.constructor === Object && insertRef(current)) {
-    forEach(Object.values(current), lookupRefs);
-  }
-}
-function createRef(value) {
-  const current = REFS.get(value);
+function createRef(ctx, value) {
+  const current = ctx.refs.get(value);
   if (current != null) {
     return current;
   }
-  const id = REFS.size;
-  REFS.set(value, id);
+  const id = ctx.refs.size;
+  ctx.refs.set(value, id);
   return id;
 }
-function getRefParam(index) {
-  if (VARS[index]) {
-    return VARS[index];
+function getRefParam(ctx, index) {
+  if (ctx.vars[index]) {
+    return ctx.vars[index];
   }
   const result = getIdentifier(index);
-  VARS[index] = result;
+  ctx.vars[index] = result;
   return result;
 }
-function assignRef(index, value) {
-  return `${getRefParam(index)}=${value}`;
+function assignRef(ctx, index, value) {
+  return `${getRefParam(ctx, index)}=${value}`;
+}
+function createAssignment(ctx, source, value) {
+  ctx.assignments.push([source, value]);
 }
-function createAssignment(source, value) {
-  ASSIGNMENTS.push([source, value]);
+function createSetAdd(ctx, ref, value) {
+  ctx.setAdds.push([getRefParam(ctx, ref), value]);
 }
-function createSetAdd(ref, value) {
-  SET_ADDS.push([getRefParam(ref), value]);
+function createMapSet(ctx, ref, key, value) {
+  ctx.mapSets.push([getRefParam(ctx, ref), key, value]);
 }
-function createMapSet(ref, key, value) {
-  MAP_SETS.push([getRefParam(ref), key, value]);
+function createArrayAssign(ctx, ref, index, value) {
+  createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
 }
-function createArrayAssign(ref, index, value) {
-  createAssignment(`${getRefParam(ref)}[${index}]`, value);
+function createObjectIdentifierAssign(ctx, ref, key, value) {
+  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
 }
-function createObjectIdentifierAssign(ref, key, value) {
-  createAssignment(`${getRefParam(ref)}.${key}`, value);
+function createObjectComputedAssign(ctx, ref, key, value) {
+  createAssignment(ctx, `${getRefParam(ctx, ref)}[${key}]`, value);
 }
-function createObjectStringAssign(ref, key, value) {
-  createAssignment(`${getRefParam(ref)}[${quote(key)}]`, value);
+
+// src/is-primitive.ts
+function isPrimitive(current) {
+  if (!current || current === true) {
+    return true;
+  }
+  const type = typeof current;
+  const classConst = current.constructor;
+  return type === "number" || type === "string" || type === "bigint" || classConst === Date || classConst === RegExp;
 }
+
+// src/is-promise.ts
+function isPromise(obj) {
+  return !!obj && (typeof obj === "object" || typeof obj === "function") && "then" in obj && typeof obj.then === "function";
+}
+
+// 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;
+    }
+    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";
@@ -248,122 +227,294 @@ function serializePrimitive(value) {
   }
   return String(value);
 }
-function traverse(current) {
+
+// src/async.ts
+async function lookupRefsAsync(ctx, current) {
+  if (isPrimitive(current)) {
+    return;
+  }
+  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);
+      }
+    }
+  } else if (constructorCheck(current, Set)) {
+    if (insertRef(ctx, current)) {
+      for (const item of current.keys()) {
+        await lookupRefsAsync(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);
+      }
+    }
+  } else if ((current.constructor === Object || current.constructor == null) && insertRef(ctx, current)) {
+    for (const value of Object.values(current)) {
+      await lookupRefsAsync(ctx, value);
+    }
+  }
+}
+async function traverseAsync(ctx, current) {
   if (isPrimitive(current)) {
     return serializePrimitive(current);
   }
-  let refResult = REFS.get(current);
+  let refResult = ctx.refs.get(current);
   if (refResult != null) {
-    if (ASSIGNED_REFS.has(refResult)) {
-      return { referred: getRefParam(refResult) };
+    if (ctx.assignedRefs.has(refResult)) {
+      return getRefParam(ctx, refResult);
     }
-    ASSIGNED_REFS.add(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 (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);
+    });
   }
   if (constructorCheck(current, Set)) {
     if (current.size) {
       const values = [];
-      STACK.add(current);
-      for (const value2 of current.keys()) {
-        if (STACK.has(value2)) {
-          if (refResult == null) {
-            refResult = createRef(current);
-          }
-          createSetAdd(refResult, getRefParam(createRef(value2)));
+      ctx.stack.add(current);
+      for (const value of current.keys()) {
+        if (ctx.stack.has(value)) {
+          createSetAdd(ctx, getCurrentRef(), getRefParam(ctx, createRef(ctx, value)));
         } else {
-          const result = traverse(value2);
-          if (typeof result === "string") {
-            values.push(result);
-          } else {
-            values.push(result.referred);
-          }
+          values.push(await traverseAsync(ctx, value));
         }
       }
-      STACK.delete(current);
-      const value = values.length ? `new Set([${join(values, ",")}])` : EMPTY_SET;
-      if (refResult != null) {
-        return assignRef(refResult, value);
-      }
-      return value;
+      ctx.stack.delete(current);
+      return processRef(values.length ? `new Set([${join(values, ",")}])` : EMPTY_SET);
     }
     return EMPTY_SET;
   }
   if (constructorCheck(current, Map)) {
     if (current.size) {
       const values = [];
-      STACK.add(current);
-      for (const [key, value2] of current.entries()) {
-        if (STACK.has(key)) {
-          if (refResult == null) {
-            refResult = createRef(current);
+      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);
           }
-          const keyRef = getRefParam(createRef(key));
-          if (STACK.has(value2)) {
-            createMapSet(refResult, keyRef, getRefParam(createRef(value2)));
+        } 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}]`);
+        }
+      }
+      ctx.stack.delete(current);
+      return processRef(values.length ? `new Map([${join(values, ",")}])` : EMPTY_MAP);
+    }
+    return EMPTY_MAP;
+  }
+  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 {
-            const valueResult = traverse(value2);
-            if (typeof valueResult === "string") {
-              createMapSet(refResult, keyRef, valueResult);
-            } else {
-              createMapSet(refResult, keyRef, valueResult.referred);
+            values += await traverseAsync(ctx, item);
+            if (i < current.length - 1) {
+              values += ",";
             }
           }
-        } else if (STACK.has(value2)) {
-          if (refResult == null) {
-            refResult = createRef(current);
-          }
-          const valueRef = getRefParam(createRef(value2));
-          const keyResult = traverse(key);
-          if (typeof keyResult === "string") {
-            createMapSet(refResult, keyResult, valueRef);
+        } else {
+          values += ",";
+        }
+      }
+      ctx.stack.delete(current);
+      return processRef(`[${values}]`);
+    }
+    return EMPTY_ARRAY;
+  }
+  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 {
-            createMapSet(refResult, keyResult.referred, valueRef);
+            createObjectComputedAssign(ctx, ref, key, refParam);
           }
         } else {
-          const keyResult = traverse(key);
-          const valueResult = traverse(value2);
-          if (typeof keyResult === "string") {
-            if (typeof valueResult === "string") {
-              values.push(`[${keyResult},${valueResult}]`);
-            } else {
-              values.push(`[${keyResult},${valueResult.referred}]`);
-            }
+          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);
+      } else {
+        const valueResult = await traverseAsync(ctx, value2);
+        values.push(`${quote(key)}:${valueResult}`);
+      }
+    }
+    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;
+  }
+  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);
+      }
+    }
+  } else if (constructorCheck(current, Map)) {
+    if (insertRef(ctx, current)) {
+      for (const [key, value] of current.entries()) {
+        lookupRefs(ctx, key);
+        lookupRefs(ctx, value);
+      }
+    }
+  } 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));
+        }
+      }
+      ctx.stack.delete(current);
+      return processRef(values.length ? `new Set([${join(values, ",")}])` : EMPTY_SET);
+    }
+    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);
           } else {
-            if (typeof valueResult === "string") {
-              values.push(`[${keyResult.referred},${valueResult}]`);
-            } else {
-              values.push(`[${keyResult.referred},${valueResult.referred}]`);
-            }
+            createMapSet(ctx, ref, keyRef, traverseSync(ctx, value));
           }
+        } 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)}]`);
         }
       }
-      STACK.delete(current);
-      const value = values.length ? `new Map([${join(values, ",")}])` : EMPTY_MAP;
-      if (refResult != null) {
-        return assignRef(refResult, value);
-      }
-      return value;
+      ctx.stack.delete(current);
+      return processRef(values.length ? `new Map([${join(values, ",")}])` : EMPTY_MAP);
     }
     return EMPTY_MAP;
   }
   if (Array.isArray(current)) {
     if (current.length) {
       let values = "";
-      STACK.add(current);
+      ctx.stack.add(current);
       forEach(current, (item, i) => {
         if (i in current) {
-          if (STACK.has(item)) {
-            if (refResult == null) {
-              refResult = createRef(current);
-            }
-            createArrayAssign(refResult, i, getRefParam(createRef(item)));
+          if (ctx.stack.has(item)) {
+            const refParam = getRefParam(ctx, createRef(ctx, item));
+            createArrayAssign(ctx, getCurrentRef(), i, refParam);
             values += ",";
           } else {
-            const result = traverse(item);
-            if (typeof result === "string") {
-              values += result;
-            } else {
-              values += result.referred;
-            }
+            values += traverseSync(ctx, item);
             if (i < current.length - 1) {
               values += ",";
             }
@@ -372,87 +523,104 @@ function traverse(current) {
           values += ",";
         }
       });
-      STACK.delete(current);
-      const value = `[${values}]`;
-      if (refResult != null) {
-        return assignRef(refResult, value);
-      }
-      return value;
+      ctx.stack.delete(current);
+      return processRef(`[${values}]`);
     }
     return EMPTY_ARRAY;
   }
-  if (current.constructor === Object) {
+  const empty = current.constructor == null;
+  if (current.constructor === Object || empty) {
     const values = [];
-    STACK.add(current);
+    ctx.stack.add(current);
     forEach(Object.entries(current), ([key, value2]) => {
       const check = Number(key);
-      if (Number.isNaN(check) || /^([$A-Z_][0-9A-Z_$]*)$/i.test(key)) {
-        if (STACK.has(value2)) {
-          if (refResult == null) {
-            refResult = createRef(current);
-          }
-          createObjectIdentifierAssign(refResult, key, getRefParam(createRef(value2)));
-        } else {
-          const result = traverse(value2);
-          if (typeof result === "string") {
-            values.push(`${key}:${result}`);
+      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 {
-            values.push(`${key}:${result.referred}`);
+            createObjectIdentifierAssign(ctx, ref, key, refParam);
           }
-        }
-      } else if (STACK.has(value2)) {
-        if (refResult == null) {
-          refResult = createRef(current);
-        }
-        createObjectStringAssign(refResult, key, getRefParam(createRef(value2)));
-      } else {
-        const result = traverse(value2);
-        if (typeof result === "string") {
-          values.push(`${quote(key)}:${result}`);
         } else {
-          values.push(`${quote(key)}:${result.referred}`);
+          values.push(`${key}:${traverseSync(ctx, value2)}`);
         }
+      } 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)}`);
       }
     });
-    STACK.delete(current);
+    ctx.stack.delete(current);
     const value = `{${join(values, ",")}}`;
-    if (refResult != null) {
-      return assignRef(refResult, value);
+    if (empty) {
+      return processRef(`Object.assign(Object.create(null),${value})`);
     }
-    return value;
+    return processRef(value);
   }
   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}))()`;
+    }
+    return `(${params}=>(${index}=${result},${patches}${index}))()`;
+  }
+  if (source.constructor === Object) {
+    return `(${result})`;
+  }
+  return result;
+}
 function serialize(source) {
   if (isPrimitive(source)) {
     return serializePrimitive(source);
   }
-  reset();
-  lookupRefs(source);
-  for (const [key, value] of REF_COUNT.entries()) {
+  const ctx = createSerializationContext();
+  lookupRefs(ctx, source);
+  for (const [key, value] of ctx.refCount.entries()) {
     if (value > 1) {
-      createRef(key);
+      createRef(ctx, key);
     }
   }
-  const result = traverse(source);
+  const result = traverseSync(ctx, source);
   if (typeof result !== "string") {
     throw new Error("Unreachable error");
   }
-  if (VARS.length) {
-    const index = getRefParam(createRef(source));
-    const patches = resolvePatches();
-    const params = VARS.length > 1 ? `(${join(VARS, ",")})` : VARS[0];
-    if (result.startsWith(index)) {
-      return `(${params}=>(${result},${patches}${index}))()`;
+  return finalize(ctx, source, result);
+}
+async function serializeAsync(source) {
+  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);
     }
-    return `(${params}=>(${index}=${result},${patches}${index}))()`;
   }
-  if (source.constructor === Object) {
-    return `(${result})`;
+  const result = await traverseAsync(ctx, source);
+  if (typeof result !== "string") {
+    throw new Error("Unreachable error");
   }
-  return result;
+  return finalize(ctx, source, result);
+}
+function deserialize(source) {
+  return (0, eval)(source);
 }
+var src_default = serialize;
 export {
-  serialize as default
+  src_default as default,
+  deserialize,
+  serialize,
+  serializeAsync
 };
 //# sourceMappingURL=index.mjs.map