seroval 0.5.0 → 0.6.0

package/dist/cjs/development/index.cjs

@@ -22,6 +22,7 @@ var src_exports = {};
 __export(src_exports, {
   Feature: () => Feature,
   compileJSON: () => compileJSON,
+  createReference: () => createReference,
   default: () => src_default,
   deserialize: () => deserialize,
   fromJSON: () => fromJSON,
@@ -47,9 +48,10 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
   Feature2[Feature2["Symbol"] = 1024] = "Symbol";
   Feature2[Feature2["TypedArray"] = 2048] = "TypedArray";
   Feature2[Feature2["BigIntTypedArray"] = 4096] = "BigIntTypedArray";
+  Feature2[Feature2["WebAPI"] = 8192] = "WebAPI";
   return Feature2;
 })(Feature || {});
-var ALL_ENABLED = 8191;
+var ALL_ENABLED = 12287;
 
 // src/get-identifier.ts
 var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
@@ -95,35 +97,35 @@ function createSerializationContext(options) {
 function markRef(ctx, current) {
   ctx.markedRefs.add(current);
 }
-function createValidRef(ctx, index) {
-  const current = ctx.validRefs[index];
-  if (current == null) {
-    const value = ctx.refSize++;
-    ctx.validRefs[index] = value;
-    return value;
+function getRefParam(ctx, index) {
+  let actualIndex = ctx.validRefs[index];
+  if (actualIndex == null) {
+    actualIndex = ctx.refSize++;
+    ctx.validRefs[index] = actualIndex;
+  }
+  let identifier = ctx.vars[actualIndex];
+  if (identifier == null) {
+    identifier = getIdentifier(actualIndex);
+    ctx.vars[actualIndex] = identifier;
   }
-  return current;
+  return identifier;
 }
-function getRefParam(ctx, index) {
-  const actualIndex = createValidRef(ctx, index);
-  if (ctx.vars[actualIndex]) {
-    return ctx.vars[actualIndex];
+function getRootID(ctx, current) {
+  const ref = ctx.refs.get(current);
+  if (ref == null) {
+    return ctx.refs.size;
   }
-  const result = getIdentifier(actualIndex);
-  ctx.vars[actualIndex] = result;
-  return result;
+  return ref;
 }
-function createRef(ctx, current, mark) {
+function createIndexedValue(ctx, current) {
   const ref = ctx.refs.get(current);
-  if (ref != null) {
-    if (mark) {
-      markRef(ctx, ref);
-    }
-    return ref;
+  if (ref == null) {
+    const id = ctx.refs.size;
+    ctx.refs.set(current, id);
+    return id;
   }
-  const id = ctx.refs.size;
-  ctx.refs.set(current, id);
-  return id;
+  markRef(ctx, ref);
+  return ref;
 }
 
 // src/assert.ts
@@ -178,6 +180,59 @@ function invQuote(str) {
   return str.replace(/\\"/g, '"').replace(/\\\\/g, "\\").replace(/\\x3C/g, "<").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\u2028/g, "\u2028").replace(/\\u2029/g, "\u2029");
 }
 
+// src/tree/reference.ts
+var REFERENCE = /* @__PURE__ */ new Map();
+var INV_REFERENCE = /* @__PURE__ */ new Map();
+function createReference(id, value) {
+  REFERENCE.set(value, id);
+  INV_REFERENCE.set(id, value);
+  return value;
+}
+function hasReferenceID(value) {
+  return REFERENCE.has(value);
+}
+function hasReference(id) {
+  return INV_REFERENCE.has(id);
+}
+function getReferenceID(value) {
+  assert(hasReferenceID(value), "Missing reference id");
+  return REFERENCE.get(value);
+}
+function getReference(id) {
+  assert(hasReference(id), "Missing reference for id:" + id);
+  return INV_REFERENCE.get(id);
+}
+var GLOBAL_KEY = "__SEROVAL__";
+if (typeof globalThis !== void 0) {
+  Object.defineProperty(globalThis, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+} else if (typeof window !== void 0) {
+  Object.defineProperty(window, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+} else if (typeof self !== void 0) {
+  Object.defineProperty(self, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+} else if (typeof global !== void 0) {
+  Object.defineProperty(global, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+}
+
 // src/tree/symbols.ts
 var SYMBOL_STRING = {
   [0 /* AsyncIterator */]: "Symbol.asyncIterator",
@@ -235,7 +290,7 @@ var TRUE_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  n: void 0
+  f: void 0
 };
 var FALSE_NODE = {
   t: 2 /* Boolean */,
@@ -246,7 +301,7 @@ var FALSE_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  n: void 0
+  f: void 0
 };
 var UNDEFINED_NODE = {
   t: 4 /* Undefined */,
@@ -257,7 +312,7 @@ var UNDEFINED_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  n: void 0
+  f: void 0
 };
 var NULL_NODE = {
   t: 3 /* Null */,
@@ -268,7 +323,7 @@ var NULL_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  n: void 0
+  f: void 0
 };
 var NEG_ZERO_NODE = {
   t: 5 /* NegativeZero */,
@@ -279,7 +334,7 @@ var NEG_ZERO_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  n: void 0
+  f: void 0
 };
 var INFINITY_NODE = {
   t: 6 /* Infinity */,
@@ -290,7 +345,7 @@ var INFINITY_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  n: void 0
+  f: void 0
 };
 var NEG_INFINITY_NODE = {
   t: 7 /* NegativeInfinity */,
@@ -301,7 +356,7 @@ var NEG_INFINITY_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  n: void 0
+  f: void 0
 };
 var NAN_NODE = {
   t: 8 /* NaN */,
@@ -312,7 +367,7 @@ var NAN_NODE = {
   m: void 0,
   d: void 0,
   a: void 0,
-  n: void 0
+  f: void 0
 };
 function createNumberNode(value) {
   return {
@@ -324,7 +379,7 @@ function createNumberNode(value) {
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function createStringNode(value) {
@@ -337,7 +392,7 @@ function createStringNode(value) {
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function createBigIntNode(ctx, current) {
@@ -345,18 +400,18 @@ function createBigIntNode(ctx, current) {
   return {
     t: 9 /* BigInt */,
     i: void 0,
-    s: current.toString(),
+    s: "" + current,
     l: void 0,
     c: void 0,
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
-function createReferenceNode(id) {
+function createIndexedValueNode(id) {
   return {
-    t: 10 /* Reference */,
+    t: 10 /* IndexedValue */,
     i: id,
     s: void 0,
     l: void 0,
@@ -364,7 +419,7 @@ function createReferenceNode(id) {
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function createDateNode(id, current) {
@@ -376,7 +431,7 @@ function createDateNode(id, current) {
     c: void 0,
     m: void 0,
     d: void 0,
-    n: void 0,
+    f: void 0,
     a: void 0
   };
 }
@@ -390,7 +445,7 @@ function createRegExpNode(id, current) {
     m: current.flags,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function createTypedArrayNode(ctx, id, current) {
@@ -399,7 +454,7 @@ function createTypedArrayNode(ctx, id, current) {
   const len = current.length;
   const values = new Array(len);
   for (let i = 0; i < len; i++) {
-    values[i] = current[i].toString();
+    values[i] = "" + current[i];
   }
   return {
     t: 22 /* TypedArray */,
@@ -410,7 +465,7 @@ function createTypedArrayNode(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 var BIGINT_FLAG = 4096 /* BigIntTypedArray */ | 8 /* BigInt */;
@@ -423,7 +478,7 @@ function createBigIntTypedArrayNode(ctx, id, current) {
   const len = current.length;
   const values = new Array(len);
   for (let i = 0; i < len; i++) {
-    values[i] = current[i].toString();
+    values[i] = "" + current[i];
   }
   return {
     t: 23 /* BigIntTypedArray */,
@@ -434,10 +489,12 @@ function createBigIntTypedArrayNode(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
-function createWKSymbolNode(current) {
+function createWKSymbolNode(ctx, current) {
+  assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "symbol"');
+  assert(current in INV_SYMBOL_REF, "seroval only supports well-known symbols");
   return {
     t: 24 /* WKSymbol */,
     i: void 0,
@@ -447,7 +504,20 @@ function createWKSymbolNode(current) {
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
+  };
+}
+function createReferenceNode(id, ref) {
+  return {
+    t: 27 /* Reference */,
+    i: id,
+    s: quote(getReferenceID(ref)),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    f: void 0
   };
 }
 
@@ -589,6 +659,36 @@ function isValidIdentifier(name) {
   return (char === "$" || char === "_" || char >= "A" && char <= "Z" || char >= "a" && char <= "z") && IDENTIFIER_CHECK.test(name);
 }
 
+// src/tree/web-api.ts
+function createURLNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "URL"');
+  return {
+    t: 25 /* URL */,
+    i: id,
+    s: current.href,
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    f: void 0,
+    a: void 0
+  };
+}
+function createURLSearchParamsNode(ctx, id, current) {
+  assert(ctx.features & 8192 /* WebAPI */, 'Unsupported type "URLSearchParams"');
+  return {
+    t: 26 /* URLSearchParams */,
+    i: id,
+    s: current.toString(),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    f: void 0,
+    a: void 0
+  };
+}
+
 // src/tree/async.ts
 async function generateNodeList(ctx, current) {
   const size = current.length;
@@ -622,7 +722,7 @@ async function generateArrayNode(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: await generateNodeList(ctx, current),
-    n: void 0
+    f: void 0
   };
 }
 async function generateMapNode(ctx, id, current) {
@@ -658,7 +758,7 @@ async function generateMapNode(ctx, id, current) {
     m: void 0,
     d: { k: keyNodes, v: valueNodes, s: len },
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 async function generateSetNode(ctx, id, current) {
@@ -687,7 +787,7 @@ async function generateSetNode(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: nodes,
-    n: void 0
+    f: void 0
   };
 }
 async function generateProperties(ctx, properties) {
@@ -736,7 +836,7 @@ async function generateIterableNode(ctx, id, current) {
     // Parse options first before the items
     d: options ? await generateProperties(ctx, options) : void 0,
     a: await generateNodeList(ctx, array),
-    n: void 0
+    f: void 0
   };
 }
 async function generatePromiseNode(ctx, id, current) {
@@ -751,7 +851,7 @@ async function generatePromiseNode(ctx, id, current) {
     // Parse options first before the items
     d: void 0,
     a: void 0,
-    n: await parse(ctx, value)
+    f: await parse(ctx, value)
   }));
 }
 async function generateObjectNode(ctx, id, current, empty) {
@@ -770,7 +870,7 @@ async function generateObjectNode(ctx, id, current, empty) {
     m: void 0,
     d: await generateProperties(ctx, current),
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 async function generateAggregateErrorNode(ctx, id, current) {
@@ -782,10 +882,10 @@ async function generateAggregateErrorNode(ctx, id, current) {
     s: void 0,
     l: current.errors.length,
     c: void 0,
-    m: current.message,
+    m: quote(current.message),
     d: optionsNode,
     a: await generateNodeList(ctx, current.errors),
-    n: void 0
+    f: void 0
   };
 }
 async function generateErrorNode(ctx, id, current) {
@@ -797,10 +897,10 @@ async function generateErrorNode(ctx, id, current) {
     s: void 0,
     l: void 0,
     c: getErrorConstructorName(current),
-    m: current.message,
+    m: quote(current.message),
     d: optionsNode,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 async function parse(ctx, current) {
@@ -812,28 +912,32 @@ async function parse(ctx, current) {
     case "string":
       return createStringNode(current);
     case "number":
-      if (current !== current) {
-        return NAN_NODE;
-      }
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
-      }
-      if (Object.is(current, Infinity)) {
-        return INFINITY_NODE;
-      }
-      if (Object.is(current, -Infinity)) {
-        return NEG_INFINITY_NODE;
+      switch (current) {
+        case Infinity:
+          return INFINITY_NODE;
+        case -Infinity:
+          return NEG_INFINITY_NODE;
+        default:
+          if (current !== current) {
+            return NAN_NODE;
+          }
+          if (Object.is(current, -0)) {
+            return NEG_ZERO_NODE;
+          }
+          return createNumberNode(current);
       }
-      return createNumberNode(current);
     case "bigint":
       return createBigIntNode(ctx, current);
     case "object": {
       if (!current) {
         return NULL_NODE;
       }
-      const id = createRef(ctx, current, true);
+      const id = createIndexedValue(ctx, current);
       if (ctx.markedRefs.has(id)) {
-        return createReferenceNode(id);
+        return createIndexedValueNode(id);
+      }
+      if (hasReferenceID(current)) {
+        return createReferenceNode(id, current);
       }
       if (Array.isArray(current)) {
         return generateArrayNode(ctx, id, current);
@@ -897,11 +1001,18 @@ async function parse(ctx, current) {
         case TypeError:
         case URIError:
           return generateErrorNode(ctx, id, current);
+        case URL:
+          return createURLNode(ctx, id, current);
+        case URLSearchParams:
+          return createURLSearchParamsNode(ctx, id, current);
         default:
           break;
       }
-      if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-        return generateAggregateErrorNode(ctx, id, current);
+      if (current instanceof AggregateError) {
+        if (ctx.features & 1 /* AggregateError */) {
+          return generateAggregateErrorNode(ctx, id, current);
+        }
+        return generateErrorNode(ctx, id, current);
       }
       if (current instanceof Error) {
         return generateErrorNode(ctx, id, current);
@@ -918,9 +1029,22 @@ async function parse(ctx, current) {
       throw new Error("Unsupported type");
     }
     case "symbol":
-      assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "symbol"');
-      assert(current in INV_SYMBOL_REF, "seroval only supports well-known symbols");
-      return createWKSymbolNode(current);
+      if (hasReferenceID(current)) {
+        const id = createIndexedValue(ctx, current);
+        if (ctx.markedRefs.has(id)) {
+          return createIndexedValueNode(id);
+        }
+        return createReferenceNode(id, current);
+      }
+      return createWKSymbolNode(ctx, current);
+    case "function": {
+      assert(hasReferenceID(current), "Cannot serialize function without reference ID.");
+      const id = createIndexedValue(ctx, current);
+      if (ctx.markedRefs.has(id)) {
+        return createIndexedValueNode(id);
+      }
+      return createReferenceNode(id, current);
+    }
     default:
       throw new Error("Unsupported type");
   }
@@ -928,11 +1052,11 @@ async function parse(ctx, current) {
 async function parseAsync(ctx, current) {
   const result = await parse(ctx, current);
   const isObject = result.t === 16 /* Object */ || result.t === 21 /* Iterable */;
-  return [result, createRef(ctx, current, false), isObject];
+  return [result, getRootID(ctx, current), isObject];
 }
 
 // src/tree/deserialize.ts
-function assignRef(ctx, index, value) {
+function assignIndexedValue(ctx, index, value) {
   ctx.valueMap.set(index, value);
   return value;
 }
@@ -947,7 +1071,7 @@ function deserializeNodeList(ctx, node, result) {
   return result;
 }
 function deserializeArray(ctx, node) {
-  const result = assignRef(
+  const result = assignIndexedValue(
     ctx,
     node.i,
     new Array(node.l)
@@ -967,21 +1091,25 @@ function deserializeProperties(ctx, node, result) {
   return result;
 }
 function deserializeNullConstructor(ctx, node) {
-  const result = assignRef(ctx, node.i, /* @__PURE__ */ Object.create(null));
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    /* @__PURE__ */ Object.create(null)
+  );
   ctx.stack.push(node.i);
   deserializeProperties(ctx, node.d, result);
   ctx.stack.pop();
   return result;
 }
 function deserializeObject(ctx, node) {
-  const result = assignRef(ctx, node.i, {});
+  const result = assignIndexedValue(ctx, node.i, {});
   ctx.stack.push(node.i);
   deserializeProperties(ctx, node.d, result);
   ctx.stack.pop();
   return result;
 }
 function deserializeSet(ctx, node) {
-  const result = assignRef(ctx, node.i, /* @__PURE__ */ new Set());
+  const result = assignIndexedValue(ctx, node.i, /* @__PURE__ */ new Set());
   ctx.stack.push(node.i);
   for (let i = 0, len = node.a.length; i < len; i++) {
     result.add(deserializeTree(ctx, node.a[i]));
@@ -990,7 +1118,7 @@ function deserializeSet(ctx, node) {
   return result;
 }
 function deserializeMap(ctx, node) {
-  const result = assignRef(
+  const result = assignIndexedValue(
     ctx,
     node.i,
     /* @__PURE__ */ new Map()
@@ -1015,7 +1143,7 @@ function deserializeDictionary(ctx, node, result) {
   return result;
 }
 function deserializeAggregateError(ctx, node) {
-  const result = assignRef(ctx, node.i, new AggregateError([], node.m));
+  const result = assignIndexedValue(ctx, node.i, new AggregateError([], invQuote(node.m)));
   ctx.stack.push(node.i);
   result.errors = deserializeNodeList(ctx, node, new Array(node.l));
   ctx.stack.pop();
@@ -1023,7 +1151,7 @@ function deserializeAggregateError(ctx, node) {
 }
 function deserializeError(ctx, node) {
   const ErrorConstructor = getErrorConstructor(node.c);
-  const result = assignRef(ctx, node.i, new ErrorConstructor(node.m));
+  const result = assignIndexedValue(ctx, node.i, new ErrorConstructor(invQuote(node.m)));
   return deserializeDictionary(ctx, node, result);
 }
 function createDeferred() {
@@ -1039,14 +1167,14 @@ function createDeferred() {
 }
 function deserializePromise(ctx, node) {
   const deferred = createDeferred();
-  const result = assignRef(ctx, node.i, deferred.promise);
-  deferred.resolve(deserializeTree(ctx, node.n));
+  const result = assignIndexedValue(ctx, node.i, deferred.promise);
+  deferred.resolve(deserializeTree(ctx, node.f));
   return result;
 }
 function deserializeTypedArray(ctx, node) {
   const TypedArray = getTypedArrayConstructor(node.c);
   const dummy = new TypedArray();
-  const result = assignRef(ctx, node.i, new TypedArray(
+  const result = assignIndexedValue(ctx, node.i, new TypedArray(
     dummy.buffer,
     node.l
   ));
@@ -1058,7 +1186,7 @@ function deserializeTypedArray(ctx, node) {
 function deserializeIterable(ctx, node) {
   const values = [];
   deserializeNodeList(ctx, node, values);
-  const result = assignRef(ctx, node.i, {
+  const result = assignIndexedValue(ctx, node.i, {
     [Symbol.iterator]: () => values.values()
   });
   return deserializeDictionary(ctx, node, result);
@@ -1084,7 +1212,7 @@ function deserializeTree(ctx, node) {
       return NaN;
     case 9 /* BigInt */:
       return BigInt(node.s);
-    case 10 /* Reference */:
+    case 10 /* IndexedValue */:
       return ctx.valueMap.get(node.i);
     case 15 /* Array */:
       return deserializeArray(ctx, node);
@@ -1093,9 +1221,9 @@ function deserializeTree(ctx, node) {
     case 17 /* NullConstructor */:
       return deserializeNullConstructor(ctx, node);
     case 11 /* Date */:
-      return assignRef(ctx, node.i, new Date(node.s));
+      return assignIndexedValue(ctx, node.i, new Date(node.s));
     case 12 /* RegExp */:
-      return assignRef(ctx, node.i, new RegExp(node.c, node.m));
+      return assignIndexedValue(ctx, node.i, new RegExp(node.c, node.m));
     case 13 /* Set */:
       return deserializeSet(ctx, node);
     case 14 /* Map */:
@@ -1113,6 +1241,12 @@ function deserializeTree(ctx, node) {
       return deserializePromise(ctx, node);
     case 24 /* WKSymbol */:
       return SYMBOL_REF[node.s];
+    case 25 /* URL */:
+      return assignIndexedValue(ctx, node.i, new URL(node.s));
+    case 26 /* URLSearchParams */:
+      return assignIndexedValue(ctx, node.i, new URLSearchParams(node.s));
+    case 27 /* Reference */:
+      return assignIndexedValue(ctx, node.i, getReference(invQuote(node.s)));
     default:
       throw new Error("Unsupported type");
   }
@@ -1139,30 +1273,48 @@ function mergeAssignments(assignments) {
   for (let i = 1, len = assignments.length; i < len; i++) {
     item = assignments[i];
     if (item.t === prev.t) {
-      if (item.t === "index" && item.v === prev.v) {
-        current = {
-          t: "index",
-          s: item.s,
-          k: void 0,
-          v: getAssignmentExpression(current)
-        };
-      } else if (item.t === "map" && item.s === prev.s) {
-        current = {
-          t: "map",
-          s: getAssignmentExpression(current),
-          k: item.k,
-          v: item.v
-        };
-      } else if (item.t === "set" && item.s === prev.s) {
-        current = {
-          t: "set",
-          s: getAssignmentExpression(current),
-          k: void 0,
-          v: item.v
-        };
-      } else {
-        newAssignments.push(current);
-        current = item;
+      switch (item.t) {
+        case "index":
+          if (item.v === prev.v) {
+            current = {
+              t: "index",
+              s: item.s,
+              k: void 0,
+              v: getAssignmentExpression(current)
+            };
+          } else {
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        case "map":
+          if (item.s === prev.s) {
+            current = {
+              t: "map",
+              s: getAssignmentExpression(current),
+              k: item.k,
+              v: item.v
+            };
+          } else {
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        case "set":
+          if (item.s === prev.s) {
+            current = {
+              t: "set",
+              s: getAssignmentExpression(current),
+              k: void 0,
+              v: item.v
+            };
+          } else {
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        default:
+          break;
       }
     } else {
       newAssignments.push(current);
@@ -1215,20 +1367,20 @@ function createMapSet(ctx, ref, key, value) {
 }
 function createArrayAssign(ctx, ref, index, value) {
   markRef(ctx, ref);
-  createAssignment(ctx, getRefParam(ctx, ref) + "[" + index.toString() + "]", value);
+  createAssignment(ctx, getRefParam(ctx, ref) + "[" + index + "]", value);
 }
 function createObjectAssign(ctx, ref, key, value) {
   markRef(ctx, ref);
   createAssignment(ctx, getRefParam(ctx, ref) + "." + key, value);
 }
-function assignRef2(ctx, index, value) {
+function assignIndexedValue2(ctx, index, value) {
   if (ctx.markedRefs.has(index)) {
     return getRefParam(ctx, index) + "=" + value;
   }
   return value;
 }
-function isReferenceInStack(ctx, node) {
-  return node.t === 10 /* Reference */ && ctx.stack.includes(node.i);
+function isIndexedValueInStack(ctx, node) {
+  return node.t === 10 /* IndexedValue */ && ctx.stack.includes(node.i);
 }
 function serializeNodeList(ctx, node) {
   const size = node.l;
@@ -1241,7 +1393,7 @@ function serializeNodeList(ctx, node) {
     }
     item = node.a[i];
     if (item) {
-      if (isReferenceInStack(ctx, item)) {
+      if (isIndexedValueInStack(ctx, item)) {
         createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
         isHoley = true;
       } else {
@@ -1252,16 +1404,13 @@ function serializeNodeList(ctx, node) {
       isHoley = true;
     }
   }
-  if (isHoley) {
-    values += ",";
-  }
-  return "[" + values + "]";
+  return "[" + values + (isHoley ? ",]" : "]");
 }
 function serializeArray(ctx, node) {
   ctx.stack.push(node.i);
   const result = serializeNodeList(ctx, node);
   ctx.stack.pop();
-  return assignRef2(ctx, node.i, result);
+  return assignIndexedValue2(ctx, node.i, result);
 }
 function serializeProperties(ctx, sourceID, node) {
   if (node.s === 0) {
@@ -1280,7 +1429,7 @@ function serializeProperties(ctx, sourceID, node) {
     val = node.v[i];
     check = Number(key);
     isIdentifier = check >= 0 || isValidIdentifier(key);
-    if (isReferenceInStack(ctx, val)) {
+    if (isIndexedValueInStack(ctx, val)) {
       refParam = getRefParam(ctx, val.i);
       if (isIdentifier && Number.isNaN(check)) {
         createObjectAssign(ctx, sourceID, key, refParam);
@@ -1288,11 +1437,7 @@ function serializeProperties(ctx, sourceID, node) {
         createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + quote(key) + '"', refParam);
       }
     } else {
-      if (hasPrev) {
-        result += ",";
-      }
-      result += isIdentifier ? key : '"' + quote(key) + '"';
-      result += ":" + serializeTree(ctx, val);
+      result += (hasPrev ? "," : "") + (isIdentifier ? key : '"' + quote(key) + '"') + ":" + serializeTree(ctx, val);
       hasPrev = true;
     }
   }
@@ -1343,18 +1488,17 @@ function serializeDictionary(ctx, i, d, init) {
       markRef(ctx, i);
       const assignments = serializeAssignments(ctx, i, d);
       if (assignments) {
-        const ref = getRefParam(ctx, i);
-        return "(" + assignRef2(ctx, i, init) + "," + assignments + ref + ")";
+        return "(" + assignIndexedValue2(ctx, i, init) + "," + assignments + getRefParam(ctx, i) + ")";
       }
     }
   }
-  return assignRef2(ctx, i, init);
+  return assignIndexedValue2(ctx, i, init);
 }
 function serializeNullConstructor(ctx, node) {
   return serializeDictionary(ctx, node.i, node.d, "Object.create(null)");
 }
 function serializeObject(ctx, node) {
-  return assignRef2(ctx, node.i, serializeProperties(ctx, node.i, node.d));
+  return assignIndexedValue2(ctx, node.i, serializeProperties(ctx, node.i, node.d));
 }
 function serializeSet(ctx, node) {
   let serialized = "new Set";
@@ -1366,13 +1510,10 @@ function serializeSet(ctx, node) {
     let hasPrev = false;
     for (let i = 0; i < size; i++) {
       item = node.a[i];
-      if (isReferenceInStack(ctx, item)) {
+      if (isIndexedValueInStack(ctx, item)) {
         createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
       } else {
-        if (hasPrev) {
-          result += ",";
-        }
-        result += serializeTree(ctx, item);
+        result += (hasPrev ? "," : "") + serializeTree(ctx, item);
         hasPrev = true;
       }
     }
@@ -1381,7 +1522,7 @@ function serializeSet(ctx, node) {
       serialized += "([" + result + "])";
     }
   }
-  return assignRef2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, node.i, serialized);
 }
 function serializeMap(ctx, node) {
   let serialized = "new Map";
@@ -1397,9 +1538,9 @@ function serializeMap(ctx, node) {
     for (let i = 0; i < node.d.s; i++) {
       key = node.d.k[i];
       val = node.d.v[i];
-      if (isReferenceInStack(ctx, key)) {
+      if (isIndexedValueInStack(ctx, key)) {
         keyRef = getRefParam(ctx, key.i);
-        if (isReferenceInStack(ctx, val)) {
+        if (isIndexedValueInStack(ctx, val)) {
           valueRef = getRefParam(ctx, val.i);
           createMapSet(ctx, node.i, keyRef, valueRef);
         } else {
@@ -1408,17 +1549,14 @@ function serializeMap(ctx, node) {
           createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
           ctx.stack = parent;
         }
-      } else if (isReferenceInStack(ctx, val)) {
+      } else if (isIndexedValueInStack(ctx, val)) {
         valueRef = getRefParam(ctx, val.i);
         parent = ctx.stack;
         ctx.stack = [];
         createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
         ctx.stack = parent;
       } else {
-        if (hasPrev) {
-          result += ",";
-        }
-        result += "[" + serializeTree(ctx, key) + "," + serializeTree(ctx, val) + "]";
+        result += (hasPrev ? ",[" : "[") + serializeTree(ctx, key) + "," + serializeTree(ctx, val) + "]";
         hasPrev = true;
       }
     }
@@ -1427,7 +1565,7 @@ function serializeMap(ctx, node) {
       serialized += "([" + result + "])";
     }
   }
-  return assignRef2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, node.i, serialized);
 }
 function serializeAggregateError(ctx, node) {
   ctx.stack.push(node.i);
@@ -1441,8 +1579,8 @@ function serializeError(ctx, node) {
 }
 function serializePromise(ctx, node) {
   let serialized;
-  if (isReferenceInStack(ctx, node.n)) {
-    const ref = getRefParam(ctx, node.n.i);
+  if (isIndexedValueInStack(ctx, node.f)) {
+    const ref = getRefParam(ctx, node.f.i);
     if (ctx.features & 4 /* ArrowFunction */) {
       serialized = "Promise.resolve().then(()=>" + ref + ")";
     } else {
@@ -1450,28 +1588,20 @@ function serializePromise(ctx, node) {
     }
   } else {
     ctx.stack.push(node.i);
-    const result = serializeTree(ctx, node.n);
+    const result = serializeTree(ctx, node.f);
     ctx.stack.pop();
     serialized = "Promise.resolve(" + result + ")";
   }
-  return assignRef2(ctx, node.i, serialized);
+  return assignIndexedValue2(ctx, node.i, serialized);
 }
 function serializeTypedArray(ctx, node) {
   let result = "";
+  const isBigInt = node.t === 23 /* BigIntTypedArray */;
   for (let i = 0, len = node.s.length; i < len; i++) {
-    if (i !== 0) {
-      result += ",";
-    }
-    result += node.s[i];
-    if (node.t === 23 /* BigIntTypedArray */) {
-      result += "n";
-    }
+    result += (i !== 0 ? "," : "") + node.s[i] + (isBigInt ? "n" : "");
   }
-  let args = "[" + result + "]";
-  if (node.l !== 0) {
-    args += "," + node.l.toString();
-  }
-  return assignRef2(ctx, node.i, "new " + node.c + "(" + args + ")");
+  const args = "[" + result + "]" + (node.l !== 0 ? "," + node.l : "");
+  return assignIndexedValue2(ctx, node.i, "new " + node.c + "(" + args + ")");
 }
 function serializeIterable(ctx, node) {
   const parent = ctx.stack;
@@ -1496,13 +1626,13 @@ function serializeIterable(ctx, node) {
 function serializeTree(ctx, node) {
   switch (node.t) {
     case 0 /* Number */:
-      return String(node.s);
+      return "" + node.s;
     case 1 /* String */:
       return '"' + node.s + '"';
     case 2 /* Boolean */:
       return node.s ? "!0" : "!1";
     case 4 /* Undefined */:
-      return "undefined";
+      return "void 0";
     case 3 /* Null */:
       return "null";
     case 5 /* NegativeZero */:
@@ -1515,7 +1645,7 @@ function serializeTree(ctx, node) {
       return "NaN";
     case 9 /* BigInt */:
       return node.s + "n";
-    case 10 /* Reference */:
+    case 10 /* IndexedValue */:
       return getRefParam(ctx, node.i);
     case 15 /* Array */:
       return serializeArray(ctx, node);
@@ -1524,9 +1654,9 @@ function serializeTree(ctx, node) {
     case 17 /* NullConstructor */:
       return serializeNullConstructor(ctx, node);
     case 11 /* Date */:
-      return assignRef2(ctx, node.i, 'new Date("' + node.s + '")');
+      return assignIndexedValue2(ctx, node.i, 'new Date("' + node.s + '")');
     case 12 /* RegExp */:
-      return assignRef2(ctx, node.i, "/" + node.c + "/" + node.m);
+      return assignIndexedValue2(ctx, node.i, "/" + node.c + "/" + node.m);
     case 13 /* Set */:
       return serializeSet(ctx, node);
     case 14 /* Map */:
@@ -1544,6 +1674,12 @@ function serializeTree(ctx, node) {
       return serializePromise(ctx, node);
     case 24 /* WKSymbol */:
       return SYMBOL_STRING[node.s];
+    case 25 /* URL */:
+      return assignIndexedValue2(ctx, node.i, 'new URL("' + node.s + '")');
+    case 26 /* URLSearchParams */:
+      return assignIndexedValue2(ctx, node.i, node.s ? 'new URLSearchParams("' + node.s + '")' : "new URLSearchParams");
+    case 27 /* Reference */:
+      return assignIndexedValue2(ctx, node.i, GLOBAL_KEY + '.get("' + node.s + '")');
     default:
       throw new Error("Unsupported type");
   }
@@ -1582,7 +1718,7 @@ function generateArrayNode2(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: generateNodeList2(ctx, current),
-    n: void 0
+    f: void 0
   };
 }
 function generateMapNode2(ctx, id, current) {
@@ -1618,7 +1754,7 @@ function generateMapNode2(ctx, id, current) {
     m: void 0,
     d: { k: keyNodes, v: valueNodes, s: len },
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function generateSetNode2(ctx, id, current) {
@@ -1647,7 +1783,7 @@ function generateSetNode2(ctx, id, current) {
     m: void 0,
     d: void 0,
     a: nodes,
-    n: void 0
+    f: void 0
   };
 }
 function generateProperties2(ctx, properties) {
@@ -1696,7 +1832,7 @@ function generateIterableNode2(ctx, id, current) {
     // Parse options first before the items
     d: options ? generateProperties2(ctx, options) : void 0,
     a: generateNodeList2(ctx, array),
-    n: void 0
+    f: void 0
   };
 }
 function generateObjectNode2(ctx, id, current, empty) {
@@ -1712,7 +1848,7 @@ function generateObjectNode2(ctx, id, current, empty) {
     m: void 0,
     d: generateProperties2(ctx, current),
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function generateAggregateErrorNode2(ctx, id, current) {
@@ -1724,10 +1860,10 @@ function generateAggregateErrorNode2(ctx, id, current) {
     s: void 0,
     l: current.errors.length,
     c: void 0,
-    m: current.message,
+    m: quote(current.message),
     d: optionsNode,
     a: generateNodeList2(ctx, current.errors),
-    n: void 0
+    f: void 0
   };
 }
 function generateErrorNode2(ctx, id, current) {
@@ -1739,10 +1875,10 @@ function generateErrorNode2(ctx, id, current) {
     s: void 0,
     l: void 0,
     c: getErrorConstructorName(current),
-    m: current.message,
+    m: quote(current.message),
     d: optionsNode,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function parse2(ctx, current) {
@@ -1754,28 +1890,32 @@ function parse2(ctx, current) {
     case "string":
       return createStringNode(current);
     case "number":
-      if (current !== current) {
-        return NAN_NODE;
-      }
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
-      }
-      if (Object.is(current, Infinity)) {
-        return INFINITY_NODE;
-      }
-      if (Object.is(current, -Infinity)) {
-        return NEG_INFINITY_NODE;
+      switch (current) {
+        case Infinity:
+          return INFINITY_NODE;
+        case -Infinity:
+          return NEG_INFINITY_NODE;
+        default:
+          if (current !== current) {
+            return NAN_NODE;
+          }
+          if (Object.is(current, -0)) {
+            return NEG_ZERO_NODE;
+          }
+          return createNumberNode(current);
       }
-      return createNumberNode(current);
     case "bigint":
       return createBigIntNode(ctx, current);
     case "object": {
       if (!current) {
         return NULL_NODE;
       }
-      const id = createRef(ctx, current, true);
+      const id = createIndexedValue(ctx, current);
       if (ctx.markedRefs.has(id)) {
-        return createReferenceNode(id);
+        return createIndexedValueNode(id);
+      }
+      if (hasReferenceID(current)) {
+        return createReferenceNode(id, current);
       }
       if (Array.isArray(current)) {
         return generateArrayNode2(ctx, id, current);
@@ -1803,9 +1943,19 @@ function parse2(ctx, current) {
         case Set:
           return generateSetNode2(ctx, id, current);
         case Object:
-          return generateObjectNode2(ctx, id, current, false);
+          return generateObjectNode2(
+            ctx,
+            id,
+            current,
+            false
+          );
         case void 0:
-          return generateObjectNode2(ctx, id, current, true);
+          return generateObjectNode2(
+            ctx,
+            id,
+            current,
+            true
+          );
         case AggregateError:
           if (ctx.features & 1 /* AggregateError */) {
             return generateAggregateErrorNode2(ctx, id, current);
@@ -1819,11 +1969,18 @@ function parse2(ctx, current) {
         case TypeError:
         case URIError:
           return generateErrorNode2(ctx, id, current);
+        case URL:
+          return createURLNode(ctx, id, current);
+        case URLSearchParams:
+          return createURLSearchParamsNode(ctx, id, current);
         default:
           break;
       }
-      if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-        return generateAggregateErrorNode2(ctx, id, current);
+      if (current instanceof AggregateError) {
+        if (ctx.features & 1 /* AggregateError */) {
+          return generateAggregateErrorNode2(ctx, id, current);
+        }
+        return generateErrorNode2(ctx, id, current);
       }
       if (current instanceof Error) {
         return generateErrorNode2(ctx, id, current);
@@ -1834,9 +1991,22 @@ function parse2(ctx, current) {
       throw new Error("Unsupported type");
     }
     case "symbol":
-      assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "symbol"');
-      assert(current in INV_SYMBOL_REF, "seroval only supports well-known symbols");
-      return createWKSymbolNode(current);
+      if (hasReferenceID(current)) {
+        const id = createIndexedValue(ctx, current);
+        if (ctx.markedRefs.has(id)) {
+          return createIndexedValueNode(id);
+        }
+        return createReferenceNode(id, current);
+      }
+      return createWKSymbolNode(ctx, current);
+    case "function": {
+      assert(hasReferenceID(current), "Cannot serialize function without reference ID.");
+      const id = createIndexedValue(ctx, current);
+      if (ctx.markedRefs.has(id)) {
+        return createIndexedValueNode(id);
+      }
+      return createReferenceNode(id, current);
+    }
     default:
       throw new Error("Unsupported type");
   }
@@ -1844,7 +2014,7 @@ function parse2(ctx, current) {
 function parseSync(ctx, current) {
   const result = parse2(ctx, current);
   const isObject = result.t === 16 /* Object */ || result.t === 21 /* Iterable */;
-  return [result, createRef(ctx, current, false), isObject];
+  return [result, getRootID(ctx, current), isObject];
 }
 
 // src/index.ts