seroval 0.4.1 → 0.5.1

package/dist/esm/development/index.mjs

@@ -10,7 +10,7 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
   Feature2[Feature2["ObjectAssign"] = 128] = "ObjectAssign";
   Feature2[Feature2["Promise"] = 256] = "Promise";
   Feature2[Feature2["Set"] = 512] = "Set";
-  Feature2[Feature2["SymbolIterator"] = 1024] = "SymbolIterator";
+  Feature2[Feature2["Symbol"] = 1024] = "Symbol";
   Feature2[Feature2["TypedArray"] = 2048] = "TypedArray";
   Feature2[Feature2["BigIntTypedArray"] = 4096] = "BigIntTypedArray";
   return Feature2;
@@ -54,41 +54,42 @@ function createSerializationContext(options) {
     validRefs: [],
     refSize: 0,
     features: options.features,
-    markedRefs: new Set(options.markedRefs)
+    markedRefs: new Set(options.markedRefs),
+    valueMap: /* @__PURE__ */ new Map()
   };
 }
 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 createRef(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
@@ -137,13 +138,151 @@ function quote(str) {
   } else {
     result += str.slice(lastPos);
   }
-  return '"' + result + '"';
+  return result;
+}
+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/symbols.ts
+var SYMBOL_STRING = {
+  [0 /* AsyncIterator */]: "Symbol.asyncIterator",
+  [1 /* HasInstance */]: "Symbol.hasInstance",
+  [2 /* IsConcatSpreadable */]: "Symbol.isConcatSpreadable",
+  [3 /* Iterator */]: "Symbol.iterator",
+  [4 /* Match */]: "Symbol.match",
+  [5 /* MatchAll */]: "Symbol.matchAll",
+  [6 /* Replace */]: "Symbol.replace",
+  [7 /* Search */]: "Symbol.search",
+  [8 /* Species */]: "Symbol.species",
+  [9 /* Split */]: "Symbol.split",
+  [10 /* ToPrimitive */]: "Symbol.toPrimitive",
+  [11 /* ToStringTag */]: "Symbol.toStringTag",
+  [12 /* Unscopables */]: "Symbol.unscopables"
+};
+var INV_SYMBOL_REF = {
+  [Symbol.asyncIterator]: 0 /* AsyncIterator */,
+  [Symbol.hasInstance]: 1 /* HasInstance */,
+  [Symbol.isConcatSpreadable]: 2 /* IsConcatSpreadable */,
+  [Symbol.iterator]: 3 /* Iterator */,
+  [Symbol.match]: 4 /* Match */,
+  [Symbol.matchAll]: 5 /* MatchAll */,
+  [Symbol.replace]: 6 /* Replace */,
+  [Symbol.search]: 7 /* Search */,
+  [Symbol.species]: 8 /* Species */,
+  [Symbol.split]: 9 /* Split */,
+  [Symbol.toPrimitive]: 10 /* ToPrimitive */,
+  [Symbol.toStringTag]: 11 /* ToStringTag */,
+  [Symbol.unscopables]: 12 /* Unscopables */
+};
+var SYMBOL_REF = {
+  [0 /* AsyncIterator */]: Symbol.asyncIterator,
+  [1 /* HasInstance */]: Symbol.hasInstance,
+  [2 /* IsConcatSpreadable */]: Symbol.isConcatSpreadable,
+  [3 /* Iterator */]: Symbol.iterator,
+  [4 /* Match */]: Symbol.match,
+  [5 /* MatchAll */]: Symbol.matchAll,
+  [6 /* Replace */]: Symbol.replace,
+  [7 /* Search */]: Symbol.search,
+  [8 /* Species */]: Symbol.species,
+  [9 /* Split */]: Symbol.split,
+  [10 /* ToPrimitive */]: Symbol.toPrimitive,
+  [11 /* ToStringTag */]: Symbol.toStringTag,
+  [12 /* Unscopables */]: Symbol.unscopables
+};
+
 // src/tree/primitives.ts
-function createPrimitiveNode(value) {
+var TRUE_NODE = {
+  t: 2 /* Boolean */,
+  i: void 0,
+  s: true,
+  l: void 0,
+  c: void 0,
+  m: void 0,
+  d: void 0,
+  a: void 0,
+  f: void 0
+};
+var FALSE_NODE = {
+  t: 2 /* Boolean */,
+  i: void 0,
+  s: false,
+  l: void 0,
+  c: void 0,
+  m: void 0,
+  d: void 0,
+  a: void 0,
+  f: void 0
+};
+var UNDEFINED_NODE = {
+  t: 4 /* Undefined */,
+  i: void 0,
+  s: void 0,
+  l: void 0,
+  c: void 0,
+  m: void 0,
+  d: void 0,
+  a: void 0,
+  f: void 0
+};
+var NULL_NODE = {
+  t: 3 /* Null */,
+  i: void 0,
+  s: void 0,
+  l: void 0,
+  c: void 0,
+  m: void 0,
+  d: void 0,
+  a: void 0,
+  f: void 0
+};
+var NEG_ZERO_NODE = {
+  t: 5 /* NegativeZero */,
+  i: void 0,
+  s: void 0,
+  l: void 0,
+  c: void 0,
+  m: void 0,
+  d: void 0,
+  a: void 0,
+  f: void 0
+};
+var INFINITY_NODE = {
+  t: 6 /* Infinity */,
+  i: void 0,
+  s: void 0,
+  l: void 0,
+  c: void 0,
+  m: void 0,
+  d: void 0,
+  a: void 0,
+  f: void 0
+};
+var NEG_INFINITY_NODE = {
+  t: 7 /* NegativeInfinity */,
+  i: void 0,
+  s: void 0,
+  l: void 0,
+  c: void 0,
+  m: void 0,
+  d: void 0,
+  a: void 0,
+  f: void 0
+};
+var NAN_NODE = {
+  t: 8 /* NaN */,
+  i: void 0,
+  s: void 0,
+  l: void 0,
+  c: void 0,
+  m: void 0,
+  d: void 0,
+  a: void 0,
+  f: void 0
+};
+function createNumberNode(value) {
   return {
-    t: 0 /* Primitive */,
+    t: 0 /* Number */,
     i: void 0,
     s: value,
     l: void 0,
@@ -151,33 +290,39 @@ function createPrimitiveNode(value) {
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
+  };
+}
+function createStringNode(value) {
+  return {
+    t: 1 /* String */,
+    i: void 0,
+    s: quote(value),
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    f: void 0
   };
 }
-var TRUE_NODE = createPrimitiveNode("!0");
-var FALSE_NODE = createPrimitiveNode("!1");
-var UNDEFINED_NODE = createPrimitiveNode("void 0");
-var NULL_NODE = createPrimitiveNode(null);
-var NEG_ZERO_NODE = createPrimitiveNode("-0");
-var INFINITY_NODE = createPrimitiveNode("1/0");
-var NEG_INFINITY_NODE = createPrimitiveNode("-1/0");
 function createBigIntNode(ctx, current) {
   assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
   return {
-    t: 1 /* BigInt */,
+    t: 9 /* BigInt */,
     i: void 0,
-    s: current.toString() + "n",
+    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) {
   return {
-    t: 2 /* Reference */,
+    t: 10 /* Reference */,
     i: id,
     s: void 0,
     l: void 0,
@@ -185,48 +330,53 @@ function createReferenceNode(id) {
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function createDateNode(id, current) {
   return {
-    t: 3 /* Date */,
+    t: 11 /* Date */,
     i: id,
     s: current.toISOString(),
     l: void 0,
     c: void 0,
     m: void 0,
     d: void 0,
-    n: void 0,
+    f: void 0,
     a: void 0
   };
 }
 function createRegExpNode(id, current) {
   return {
-    t: 4 /* RegExp */,
+    t: 12 /* RegExp */,
     i: id,
-    s: String(current),
+    s: void 0,
     l: void 0,
-    c: void 0,
-    m: void 0,
+    c: current.source,
+    m: current.flags,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function createTypedArrayNode(ctx, id, current) {
   const constructor = current.constructor.name;
   assert(ctx.features & 2048 /* TypedArray */, `Unsupported value type "${constructor}"`);
+  const len = current.length;
+  const values = new Array(len);
+  for (let i = 0; i < len; i++) {
+    values[i] = "" + current[i];
+  }
   return {
-    t: 14 /* TypedArray */,
+    t: 22 /* TypedArray */,
     i: id,
-    s: current.toString(),
+    s: values,
     l: current.byteOffset,
     c: constructor,
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 var BIGINT_FLAG = 4096 /* BigIntTypedArray */ | 8 /* BigInt */;
@@ -236,28 +386,39 @@ function createBigIntTypedArrayNode(ctx, id, current) {
     (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
     `Unsupported value type "${constructor}"`
   );
-  let result = "";
-  for (let i = 0, len = current.length; i < len; i++) {
-    if (i !== 0) {
-      result += ",";
-    }
-    result += current[i].toString() + "n";
+  const len = current.length;
+  const values = new Array(len);
+  for (let i = 0; i < len; i++) {
+    values[i] = "" + current[i];
   }
   return {
-    t: 15 /* BigIntTypedArray */,
+    t: 23 /* BigIntTypedArray */,
     i: id,
-    s: result,
+    s: values,
     l: current.byteOffset,
     c: constructor,
     m: void 0,
     d: void 0,
     a: void 0,
-    n: void 0
+    f: void 0
+  };
+}
+function createWKSymbolNode(current) {
+  return {
+    t: 24 /* WKSymbol */,
+    i: void 0,
+    s: INV_SYMBOL_REF[current],
+    l: void 0,
+    c: void 0,
+    m: void 0,
+    d: void 0,
+    a: void 0,
+    f: void 0
   };
 }
 
 // src/tree/shared.ts
-function getErrorConstructor(error) {
+function getErrorConstructorName(error) {
   if (error instanceof EvalError) {
     return "EvalError";
   }
@@ -278,9 +439,29 @@ function getErrorConstructor(error) {
   }
   return "Error";
 }
+function getErrorConstructor(errorName) {
+  switch (errorName) {
+    case "Error":
+      return Error;
+    case "EvalError":
+      return EvalError;
+    case "RangeError":
+      return RangeError;
+    case "ReferenceError":
+      return ReferenceError;
+    case "SyntaxError":
+      return SyntaxError;
+    case "TypeError":
+      return TypeError;
+    case "URIError":
+      return URIError;
+    default:
+      throw new Error(`Unknown Error constructor "${errorName}"`);
+  }
+}
 function getErrorOptions(ctx, error) {
   let options;
-  const constructor = getErrorConstructor(error);
+  const constructor = getErrorConstructorName(error);
   if (error.name !== constructor) {
     options = { name: error.name };
   } else if (error.constructor.name !== constructor) {
@@ -340,6 +521,39 @@ function isIterable(value) {
   }
   return Symbol.iterator in value;
 }
+function getTypedArrayConstructor(name) {
+  switch (name) {
+    case "Int8Array":
+      return Int8Array;
+    case "Int16Array":
+      return Int16Array;
+    case "Int32Array":
+      return Int32Array;
+    case "Uint8Array":
+      return Uint8Array;
+    case "Uint16Array":
+      return Uint16Array;
+    case "Uint32Array":
+      return Uint32Array;
+    case "Uint8ClampedArray":
+      return Uint8ClampedArray;
+    case "Float32Array":
+      return Float32Array;
+    case "Float64Array":
+      return Float64Array;
+    case "BigInt64Array":
+      return BigInt64Array;
+    case "BigUint64Array":
+      return BigUint64Array;
+    default:
+      throw new Error(`Unknown TypedArray "${name}"`);
+  }
+}
+var IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;
+function isValidIdentifier(name) {
+  const char = name[0];
+  return (char === "$" || char === "_" || char >= "A" && char <= "Z" || char >= "a" && char <= "z") && IDENTIFIER_CHECK.test(name);
+}
 
 // src/tree/async.ts
 async function generateNodeList(ctx, current) {
@@ -366,15 +580,15 @@ async function generateNodeList(ctx, current) {
 }
 async function generateArrayNode(ctx, id, current) {
   return {
-    t: 7 /* Array */,
+    t: 15 /* Array */,
     i: id,
     s: void 0,
-    l: void 0,
+    l: current.length,
     c: void 0,
     m: void 0,
     d: void 0,
     a: await generateNodeList(ctx, current),
-    n: void 0
+    f: void 0
   };
 }
 async function generateMapNode(ctx, id, current) {
@@ -402,7 +616,7 @@ async function generateMapNode(ctx, id, current) {
     valueNodes[nodeSize + i] = await parse(ctx, deferredValue[i]);
   }
   return {
-    t: 6 /* Map */,
+    t: 14 /* Map */,
     i: id,
     s: void 0,
     l: void 0,
@@ -410,7 +624,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) {
@@ -431,15 +645,15 @@ async function generateSetNode(ctx, id, current) {
     nodes[nodeSize + i] = await parse(ctx, deferred[i]);
   }
   return {
-    t: 5 /* Set */,
+    t: 13 /* Set */,
     i: id,
     s: void 0,
-    l: void 0,
+    l: len,
     c: void 0,
     m: void 0,
     d: void 0,
     a: nodes,
-    n: void 0
+    f: void 0
   };
 }
 async function generateProperties(ctx, properties) {
@@ -475,25 +689,26 @@ async function generateProperties(ctx, properties) {
   };
 }
 async function generateIterableNode(ctx, id, current) {
-  assert(ctx.features & 1024 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
+  const array = Array.from(current);
   return {
-    t: 13 /* Iterable */,
+    t: 21 /* Iterable */,
     i: id,
     s: void 0,
-    l: void 0,
+    l: array.length,
     c: void 0,
     m: void 0,
     // Parse options first before the items
     d: options ? await generateProperties(ctx, options) : void 0,
-    a: await generateNodeList(ctx, Array.from(current)),
-    n: void 0
+    a: await generateNodeList(ctx, array),
+    f: void 0
   };
 }
 async function generatePromiseNode(ctx, id, current) {
   assert(ctx.features & 256 /* Promise */, 'Unsupported type "Promise"');
   return current.then(async (value) => ({
-    t: 10 /* Promise */,
+    t: 18 /* Promise */,
     i: id,
     s: void 0,
     l: void 0,
@@ -502,7 +717,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) {
@@ -513,7 +728,7 @@ async function generateObjectNode(ctx, id, current, empty) {
     return generatePromiseNode(ctx, id, current);
   }
   return {
-    t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+    t: empty ? 17 /* NullConstructor */ : 16 /* Object */,
     i: id,
     s: void 0,
     l: void 0,
@@ -521,37 +736,37 @@ 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) {
   const options = getErrorOptions(ctx, current);
   const optionsNode = options ? await generateProperties(ctx, options) : void 0;
   return {
-    t: 12 /* AggregateError */,
+    t: 20 /* AggregateError */,
     i: id,
     s: void 0,
-    l: void 0,
+    l: current.errors.length,
     c: void 0,
     m: current.message,
     d: optionsNode,
-    a: void 0,
-    n: await parse(ctx, current.errors)
+    a: await generateNodeList(ctx, current.errors),
+    f: void 0
   };
 }
 async function generateErrorNode(ctx, id, current) {
   const options = getErrorOptions(ctx, current);
   const optionsNode = options ? await generateProperties(ctx, options) : void 0;
   return {
-    t: 11 /* Error */,
+    t: 19 /* Error */,
     i: id,
     s: void 0,
     l: void 0,
-    c: getErrorConstructor(current),
+    c: getErrorConstructorName(current),
     m: current.message,
     d: optionsNode,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 async function parse(ctx, current) {
@@ -561,25 +776,30 @@ async function parse(ctx, current) {
     case "undefined":
       return UNDEFINED_NODE;
     case "string":
-      return createPrimitiveNode(quote(current));
+      return createStringNode(current);
     case "number":
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
+      switch (current) {
+        case Infinity:
+          return INFINITY_NODE;
+        case -Infinity:
+          return NEG_INFINITY_NODE;
+        default:
+          break;
       }
-      if (Object.is(current, Infinity)) {
-        return createPrimitiveNode("1/0");
+      if (current !== current) {
+        return NAN_NODE;
       }
-      if (Object.is(current, -Infinity)) {
-        return createPrimitiveNode("-1/0");
+      if (Object.is(current, -0)) {
+        return NEG_ZERO_NODE;
       }
-      return createPrimitiveNode(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 = createRef(ctx, current);
       if (ctx.markedRefs.has(id)) {
         return createReferenceNode(id);
       }
@@ -648,8 +868,11 @@ async function parse(ctx, 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);
@@ -665,14 +888,205 @@ 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);
     default:
       throw new Error("Unsupported type");
   }
 }
 async function parseAsync(ctx, current) {
   const result = await parse(ctx, current);
-  const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
-  return [result, createRef(ctx, current, false), isObject];
+  const isObject = result.t === 16 /* Object */ || result.t === 21 /* Iterable */;
+  return [result, getRootID(ctx, current), isObject];
+}
+
+// src/tree/deserialize.ts
+function assignRef(ctx, index, value) {
+  ctx.valueMap.set(index, value);
+  return value;
+}
+function deserializeNodeList(ctx, node, result) {
+  let item;
+  for (let i = 0, len = node.a.length; i < len; i++) {
+    item = node.a[i];
+    if (item) {
+      result[i] = deserializeTree(ctx, item);
+    }
+  }
+  return result;
+}
+function deserializeArray(ctx, node) {
+  const result = assignRef(
+    ctx,
+    node.i,
+    new Array(node.l)
+  );
+  ctx.stack.push(node.i);
+  deserializeNodeList(ctx, node, result);
+  ctx.stack.pop();
+  return result;
+}
+function deserializeProperties(ctx, node, result) {
+  if (node.s === 0) {
+    return {};
+  }
+  for (let i = 0; i < node.s; i++) {
+    result[node.k[i]] = deserializeTree(ctx, node.v[i]);
+  }
+  return result;
+}
+function deserializeNullConstructor(ctx, node) {
+  const result = assignRef(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, {});
+  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());
+  ctx.stack.push(node.i);
+  for (let i = 0, len = node.a.length; i < len; i++) {
+    result.add(deserializeTree(ctx, node.a[i]));
+  }
+  ctx.stack.pop();
+  return result;
+}
+function deserializeMap(ctx, node) {
+  const result = assignRef(
+    ctx,
+    node.i,
+    /* @__PURE__ */ new Map()
+  );
+  ctx.stack.push(node.i);
+  for (let i = 0; i < node.d.s; i++) {
+    result.set(
+      deserializeTree(ctx, node.d.k[i]),
+      deserializeTree(ctx, node.d.v[i])
+    );
+  }
+  ctx.stack.pop();
+  return result;
+}
+function deserializeDictionary(ctx, node, result) {
+  if (node.d) {
+    ctx.stack.push(node.i);
+    const fields = deserializeProperties(ctx, node.d, {});
+    ctx.stack.pop();
+    Object.assign(result, fields);
+  }
+  return result;
+}
+function deserializeAggregateError(ctx, node) {
+  const result = assignRef(ctx, node.i, new AggregateError([], node.m));
+  ctx.stack.push(node.i);
+  result.errors = deserializeNodeList(ctx, node, new Array(node.l));
+  ctx.stack.pop();
+  return deserializeDictionary(ctx, node, result);
+}
+function deserializeError(ctx, node) {
+  const ErrorConstructor = getErrorConstructor(node.c);
+  const result = assignRef(ctx, node.i, new ErrorConstructor(node.m));
+  return deserializeDictionary(ctx, node, result);
+}
+function createDeferred() {
+  let resolver;
+  return {
+    resolve(v) {
+      resolver(v);
+    },
+    promise: new Promise((res) => {
+      resolver = res;
+    })
+  };
+}
+function deserializePromise(ctx, node) {
+  const deferred = createDeferred();
+  const result = assignRef(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(
+    dummy.buffer,
+    node.l
+  ));
+  for (let i = 0, len = node.s.length; i < len; i++) {
+    result[i] = node.t === 23 /* BigIntTypedArray */ ? BigInt(node.s[i]) : Number(node.s[i]);
+  }
+  return result;
+}
+function deserializeIterable(ctx, node) {
+  const values = [];
+  deserializeNodeList(ctx, node, values);
+  const result = assignRef(ctx, node.i, {
+    [Symbol.iterator]: () => values.values()
+  });
+  return deserializeDictionary(ctx, node, result);
+}
+function deserializeTree(ctx, node) {
+  switch (node.t) {
+    case 0 /* Number */:
+    case 2 /* Boolean */:
+      return node.s;
+    case 1 /* String */:
+      return invQuote(node.s);
+    case 4 /* Undefined */:
+      return void 0;
+    case 3 /* Null */:
+      return null;
+    case 5 /* NegativeZero */:
+      return -0;
+    case 6 /* Infinity */:
+      return Infinity;
+    case 7 /* NegativeInfinity */:
+      return -Infinity;
+    case 8 /* NaN */:
+      return NaN;
+    case 9 /* BigInt */:
+      return BigInt(node.s);
+    case 10 /* Reference */:
+      return ctx.valueMap.get(node.i);
+    case 15 /* Array */:
+      return deserializeArray(ctx, node);
+    case 16 /* Object */:
+      return deserializeObject(ctx, node);
+    case 17 /* NullConstructor */:
+      return deserializeNullConstructor(ctx, node);
+    case 11 /* Date */:
+      return assignRef(ctx, node.i, new Date(node.s));
+    case 12 /* RegExp */:
+      return assignRef(ctx, node.i, new RegExp(node.c, node.m));
+    case 13 /* Set */:
+      return deserializeSet(ctx, node);
+    case 14 /* Map */:
+      return deserializeMap(ctx, node);
+    case 23 /* BigIntTypedArray */:
+    case 22 /* TypedArray */:
+      return deserializeTypedArray(ctx, node);
+    case 20 /* AggregateError */:
+      return deserializeAggregateError(ctx, node);
+    case 19 /* Error */:
+      return deserializeError(ctx, node);
+    case 21 /* Iterable */:
+      return deserializeIterable(ctx, node);
+    case 18 /* Promise */:
+      return deserializePromise(ctx, node);
+    case 24 /* WKSymbol */:
+      return SYMBOL_REF[node.s];
+    default:
+      throw new Error("Unsupported type");
+  }
 }
 
 // src/tree/serialize.ts
@@ -696,30 +1110,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);
@@ -772,24 +1204,23 @@ 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 assignRef(ctx, index, value) {
+function assignRef2(ctx, index, value) {
   if (ctx.markedRefs.has(index)) {
     return getRefParam(ctx, index) + "=" + value;
   }
   return value;
 }
 function isReferenceInStack(ctx, node) {
-  return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
+  return node.t === 10 /* Reference */ && ctx.stack.includes(node.i);
 }
-var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
 function serializeNodeList(ctx, node) {
-  const size = node.a.length;
+  const size = node.l;
   let values = "";
   let item;
   let isHoley = false;
@@ -810,18 +1241,15 @@ 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 assignRef(ctx, node.i, result);
+  return assignRef2(ctx, node.i, result);
 }
-function serializeObject(ctx, sourceID, node) {
+function serializeProperties(ctx, sourceID, node) {
   if (node.s === 0) {
     return "{}";
   }
@@ -837,20 +1265,16 @@ function serializeObject(ctx, sourceID, node) {
     key = node.k[i];
     val = node.v[i];
     check = Number(key);
-    isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    isIdentifier = check >= 0 || isValidIdentifier(key);
     if (isReferenceInStack(ctx, val)) {
       refParam = getRefParam(ctx, val.i);
       if (isIdentifier && Number.isNaN(check)) {
         createObjectAssign(ctx, sourceID, key, refParam);
       } else {
-        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+        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;
     }
   }
@@ -858,7 +1282,7 @@ function serializeObject(ctx, sourceID, node) {
   return "{" + result + "}";
 }
 function serializeWithObjectAssign(ctx, value, id, serialized) {
-  const fields = serializeObject(ctx, id, value);
+  const fields = serializeProperties(ctx, id, value);
   if (fields !== "{}") {
     return "Object.assign(" + serialized + "," + fields + ")";
   }
@@ -882,11 +1306,11 @@ function serializeAssignments(ctx, sourceID, node) {
     check = Number(key);
     parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
-    isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    isIdentifier = check >= 0 || isValidIdentifier(key);
     if (isIdentifier && Number.isNaN(check)) {
       createObjectAssign(ctx, sourceID, key, refParam);
     } else {
-      createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+      createArrayAssign(ctx, sourceID, isIdentifier ? key : '"' + quote(key) + '"', refParam);
     }
     ctx.assignments = parentAssignment;
   }
@@ -901,19 +1325,21 @@ function serializeDictionary(ctx, i, d, init) {
       markRef(ctx, i);
       const assignments = serializeAssignments(ctx, i, d);
       if (assignments) {
-        const ref = getRefParam(ctx, i);
-        return "(" + assignRef(ctx, i, init) + "," + assignments + ref + ")";
+        return "(" + assignRef2(ctx, i, init) + "," + assignments + getRefParam(ctx, i) + ")";
       }
     }
   }
-  return assignRef(ctx, i, init);
+  return assignRef2(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));
+}
 function serializeSet(ctx, node) {
   let serialized = "new Set";
-  const size = node.a.length;
+  const size = node.l;
   if (size) {
     let result = "";
     ctx.stack.push(node.i);
@@ -924,10 +1350,7 @@ function serializeSet(ctx, node) {
       if (isReferenceInStack(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;
       }
     }
@@ -936,7 +1359,7 @@ function serializeSet(ctx, node) {
       serialized += "([" + result + "])";
     }
   }
-  return assignRef(ctx, node.i, serialized);
+  return assignRef2(ctx, node.i, serialized);
 }
 function serializeMap(ctx, node) {
   let serialized = "new Map";
@@ -970,10 +1393,7 @@ function serializeMap(ctx, node) {
         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;
       }
     }
@@ -982,22 +1402,22 @@ function serializeMap(ctx, node) {
       serialized += "([" + result + "])";
     }
   }
-  return assignRef(ctx, node.i, serialized);
+  return assignRef2(ctx, node.i, serialized);
 }
 function serializeAggregateError(ctx, node) {
   ctx.stack.push(node.i);
-  const serialized = "new AggregateError(" + serializeTree(ctx, node.n) + "," + quote(node.m) + ")";
+  const serialized = "new AggregateError(" + serializeNodeList(ctx, node) + ',"' + quote(node.m) + '")';
   ctx.stack.pop();
   return serializeDictionary(ctx, node.i, node.d, serialized);
 }
 function serializeError(ctx, node) {
-  const serialized = "new " + node.c + "(" + quote(node.m) + ")";
+  const serialized = "new " + node.c + '("' + quote(node.m) + '")';
   return serializeDictionary(ctx, node.i, node.d, serialized);
 }
 function serializePromise(ctx, node) {
   let serialized;
-  if (isReferenceInStack(ctx, node.n)) {
-    const ref = getRefParam(ctx, node.n.i);
+  if (isReferenceInStack(ctx, node.f)) {
+    const ref = getRefParam(ctx, node.f.i);
     if (ctx.features & 4 /* ArrowFunction */) {
       serialized = "Promise.resolve().then(()=>" + ref + ")";
     } else {
@@ -1005,18 +1425,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 assignRef(ctx, node.i, serialized);
+  return assignRef2(ctx, node.i, serialized);
 }
 function serializeTypedArray(ctx, node) {
-  let args = "[" + node.s + "]";
-  if (node.l !== 0) {
-    args += "," + node.l.toString();
+  let result = "";
+  const isBigInt = node.t === 23 /* BigIntTypedArray */;
+  for (let i = 0, len = node.s.length; i < len; i++) {
+    result += (i !== 0 ? "," : "") + node.s[i] + (isBigInt ? "n" : "");
   }
-  return assignRef(ctx, node.i, "new " + node.c + "(" + args + ")");
+  const args = "[" + result + "]" + (node.l !== 0 ? "," + node.l : "");
+  return assignRef2(ctx, node.i, "new " + node.c + "(" + args + ")");
 }
 function serializeIterable(ctx, node) {
   const parent = ctx.stack;
@@ -1040,37 +1462,55 @@ function serializeIterable(ctx, node) {
 }
 function serializeTree(ctx, node) {
   switch (node.t) {
-    case 0 /* Primitive */:
-      return String(node.s);
-    case 1 /* BigInt */:
-      return node.s;
-    case 2 /* Reference */:
+    case 0 /* Number */:
+      return "" + node.s;
+    case 1 /* String */:
+      return '"' + node.s + '"';
+    case 2 /* Boolean */:
+      return node.s ? "!0" : "!1";
+    case 4 /* Undefined */:
+      return "void 0";
+    case 3 /* Null */:
+      return "null";
+    case 5 /* NegativeZero */:
+      return "-0";
+    case 6 /* Infinity */:
+      return "1/0";
+    case 7 /* NegativeInfinity */:
+      return "-1/0";
+    case 8 /* NaN */:
+      return "NaN";
+    case 9 /* BigInt */:
+      return node.s + "n";
+    case 10 /* Reference */:
       return getRefParam(ctx, node.i);
-    case 7 /* Array */:
+    case 15 /* Array */:
       return serializeArray(ctx, node);
-    case 8 /* Object */:
-      return assignRef(ctx, node.i, serializeObject(ctx, node.i, node.d));
-    case 9 /* NullConstructor */:
+    case 16 /* Object */:
+      return serializeObject(ctx, node);
+    case 17 /* NullConstructor */:
       return serializeNullConstructor(ctx, node);
-    case 3 /* Date */:
-      return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
-    case 4 /* RegExp */:
-      return assignRef(ctx, node.i, node.s);
-    case 5 /* Set */:
+    case 11 /* Date */:
+      return assignRef2(ctx, node.i, 'new Date("' + node.s + '")');
+    case 12 /* RegExp */:
+      return assignRef2(ctx, node.i, "/" + node.c + "/" + node.m);
+    case 13 /* Set */:
       return serializeSet(ctx, node);
-    case 6 /* Map */:
+    case 14 /* Map */:
       return serializeMap(ctx, node);
-    case 15 /* BigIntTypedArray */:
-    case 14 /* TypedArray */:
+    case 23 /* BigIntTypedArray */:
+    case 22 /* TypedArray */:
       return serializeTypedArray(ctx, node);
-    case 12 /* AggregateError */:
+    case 20 /* AggregateError */:
       return serializeAggregateError(ctx, node);
-    case 11 /* Error */:
+    case 19 /* Error */:
       return serializeError(ctx, node);
-    case 13 /* Iterable */:
+    case 21 /* Iterable */:
       return serializeIterable(ctx, node);
-    case 10 /* Promise */:
+    case 18 /* Promise */:
       return serializePromise(ctx, node);
+    case 24 /* WKSymbol */:
+      return SYMBOL_STRING[node.s];
     default:
       throw new Error("Unsupported type");
   }
@@ -1101,15 +1541,15 @@ function generateNodeList2(ctx, current) {
 }
 function generateArrayNode2(ctx, id, current) {
   return {
-    t: 7 /* Array */,
+    t: 15 /* Array */,
     i: id,
     s: void 0,
-    l: void 0,
+    l: current.length,
     c: void 0,
     m: void 0,
     d: void 0,
     a: generateNodeList2(ctx, current),
-    n: void 0
+    f: void 0
   };
 }
 function generateMapNode2(ctx, id, current) {
@@ -1137,7 +1577,7 @@ function generateMapNode2(ctx, id, current) {
     valueNodes[nodeSize + i] = parse2(ctx, deferredValue[i]);
   }
   return {
-    t: 6 /* Map */,
+    t: 14 /* Map */,
     i: id,
     s: void 0,
     l: void 0,
@@ -1145,7 +1585,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) {
@@ -1166,15 +1606,15 @@ function generateSetNode2(ctx, id, current) {
     nodes[nodeSize + i] = parse2(ctx, deferred[i]);
   }
   return {
-    t: 5 /* Set */,
+    t: 13 /* Set */,
     i: id,
     s: void 0,
-    l: void 0,
+    l: len,
     c: void 0,
     m: void 0,
     d: void 0,
     a: nodes,
-    n: void 0
+    f: void 0
   };
 }
 function generateProperties2(ctx, properties) {
@@ -1210,19 +1650,20 @@ function generateProperties2(ctx, properties) {
   };
 }
 function generateIterableNode2(ctx, id, current) {
-  assert(ctx.features & 1024 /* SymbolIterator */, 'Unsupported type "Iterable"');
+  assert(ctx.features & 1024 /* Symbol */, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
+  const array = Array.from(current);
   return {
-    t: 13 /* Iterable */,
+    t: 21 /* Iterable */,
     i: id,
     s: void 0,
-    l: void 0,
+    l: array.length,
     c: void 0,
     m: void 0,
     // Parse options first before the items
     d: options ? generateProperties2(ctx, options) : void 0,
-    a: generateNodeList2(ctx, Array.from(current)),
-    n: void 0
+    a: generateNodeList2(ctx, array),
+    f: void 0
   };
 }
 function generateObjectNode2(ctx, id, current, empty) {
@@ -1230,7 +1671,7 @@ function generateObjectNode2(ctx, id, current, empty) {
     return generateIterableNode2(ctx, id, current);
   }
   return {
-    t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+    t: empty ? 17 /* NullConstructor */ : 16 /* Object */,
     i: id,
     s: void 0,
     l: void 0,
@@ -1238,37 +1679,37 @@ 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) {
   const options = getErrorOptions(ctx, current);
   const optionsNode = options ? generateProperties2(ctx, options) : void 0;
   return {
-    t: 12 /* AggregateError */,
+    t: 20 /* AggregateError */,
     i: id,
     s: void 0,
-    l: void 0,
+    l: current.errors.length,
     c: void 0,
     m: current.message,
     d: optionsNode,
-    a: void 0,
-    n: parse2(ctx, current.errors)
+    a: generateNodeList2(ctx, current.errors),
+    f: void 0
   };
 }
 function generateErrorNode2(ctx, id, current) {
   const options = getErrorOptions(ctx, current);
   const optionsNode = options ? generateProperties2(ctx, options) : void 0;
   return {
-    t: 11 /* Error */,
+    t: 19 /* Error */,
     i: id,
     s: void 0,
     l: void 0,
-    c: getErrorConstructor(current),
+    c: getErrorConstructorName(current),
     m: current.message,
     d: optionsNode,
     a: void 0,
-    n: void 0
+    f: void 0
   };
 }
 function parse2(ctx, current) {
@@ -1278,25 +1719,30 @@ function parse2(ctx, current) {
     case "undefined":
       return UNDEFINED_NODE;
     case "string":
-      return createPrimitiveNode(quote(current));
+      return createStringNode(current);
     case "number":
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
+      switch (current) {
+        case Infinity:
+          return INFINITY_NODE;
+        case -Infinity:
+          return NEG_INFINITY_NODE;
+        default:
+          break;
       }
-      if (Object.is(current, Infinity)) {
-        return createPrimitiveNode("1/0");
+      if (current !== current) {
+        return NAN_NODE;
       }
-      if (Object.is(current, -Infinity)) {
-        return createPrimitiveNode("-1/0");
+      if (Object.is(current, -0)) {
+        return NEG_ZERO_NODE;
       }
-      return createPrimitiveNode(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 = createRef(ctx, current);
       if (ctx.markedRefs.has(id)) {
         return createReferenceNode(id);
       }
@@ -1345,8 +1791,11 @@ function parse2(ctx, 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);
@@ -1356,14 +1805,18 @@ 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);
     default:
       throw new Error("Unsupported type");
   }
 }
 function parseSync(ctx, current) {
   const result = parse2(ctx, current);
-  const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
-  return [result, createRef(ctx, current, false), isObject];
+  const isObject = result.t === 16 /* Object */ || result.t === 21 /* Iterable */;
+  return [result, getRootID(ctx, current), isObject];
 }
 
 // src/index.ts
@@ -1438,7 +1891,11 @@ function compileJSON(source) {
   return finalize(serial, source.r, source.i, result);
 }
 function fromJSON(source) {
-  return deserialize(compileJSON(source));
+  const serial = createSerializationContext({
+    features: source.f,
+    markedRefs: source.m
+  });
+  return deserializeTree(serial, source.t);
 }
 var src_default = serialize;
 export {