seroval 0.4.0-alpha.2 → 0.4.0-alpha.4

package/dist/esm/development/index.mjs

@@ -4,7 +4,7 @@ function isPrimitive(current) {
     return true;
   }
   const type = typeof current;
-  return type === "number" || type === "string" || type === "bigint";
+  return type === "number" || type === "string";
 }
 function isPromise(obj) {
   return !!obj && (typeof obj === "object" || typeof obj === "function") && "then" in obj && typeof obj.then === "function";
@@ -39,7 +39,7 @@ function compareVersion(left, right) {
 }
 var VERSION_TABLE = {
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError#browser_compatibility
-  [0 /* AggregateError */]: {
+  [1 /* AggregateError */]: {
     es: [2021, 0, 0],
     chrome: [85, 0, 0],
     edge: [85, 0, 0],
@@ -52,7 +52,7 @@ var VERSION_TABLE = {
     node: [15, 0, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values#browser_compatibility
-  [1 /* ArrayPrototypeValues */]: {
+  [2 /* ArrayPrototypeValues */]: {
     es: [6, 0, 0],
     chrome: [66, 0, 0],
     edge: [14, 0, 0],
@@ -65,7 +65,7 @@ var VERSION_TABLE = {
     node: [10, 9, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions#browser_compatibility
-  [2 /* ArrowFunction */]: {
+  [4 /* ArrowFunction */]: {
     es: [6, 0, 0],
     chrome: [45, 0, 0],
     edge: [12, 0, 0],
@@ -78,7 +78,7 @@ var VERSION_TABLE = {
     node: [4, 0, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#browser_compatibility
-  [3 /* BigInt */]: {
+  [8 /* BigInt */]: {
     es: [2020, 0, 0],
     chrome: [67, 0, 0],
     edge: [79, 0, 0],
@@ -91,7 +91,7 @@ var VERSION_TABLE = {
     node: [10, 4, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#browser_compatibility
-  [4 /* Map */]: {
+  [16 /* Map */]: {
     es: [6, 0, 0],
     chrome: [38, 0, 0],
     edge: [12, 0, 0],
@@ -104,7 +104,7 @@ var VERSION_TABLE = {
     node: [0, 12, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions#browser_compatibility
-  [5 /* MethodShorthand */]: {
+  [32 /* MethodShorthand */]: {
     es: [6, 0, 0],
     chrome: [39, 0, 0],
     edge: [12, 0, 0],
@@ -117,7 +117,7 @@ var VERSION_TABLE = {
     node: [4, 0, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#browser_compatibility
-  [6 /* ObjectAssign */]: {
+  [64 /* ObjectAssign */]: {
     es: [6, 0, 0],
     chrome: [45, 0, 0],
     edge: [12, 0, 0],
@@ -130,7 +130,7 @@ var VERSION_TABLE = {
     node: [4, 0, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#browser_compatibility
-  [7 /* Promise */]: {
+  [128 /* Promise */]: {
     es: [6, 0, 0],
     chrome: [32, 0, 0],
     edge: [12, 0, 0],
@@ -143,7 +143,7 @@ var VERSION_TABLE = {
     node: [0, 12, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#browser_compatibility
-  [8 /* Set */]: {
+  [256 /* Set */]: {
     es: [6, 0, 0],
     chrome: [38, 0, 0],
     edge: [12, 0, 0],
@@ -156,7 +156,7 @@ var VERSION_TABLE = {
     node: [0, 12, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator#browser_compatibility
-  [9 /* SymbolIterator */]: {
+  [512 /* SymbolIterator */]: {
     es: [6, 0, 0],
     chrome: [43, 0, 0],
     edge: [12, 0, 0],
@@ -169,7 +169,7 @@ var VERSION_TABLE = {
     node: [0, 12, 0]
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#browser_compatibility
-  [10 /* TypedArray */]: {
+  [1024 /* TypedArray */]: {
     es: [6, 0, 0],
     chrome: [7, 0, 0],
     edge: [12, 0, 0],
@@ -180,6 +180,19 @@ var VERSION_TABLE = {
     samsung: [1, 0, 0],
     deno: [1, 0, 0],
     node: [0, 10, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt64Array#browser_compatibility
+  [2048 /* BigIntTypedArray */]: {
+    es: [2020, 0, 0],
+    chrome: [67, 0, 0],
+    edge: [79, 0, 0],
+    firefox: [68, 0, 0],
+    opera: [54, 6, 0],
+    safari: [15, 1, 0],
+    ios: [15, 2, 0],
+    samsung: [9, 0, 0],
+    deno: [1, 0, 0],
+    node: [10, 4, 0]
   }
 };
 var TARGET_REGEX = /^(es|chrome|edge|safari|firefox|opera|ios|samsung|deno|node)([0-9]+(\.[0-9]+(\.[0-9]+)?)?)$/i;
@@ -202,7 +215,7 @@ function getTargetVersions(targets) {
 }
 function parseTargets(targets) {
   const parsed = getTargetVersions(targets);
-  const flags = /* @__PURE__ */ new Set();
+  let flags = 0;
   for (const key in VERSION_TABLE) {
     const base = VERSION_TABLE[key];
     let flag = true;
@@ -211,7 +224,7 @@ function parseTargets(targets) {
       flag = flag && !!baseVersion && compareVersion(baseVersion, version) <= 0;
     }
     if (flag) {
-      flags.add(Number(key));
+      flags |= Number(key);
     }
   }
   return flags;
@@ -280,16 +293,22 @@ function getIdentifier(index) {
 var DEFAULT_OPTIONS = {
   target: "es2023"
 };
-function createSerializationContext(options = {}) {
+function createParserContext(options = {}) {
   const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    markedRefs: [],
-    stack: [],
+    markedRefs: /* @__PURE__ */ new Set(),
     refs: /* @__PURE__ */ new Map(),
+    features: parseTargets(result.target)
+  };
+}
+function createSerializationContext(options) {
+  return {
+    stack: [],
     vars: [],
     assignments: [],
     validRefs: /* @__PURE__ */ new Map(),
-    features: parseTargets(result.target)
+    features: options.features,
+    markedRefs: new Set(options.markedRefs)
   };
 }
 function getAssignmentExpression(assignment) {
@@ -358,16 +377,7 @@ function resolvePatches(ctx) {
   return resolveAssignments(ctx.assignments);
 }
 function markRef(ctx, current) {
-  ctx.markedRefs[current] = true;
-}
-function createRef(ctx, index) {
-  const current = ctx.refs.get(index);
-  if (current != null) {
-    return current;
-  }
-  const id = ctx.refs.size;
-  ctx.refs.set(index, id);
-  return id;
+  ctx.markedRefs.add(current);
 }
 function createValidRef(ctx, index) {
   const current = ctx.validRefs.get(index);
@@ -388,11 +398,20 @@ function getRefParam(ctx, index) {
   return result;
 }
 function assignRef(ctx, index, value) {
-  if (ctx.markedRefs[index]) {
+  if (ctx.markedRefs.has(index)) {
     return `${getRefParam(ctx, index)}=${value}`;
   }
   return value;
 }
+function createRef(ctx, index) {
+  const current = ctx.refs.get(index);
+  if (current != null) {
+    return current;
+  }
+  const id = ctx.refs.size;
+  ctx.refs.set(index, id);
+  return id;
+}
 function createAssignment(ctx, source, value) {
   ctx.assignments.push({
     type: "index",
@@ -421,13 +440,10 @@ function createArrayAssign(ctx, ref, index, value) {
   markRef(ctx, ref);
   createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
 }
-function createObjectIdentifierAssign(ctx, ref, key, value) {
-  markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
-}
-function createObjectComputedAssign(ctx, ref, key, value) {
+function createObjectAssign(ctx, ref, key, value, computed) {
   markRef(ctx, ref);
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${key}]`, value);
+  const member = computed ? `[${key}]` : `.${key}`;
+  createAssignment(ctx, `${getRefParam(ctx, ref)}${member}`, value);
 }
 function getErrorConstructor(error) {
   if (error instanceof EvalError) {
@@ -479,104 +495,131 @@ function getIterableOptions(obj) {
   return void 0;
 }
 function isReferenceInStack(ctx, node) {
-  return node[0] === 1 /* Reference */ && ctx.stack.includes(node[1]);
+  return node[0] === 2 /* Reference */ && ctx.stack.includes(node[1]);
 }
 function generateRef(ctx, current) {
   const ref = ctx.refs.has(current);
   if (ref) {
     const refID = ctx.refs.get(current) || 0;
     markRef(ctx, refID);
-    return [1 /* Reference */, refID];
+    return [2 /* Reference */, refID];
   }
   const id = ctx.refs.size;
   ctx.refs.set(current, id);
   return id;
 }
 function generateSemiPrimitiveValue(ctx, current, id) {
+  if (typeof current === "bigint") {
+    assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+    return [1 /* BigInt */, `${current}n`];
+  }
   if (constructorCheck(current, Date)) {
-    return [2 /* Date */, current, id];
+    return [3 /* Date */, current.toISOString(), id];
   }
   if (constructorCheck(current, RegExp)) {
-    return [3 /* RegExp */, current, id];
+    return [4 /* RegExp */, String(current), id];
   }
   if (constructorCheck(current, Int8Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int8Array"');
-    return [13 /* TypedArray */, ["Int8Array", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Int8Array"');
+    return [14 /* TypedArray */, ["Int8Array", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, Int16Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int16Array"');
-    return [13 /* TypedArray */, ["Int16Array", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Int16Array"');
+    return [14 /* TypedArray */, ["Int16Array", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, Int32Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int32Array"');
-    return [13 /* TypedArray */, ["Int32Array", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Int32Array"');
+    return [14 /* TypedArray */, ["Int32Array", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, Uint8Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint8Array"');
-    return [13 /* TypedArray */, ["Uint8Array", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Uint8Array"');
+    return [14 /* TypedArray */, ["Uint8Array", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, Uint16Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint16Array"');
-    return [13 /* TypedArray */, ["Uint16Array", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Uint16Array"');
+    return [14 /* TypedArray */, ["Uint16Array", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, Uint32Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint32Array"');
-    return [13 /* TypedArray */, ["Uint32Array", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Uint32Array"');
+    return [14 /* TypedArray */, ["Uint32Array", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, Uint8ClampedArray)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint8ClampedArray"');
-    return [13 /* TypedArray */, ["Uint8ClampedArray", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Uint8ClampedArray"');
+    return [14 /* TypedArray */, ["Uint8ClampedArray", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, Float32Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Float32Array"');
-    return [13 /* TypedArray */, ["Float32Array", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Float32Array"');
+    return [14 /* TypedArray */, ["Float32Array", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, Float64Array)) {
-    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Float64Array"');
-    return [13 /* TypedArray */, ["Float64Array", current], id];
+    assert(ctx.features & 1024 /* TypedArray */, 'Unsupported value type "Float64Array"');
+    return [14 /* TypedArray */, ["Float64Array", current.toString(), current.byteOffset], id];
   }
   if (constructorCheck(current, BigInt64Array)) {
     assert(
-      ctx.features.has(10 /* TypedArray */) && ctx.features.has(3 /* BigInt */),
+      ctx.features & 2048 /* BigIntTypedArray */,
       'Unsupported value type "BigInt64Array"'
     );
-    return [13 /* TypedArray */, ["BigInt64Array", current], id];
+    let result = "";
+    const cap = current.length - 1;
+    for (let i = 0; i < cap; i++) {
+      result += `${current[i]}n,`;
+    }
+    result += `"${current[cap]}"`;
+    return [
+      15 /* BigIntTypedArray */,
+      ["BigInt64Array", result, current.byteOffset],
+      id
+    ];
   }
   if (constructorCheck(current, BigUint64Array)) {
     assert(
-      ctx.features.has(10 /* TypedArray */) && ctx.features.has(3 /* BigInt */),
+      ctx.features & 2048 /* BigIntTypedArray */,
       'Unsupported value type "BigUint64Array"'
     );
-    return [13 /* TypedArray */, ["BigUint64Array", current], id];
+    let result = "";
+    const cap = current.length - 1;
+    for (let i = 0; i < cap; i++) {
+      result += `"${current[i]}n",`;
+    }
+    result += `"${current[cap]}"`;
+    return [
+      15 /* BigIntTypedArray */,
+      ["BigInt64Array", result, current.byteOffset],
+      id
+    ];
   }
   return void 0;
 }
 function serializePropertiesSync(ctx, properties) {
-  const keyNodes = [];
-  const valueNodes = [];
-  const deferredKeys = [];
-  const deferredValues = [];
   const keys = Object.keys(properties);
+  const size = keys.length;
+  const keyNodes = new Array(size);
+  const valueNodes = new Array(size);
+  const deferredKeys = new Array(size);
+  const deferredValues = new Array(size);
   let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferredKeys.push(key);
-      deferredValues.push(properties[key]);
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key];
       deferredSize++;
     } else {
-      keyNodes.push(key);
-      valueNodes.push(generateTreeSync(ctx, properties[key]));
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key]);
+      nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes.push(deferredKeys[i]);
-    valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, keys.length];
+  return [keyNodes, valueNodes, size];
 }
 function generateTreeSync(ctx, current) {
   if (isPrimitive(current)) {
-    return [0 /* Primitive */, current];
+    return [0 /* Primitive */, serializePrimitive(current)];
   }
   const id = generateRef(ctx, current);
   if (Array.isArray(id)) {
@@ -587,43 +630,49 @@ function generateTreeSync(ctx, current) {
     return semiPrimitive;
   }
   if (constructorCheck(current, Set)) {
-    assert(ctx.features.has(8 /* Set */), 'Unsupported type "Set"');
-    const nodes = [];
-    const deferred = [];
+    assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+    const len = current.size;
+    const nodes = new Array(len);
+    const deferred = new Array(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
     for (const item of current.keys()) {
       if (isIterable(item)) {
-        deferred.push(item);
+        deferred[deferredSize++] = item;
       } else {
-        nodes.push(generateTreeSync(ctx, item));
+        nodes[nodeSize++] = generateTreeSync(ctx, item);
       }
     }
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(generateTreeSync(ctx, deferred[i]));
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
     }
-    return [4 /* Set */, nodes, id];
+    return [5 /* Set */, nodes, id];
   }
   if (constructorCheck(current, Map)) {
-    assert(ctx.features.has(4 /* Map */), 'Unsupported type "Map"');
-    const keyNodes = [];
-    const valueNodes = [];
-    const deferredKey = [];
-    const deferredValue = [];
+    assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+    const len = current.size;
+    const keyNodes = new Array(len);
+    const valueNodes = new Array(len);
+    const deferredKey = new Array(len);
+    const deferredValue = new Array(len);
     let deferredSize = 0;
+    let nodeSize = 0;
     for (const [key, value] of current.entries()) {
       if (isIterable(key) || isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
+        deferredKey[deferredSize] = key;
+        deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes.push(generateTreeSync(ctx, key));
-        valueNodes.push(generateTreeSync(ctx, value));
+        keyNodes[nodeSize] = generateTreeSync(ctx, key);
+        valueNodes[nodeSize] = generateTreeSync(ctx, value);
+        nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(generateTreeSync(ctx, deferredKey[i]));
-      valueNodes.push(generateTreeSync(ctx, deferredValue[i]));
+      keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
     }
-    return [5 /* Map */, [keyNodes, valueNodes, current.size], id];
+    return [6 /* Map */, [keyNodes, valueNodes, len], id];
   }
   if (Array.isArray(current)) {
     const size = current.length;
@@ -643,27 +692,27 @@ function generateTreeSync(ctx, current) {
         nodes[i] = generateTreeSync(ctx, deferred[i]);
       }
     }
-    return [6 /* Array */, nodes, id];
+    return [7 /* Array */, nodes, id];
   }
-  if (current instanceof AggregateError && ctx.features.has(0 /* AggregateError */)) {
+  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
     const options = getErrorOptions(current);
     const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
     const errorsNode = generateTreeSync(ctx, current.errors);
-    return [11 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
+    return [12 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
   }
   if (current instanceof Error) {
     const options = getErrorOptions(current);
     const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
     return [
-      10 /* Error */,
+      11 /* Error */,
       [getErrorConstructor(current), current.message, optionsNode],
       id
     ];
   }
   if (isIterable(current)) {
-    assert(ctx.features.has(9 /* SymbolIterator */), 'Unsupported type "Iterable"');
+    assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return [12 /* Iterable */, [
+    return [13 /* Iterable */, [
       // Parse options first before the items
       options ? serializePropertiesSync(ctx, options) : void 0,
       generateTreeSync(ctx, Array.from(current))
@@ -672,39 +721,46 @@ function generateTreeSync(ctx, current) {
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
     return [
-      empty ? 8 /* NullConstructor */ : 7 /* Object */,
+      empty ? 9 /* NullConstructor */ : 8 /* Object */,
       serializePropertiesSync(ctx, current),
       id
     ];
   }
   throw new Error("Unsupported value");
 }
+function parseSync(ctx, current) {
+  const result = generateTreeSync(ctx, current);
+  return [result, createRef(ctx, current), result[0] === 8 /* Object */];
+}
 async function serializePropertiesAsync(ctx, properties) {
-  const keyNodes = [];
-  const valueNodes = [];
-  const deferredKeys = [];
-  const deferredValues = [];
   const keys = Object.keys(properties);
+  const size = keys.length;
+  const keyNodes = new Array(size);
+  const valueNodes = new Array(size);
+  const deferredKeys = new Array(size);
+  const deferredValues = new Array(size);
   let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferredKeys.push(key);
-      deferredValues.push(properties[key]);
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key];
       deferredSize++;
     } else {
-      keyNodes.push(key);
-      valueNodes.push(await generateTreeAsync(ctx, properties[key]));
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key]);
+      nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes.push(deferredKeys[i]);
-    valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, keys.length];
+  return [keyNodes, valueNodes, size];
 }
 async function generateTreeAsync(ctx, current) {
   if (isPrimitive(current)) {
-    return [0 /* Primitive */, current];
+    return [0 /* Primitive */, serializePrimitive(current)];
   }
   const id = generateRef(ctx, current);
   if (Array.isArray(id)) {
@@ -715,51 +771,57 @@ async function generateTreeAsync(ctx, current) {
     return semiPrimitive;
   }
   if (isPromise(current)) {
-    assert(ctx.features.has(7 /* Promise */), 'Unsupported type "Promise"');
+    assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
     return current.then(async (value) => [
-      9 /* Promise */,
+      10 /* Promise */,
       await generateTreeAsync(ctx, value),
       id
     ]);
   }
   if (constructorCheck(current, Set)) {
-    assert(ctx.features.has(8 /* Set */), 'Unsupported type "Set"');
-    const nodes = [];
-    const deferred = [];
+    assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
+    const len = current.size;
+    const nodes = new Array(len);
+    const deferred = new Array(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
     for (const item of current.keys()) {
       if (isIterable(item)) {
-        deferred.push(item);
+        deferred[deferredSize++] = item;
       } else {
-        nodes.push(await generateTreeAsync(ctx, item));
+        nodes[nodeSize++] = await generateTreeAsync(ctx, item);
       }
     }
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(await generateTreeAsync(ctx, deferred[i]));
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
     }
-    return [4 /* Set */, nodes, id];
+    return [5 /* Set */, nodes, id];
   }
   if (constructorCheck(current, Map)) {
-    assert(ctx.features.has(4 /* Map */), 'Unsupported type "Map"');
-    const keyNodes = [];
-    const valueNodes = [];
-    const deferredKey = [];
-    const deferredValue = [];
+    assert(ctx.features & 16 /* Map */, 'Unsupported type "Map"');
+    const len = current.size;
+    const keyNodes = new Array(len);
+    const valueNodes = new Array(len);
+    const deferredKey = new Array(len);
+    const deferredValue = new Array(len);
     let deferredSize = 0;
+    let nodeSize = 0;
     for (const [key, value] of current.entries()) {
       if (isIterable(key) || isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
+        deferredKey[deferredSize] = key;
+        deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes.push(await generateTreeAsync(ctx, key));
-        valueNodes.push(await generateTreeAsync(ctx, value));
+        keyNodes[nodeSize] = await generateTreeAsync(ctx, key);
+        valueNodes[nodeSize] = await generateTreeAsync(ctx, value);
+        nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(await generateTreeAsync(ctx, deferredKey[i]));
-      valueNodes.push(await generateTreeAsync(ctx, deferredValue[i]));
+      keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
     }
-    return [5 /* Map */, [keyNodes, valueNodes, current.size], id];
+    return [6 /* Map */, [keyNodes, valueNodes, len], id];
   }
   if (Array.isArray(current)) {
     const size = current.length;
@@ -780,27 +842,27 @@ async function generateTreeAsync(ctx, current) {
         nodes[i] = await generateTreeAsync(ctx, deferred[i]);
       }
     }
-    return [6 /* Array */, nodes, id];
+    return [7 /* Array */, nodes, id];
   }
-  if (current instanceof AggregateError) {
+  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
     const options = getErrorOptions(current);
     const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
     const errorsNode = await generateTreeAsync(ctx, current.errors);
-    return [11 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
+    return [12 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
   }
   if (current instanceof Error) {
     const options = getErrorOptions(current);
     const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
     return [
-      10 /* Error */,
+      11 /* Error */,
       [getErrorConstructor(current), current.message, optionsNode],
       id
     ];
   }
   if (isIterable(current)) {
-    assert(ctx.features.has(9 /* SymbolIterator */), 'Unsupported type "Iterable"');
+    assert(ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return [12 /* Iterable */, [
+    return [13 /* Iterable */, [
       options ? await serializePropertiesAsync(ctx, options) : void 0,
       await generateTreeAsync(ctx, Array.from(current))
     ], id];
@@ -808,14 +870,18 @@ async function generateTreeAsync(ctx, current) {
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
     return [
-      empty ? 8 /* NullConstructor */ : 7 /* Object */,
+      empty ? 9 /* NullConstructor */ : 8 /* Object */,
       await serializePropertiesAsync(ctx, current),
       id
     ];
   }
   throw new Error("Unsupported value");
 }
-function serializePrimitive(ctx, value) {
+async function parseAsync(ctx, current) {
+  const result = await generateTreeAsync(ctx, current);
+  return [result, createRef(ctx, current), result[0] === 8 /* Object */];
+}
+function serializePrimitive(value) {
   if (value === true) {
     return "!0";
   }
@@ -826,11 +892,7 @@ function serializePrimitive(ctx, value) {
     return "void 0";
   }
   if (value === null) {
-    return "null";
-  }
-  if (typeof value === "bigint") {
-    assert(ctx.features.has(3 /* BigInt */), 'Unsupported type "BigInt"');
-    return `${value}n`;
+    return null;
   }
   if (typeof value === "string") {
     return quote(value);
@@ -844,7 +906,7 @@ function serializePrimitive(ctx, value) {
   if (Object.is(value, -Infinity)) {
     return "-1/0";
   }
-  return String(value);
+  return value;
 }
 var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
 function serializeAssignments(ctx, targetRef, [keys, values, size]) {
@@ -859,15 +921,14 @@ function serializeAssignments(ctx, targetRef, [keys, values, size]) {
     const check = Number(key);
     const parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
-    if (check >= 0 || Number.isNaN(check) && IDENTIFIER_CHECK.test(key)) {
-      if (!Number.isNaN(check)) {
-        createObjectComputedAssign(ctx, targetRef, key, refParam);
-      } else {
-        createObjectIdentifierAssign(ctx, targetRef, key, refParam);
-      }
-    } else {
-      createObjectComputedAssign(ctx, targetRef, quote(key), refParam);
-    }
+    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    createObjectAssign(
+      ctx,
+      targetRef,
+      isIdentifier ? key : quote(key),
+      refParam,
+      !(isIdentifier && Number.isNaN(check))
+    );
     ctx.assignments = parentAssignment;
   }
   ctx.stack.pop();
@@ -880,22 +941,19 @@ function serializeObject(ctx, sourceID, [keys, values, size]) {
     const key = keys[i];
     const val = values[i];
     const check = Number(key);
-    if (check >= 0 || Number.isNaN(check) && IDENTIFIER_CHECK.test(key)) {
-      if (isReferenceInStack(ctx, val)) {
-        const refParam = getRefParam(ctx, val[1]);
-        if (!Number.isNaN(check)) {
-          createObjectComputedAssign(ctx, sourceID, key, refParam);
-        } else {
-          createObjectIdentifierAssign(ctx, sourceID, key, refParam);
-        }
-      } else {
-        result += `${key}:${serializeTree(ctx, val)},`;
-      }
-    } else if (isReferenceInStack(ctx, val)) {
+    const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    const validKey = isIdentifier ? key : quote(key);
+    if (isReferenceInStack(ctx, val)) {
       const refParam = getRefParam(ctx, val[1]);
-      createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
+      createObjectAssign(
+        ctx,
+        sourceID,
+        validKey,
+        refParam,
+        !(isIdentifier && Number.isNaN(check))
+      );
     } else {
-      result += `${quote(key)}:${serializeTree(ctx, val)},`;
+      result += `${validKey}:${serializeTree(ctx, val)},`;
     }
   }
   ctx.stack.pop();
@@ -904,10 +962,10 @@ function serializeObject(ctx, sourceID, [keys, values, size]) {
 function serializeTree(ctx, [type, value, id]) {
   switch (type) {
     case 0 /* Primitive */:
-      return serializePrimitive(ctx, value);
-    case 1 /* Reference */:
+      return String(value);
+    case 2 /* Reference */:
       return getRefParam(ctx, value);
-    case 9 /* Promise */: {
+    case 10 /* Promise */: {
       let serialized;
       if (isReferenceInStack(ctx, value)) {
         serialized = `Promise.resolve().then(()=>${getRefParam(ctx, value[1])})`;
@@ -919,22 +977,21 @@ function serializeTree(ctx, [type, value, id]) {
       }
       return assignRef(ctx, id, serialized);
     }
-    case 2 /* Date */:
-      return assignRef(ctx, id, `new Date("${value.toISOString()}")`);
-    case 3 /* RegExp */:
-      return assignRef(ctx, id, String(value));
-    case 13 /* TypedArray */: {
-      let values = "";
-      for (let i = 0, len = value[1].length; i < len; i++) {
-        values += `${serializePrimitive(ctx, value[1][i])},`;
-      }
-      let args = values ? `[${values.substring(0, values.length - 1)}]` : "[]";
-      if (value[1].byteOffset !== 0) {
-        args += `,${value[1].byteOffset}`;
+    case 1 /* BigInt */:
+      return value;
+    case 3 /* Date */:
+      return assignRef(ctx, id, `new Date("${value}")`);
+    case 4 /* RegExp */:
+      return assignRef(ctx, id, value);
+    case 15 /* BigIntTypedArray */:
+    case 14 /* TypedArray */: {
+      let args = `[${value[1]}]`;
+      if (value[2] !== 0) {
+        args += `,${value[2]}`;
       }
       return assignRef(ctx, id, `new ${value[0]}(${args})`);
     }
-    case 4 /* Set */: {
+    case 5 /* Set */: {
       let serialized = "new Set";
       const size = value.length;
       if (size) {
@@ -955,7 +1012,7 @@ function serializeTree(ctx, [type, value, id]) {
       }
       return assignRef(ctx, id, serialized);
     }
-    case 5 /* Map */: {
+    case 6 /* Map */: {
       let serialized = "new Map";
       const size = value[2];
       if (size) {
@@ -992,13 +1049,13 @@ function serializeTree(ctx, [type, value, id]) {
       }
       return assignRef(ctx, id, serialized);
     }
-    case 6 /* Array */: {
+    case 7 /* Array */: {
       const size = value.length;
       let values = "";
       ctx.stack.push(id);
       for (let i = 0; i < size; i++) {
         const item = value[i];
-        if (i in value) {
+        if (item) {
           if (isReferenceInStack(ctx, item)) {
             createArrayAssign(ctx, id, i, getRefParam(ctx, item[1]));
             values += ",";
@@ -1015,12 +1072,12 @@ function serializeTree(ctx, [type, value, id]) {
       ctx.stack.pop();
       return assignRef(ctx, id, `[${values}]`);
     }
-    case 11 /* AggregateError */: {
+    case 12 /* AggregateError */: {
       ctx.stack.push(id);
       let serialized = `new AggregateError(${serializeTree(ctx, value[2])},${quote(value[0])})`;
       ctx.stack.pop();
       if (value[1]) {
-        if (ctx.features.has(6 /* ObjectAssign */)) {
+        if (ctx.features & 64 /* ObjectAssign */) {
           const options = serializeObject(ctx, id, value[1]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
@@ -1034,10 +1091,10 @@ function serializeTree(ctx, [type, value, id]) {
       }
       return assignRef(ctx, id, serialized);
     }
-    case 10 /* Error */: {
+    case 11 /* Error */: {
       let serialized = `new ${value[0]}(${quote(value[1])})`;
       if (value[2]) {
-        if (ctx.features.has(6 /* ObjectAssign */)) {
+        if (ctx.features & 64 /* ObjectAssign */) {
           const options = serializeObject(ctx, id, value[2]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
@@ -1051,26 +1108,26 @@ function serializeTree(ctx, [type, value, id]) {
       }
       return assignRef(ctx, id, serialized);
     }
-    case 12 /* Iterable */: {
+    case 13 /* Iterable */: {
       const parent = ctx.stack;
       ctx.stack = [];
       const values = serializeTree(ctx, value[1]);
       ctx.stack = parent;
       let serialized;
-      if (ctx.features.has(1 /* ArrayPrototypeValues */)) {
+      if (ctx.features & 2 /* ArrayPrototypeValues */) {
         serialized = `${values}.values()`;
       } else {
         serialized = `${values}[Symbol.iterator]()`;
       }
-      if (ctx.features.has(2 /* ArrowFunction */)) {
+      if (ctx.features & 4 /* ArrowFunction */) {
         serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-      } else if (ctx.features.has(5 /* MethodShorthand */)) {
+      } else if (ctx.features & 32 /* MethodShorthand */) {
         serialized = `{[Symbol.iterator](){return ${serialized}}}`;
       } else {
         serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
       }
       if (value[0]) {
-        if (ctx.features.has(6 /* ObjectAssign */)) {
+        if (ctx.features & 64 /* ObjectAssign */) {
           const options = serializeObject(ctx, id, value[0]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
@@ -1084,9 +1141,9 @@ function serializeTree(ctx, [type, value, id]) {
       }
       return assignRef(ctx, id, serialized);
     }
-    case 8 /* NullConstructor */: {
+    case 9 /* NullConstructor */: {
       let serialized = "Object.create(null)";
-      if (ctx.features.has(6 /* ObjectAssign */)) {
+      if (ctx.features & 64 /* ObjectAssign */) {
         const fields = serializeObject(ctx, id, value);
         if (fields !== "{}") {
           serialized = `Object.assign(${serialized},${fields})`;
@@ -1101,7 +1158,7 @@ function serializeTree(ctx, [type, value, id]) {
       }
       return assignRef(ctx, id, serialized);
     }
-    case 7 /* Object */:
+    case 8 /* Object */:
       return assignRef(ctx, id, serializeObject(ctx, id, value));
     default:
       throw new Error("Unsupported type");
@@ -1109,12 +1166,12 @@ function serializeTree(ctx, [type, value, id]) {
 }
 
 // src/index.ts
-function finalize(ctx, source, result) {
+function finalize(ctx, rootID, isObject, result) {
   if (ctx.vars.length) {
     const patches = resolvePatches(ctx);
     let body = result;
     if (patches) {
-      const index = getRefParam(ctx, createRef(ctx, source));
+      const index = getRefParam(ctx, rootID);
       if (result.startsWith(`${index}=`)) {
         body = `${result},${patches}${index}`;
       } else {
@@ -1122,43 +1179,83 @@ function finalize(ctx, source, result) {
       }
     }
     let params = ctx.vars.length > 1 ? ctx.vars.join(",") : ctx.vars[0];
-    if (ctx.features.has(2 /* ArrowFunction */)) {
+    if (ctx.features & 4 /* ArrowFunction */) {
       params = ctx.vars.length > 1 || ctx.vars.length === 0 ? `(${params})` : params;
       return `(${params}=>(${body}))()`;
     }
     return `(function(${params}){return ${body}})()`;
   }
-  if (source.constructor === Object) {
+  if (isObject) {
     return `(${result})`;
   }
   return result;
 }
 function serialize(source, options) {
-  const ctx = createSerializationContext(options);
+  const ctx = createParserContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(ctx, source);
+    return String(serializePrimitive(source));
   }
-  const tree = generateTreeSync(ctx, source);
-  const result = serializeTree(ctx, tree);
-  return finalize(ctx, source, result);
+  const [tree, rootID, isObject] = parseSync(ctx, source);
+  const serial = createSerializationContext(ctx);
+  const result = serializeTree(serial, tree);
+  return finalize(serial, rootID, isObject, result);
 }
 async function serializeAsync(source, options) {
-  const ctx = createSerializationContext(options);
+  const ctx = createParserContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(ctx, source);
+    return String(serializePrimitive(source));
   }
-  const tree = await generateTreeAsync(ctx, source);
-  const result = serializeTree(ctx, tree);
-  return finalize(ctx, source, result);
+  const [tree, rootID, isObject] = await parseAsync(ctx, source);
+  const serial = createSerializationContext(ctx);
+  const result = serializeTree(serial, tree);
+  return finalize(serial, rootID, isObject, result);
 }
 function deserialize(source) {
   return (0, eval)(source);
 }
+function toJSON(source, options) {
+  const ctx = createParserContext(options);
+  const [tree, root, isObject] = parseSync(ctx, source);
+  return JSON.stringify([
+    tree,
+    root,
+    isObject,
+    ctx.features,
+    [...ctx.markedRefs]
+  ]);
+}
+async function toJSONAsync(source, options) {
+  const ctx = createParserContext(options);
+  const [tree, root, isObject] = await parseAsync(ctx, source);
+  return JSON.stringify([
+    tree,
+    root,
+    isObject,
+    ctx.features,
+    [...ctx.markedRefs]
+  ]);
+}
+function compileJSON(source) {
+  const parsed = JSON.parse(source);
+  const serial = createSerializationContext({
+    features: parsed[3],
+    markedRefs: parsed[4]
+  });
+  const result = serializeTree(serial, parsed[0]);
+  return finalize(serial, parsed[1], parsed[2], result);
+}
+function fromJSON(source) {
+  return deserialize(compileJSON(source));
+}
 var src_default = serialize;
 export {
+  compileJSON,
   src_default as default,
   deserialize,
+  fromJSON,
   serialize,
-  serializeAsync
+  serializeAsync,
+  toJSON,
+  toJSONAsync
 };
 //# sourceMappingURL=index.mjs.map