seroval 0.3.0 → 0.4.0-alpha.0

package/dist/cjs/development/index.cjs

@@ -90,38 +90,6 @@ function quote(str) {
   return `"${result}"`;
 }
 
-// src/serialize-primitive.ts
-function serializePrimitive(value) {
-  if (value === true) {
-    return "!0";
-  }
-  if (value === false) {
-    return "!1";
-  }
-  if (value === void 0) {
-    return "void 0";
-  }
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "bigint") {
-    return `${value}n`;
-  }
-  if (typeof value === "string") {
-    return quote(value);
-  }
-  if (Object.is(value, -0)) {
-    return "-0";
-  }
-  if (Object.is(value, Infinity)) {
-    return "1/0";
-  }
-  if (Object.is(value, -Infinity)) {
-    return "-1/0";
-  }
-  return String(value);
-}
-
 // src/get-identifier.ts
 var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
 var REF_START_CHARS_LEN = REF_START_CHARS.length;
@@ -139,15 +107,221 @@ function getIdentifier(index) {
   return ref;
 }
 
+// src/assert.ts
+function assert(cond, error) {
+  if (!cond) {
+    throw new Error(error);
+  }
+}
+
+// src/compat.ts
+function compareVersion(left, right) {
+  let diff = left[0] - right[0];
+  if (diff === 0) {
+    diff = left[1] - right[1];
+  }
+  if (diff === 0) {
+    diff = left[2] - right[2];
+  }
+  return diff;
+}
+var VERSION_TABLE = {
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError#browser_compatibility
+  "aggregate-error": {
+    es: [2021, 0, 0],
+    chrome: [85, 0, 0],
+    edge: [85, 0, 0],
+    firefox: [79, 0, 0],
+    opera: [71, 0, 0],
+    safari: [14, 0, 0],
+    ios: [14, 0, 0],
+    samsung: [14, 0, 0],
+    deno: [1, 2, 0],
+    node: [15, 0, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values#browser_compatibility
+  "array-values": {
+    es: [6, 0, 0],
+    chrome: [66, 0, 0],
+    edge: [14, 0, 0],
+    firefox: [60, 0, 0],
+    opera: [53, 0, 0],
+    safari: [9, 0, 0],
+    ios: [9, 0, 0],
+    samsung: [9, 0, 0],
+    deno: [1, 0, 0],
+    node: [10, 9, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions#browser_compatibility
+  "arrow-function": {
+    es: [6, 0, 0],
+    chrome: [45, 0, 0],
+    edge: [12, 0, 0],
+    firefox: [24, 0, 0],
+    opera: [32, 0, 0],
+    safari: [10, 0, 0],
+    ios: [10, 0, 0],
+    samsung: [5, 0, 0],
+    deno: [1, 0, 0],
+    node: [4, 0, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#browser_compatibility
+  bigint: {
+    es: [2020, 0, 0],
+    chrome: [67, 0, 0],
+    edge: [79, 0, 0],
+    firefox: [68, 0, 0],
+    opera: [54, 0, 0],
+    safari: [14, 0, 0],
+    ios: [14, 0, 0],
+    samsung: [9, 0, 0],
+    deno: [1, 0, 0],
+    node: [10, 4, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#browser_compatibility
+  map: {
+    es: [6, 0, 0],
+    chrome: [38, 0, 0],
+    edge: [12, 0, 0],
+    firefox: [13, 0, 0],
+    opera: [25, 0, 0],
+    safari: [8, 0, 0],
+    ios: [8, 0, 0],
+    samsung: [3, 0, 0],
+    deno: [1, 0, 0],
+    node: [0, 12, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions#browser_compatibility
+  "method-shorthand": {
+    es: [6, 0, 0],
+    chrome: [39, 0, 0],
+    edge: [12, 0, 0],
+    firefox: [34, 0, 0],
+    opera: [26, 0, 0],
+    safari: [9, 0, 0],
+    ios: [9, 0, 0],
+    samsung: [4, 0, 0],
+    deno: [1, 0, 0],
+    node: [4, 0, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#browser_compatibility
+  "object-assign": {
+    es: [6, 0, 0],
+    chrome: [45, 0, 0],
+    edge: [12, 0, 0],
+    firefox: [34, 0, 0],
+    opera: [32, 0, 0],
+    safari: [9, 0, 0],
+    ios: [9, 0, 0],
+    samsung: [5, 0, 0],
+    deno: [1, 0, 0],
+    node: [4, 0, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#browser_compatibility
+  promise: {
+    es: [6, 0, 0],
+    chrome: [32, 0, 0],
+    edge: [12, 0, 0],
+    firefox: [29, 0, 0],
+    opera: [19, 0, 0],
+    safari: [8, 0, 0],
+    ios: [8, 0, 0],
+    samsung: [2, 0, 0],
+    deno: [1, 0, 0],
+    node: [0, 12, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#browser_compatibility
+  set: {
+    es: [6, 0, 0],
+    chrome: [38, 0, 0],
+    edge: [12, 0, 0],
+    firefox: [13, 0, 0],
+    opera: [25, 0, 0],
+    safari: [8, 0, 0],
+    ios: [8, 0, 0],
+    samsung: [3, 0, 0],
+    deno: [1, 0, 0],
+    node: [0, 12, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator#browser_compatibility
+  "symbol-iterator": {
+    es: [6, 0, 0],
+    chrome: [43, 0, 0],
+    edge: [12, 0, 0],
+    firefox: [36, 0, 0],
+    opera: [30, 0, 0],
+    safari: [10, 0, 0],
+    ios: [10, 0, 0],
+    samsung: [4, 0, 0],
+    deno: [1, 0, 0],
+    node: [0, 12, 0]
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#browser_compatibility
+  "typed-arrays": {
+    es: [6, 0, 0],
+    chrome: [7, 0, 0],
+    edge: [12, 0, 0],
+    firefox: [4, 0, 0],
+    opera: [11, 6, 0],
+    safari: [5, 1, 0],
+    ios: [4, 2, 0],
+    samsung: [1, 0, 0],
+    deno: [1, 0, 0],
+    node: [0, 10, 0]
+  }
+};
+var TARGET_REGEX = /^(es|chrome|edge|safari|firefox|opera|ios|samsung|deno|node)([0-9]+(\.[0-9]+(\.[0-9]+)?)?)$/i;
+function parseTarget(target) {
+  const result = TARGET_REGEX.exec(target);
+  assert(result, `Invalid target "${target}"`);
+  const [, platform, version] = result;
+  const [major, minor = "0", patch = "0"] = version.split(".");
+  return [platform, [Number(major), Number(minor), Number(patch)]];
+}
+function getTargetVersions(targets) {
+  if (Array.isArray(targets)) {
+    const versions = [];
+    for (const target of targets) {
+      versions.push(parseTarget(target));
+    }
+    return versions;
+  }
+  return [parseTarget(targets)];
+}
+function isFeatureSupported(key, targets) {
+  const base = VERSION_TABLE[key];
+  let flag = true;
+  for (const [platform, version] of targets) {
+    const baseVersion = base[platform];
+    flag = flag && !!baseVersion && compareVersion(baseVersion, version) <= 0;
+  }
+  return flag;
+}
+function parseTargets(targets) {
+  const parsed = getTargetVersions(targets);
+  const flags = /* @__PURE__ */ new Set();
+  for (const key in VERSION_TABLE) {
+    if (isFeatureSupported(key, parsed)) {
+      flags.add(key);
+    }
+  }
+  return flags;
+}
+
 // src/tree.ts
-function createSerializationContext() {
+var DEFAULT_OPTIONS = {
+  target: "es2023"
+};
+function createSerializationContext(options = {}) {
+  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
     markedRefs: [],
     stack: [],
     refs: /* @__PURE__ */ new Map(),
     vars: [],
     assignments: [],
-    validRefs: /* @__PURE__ */ new Map()
+    validRefs: /* @__PURE__ */ new Map(),
+    features: parseTargets(result.target)
   };
 }
 function getAssignmentExpression(assignment) {
@@ -162,12 +336,12 @@ function getAssignmentExpression(assignment) {
       return "";
   }
 }
-function mergeAssignments(ctx) {
+function mergeAssignments(assignments) {
   const newAssignments = [];
-  let current = ctx.assignments[0];
+  let current = assignments[0];
   let prev = current;
-  for (let i = 1, len = ctx.assignments.length; i < len; i += 1) {
-    const item = ctx.assignments[i];
+  for (let i = 1, len = assignments.length; i < len; i++) {
+    const item = assignments[i];
     if (item.type === prev.type) {
       if (item.type === "index" && item.value === prev.value) {
         current = {
@@ -201,15 +375,19 @@ function mergeAssignments(ctx) {
   newAssignments.push(current);
   return newAssignments;
 }
-function resolvePatches(ctx) {
-  if (ctx.assignments.length) {
+function resolveAssignments(assignments) {
+  if (assignments.length) {
     let result = "";
-    for (const assignment of mergeAssignments(ctx)) {
-      result += `${getAssignmentExpression(assignment)},`;
+    const merged = mergeAssignments(assignments);
+    for (let i = 0, len = merged.length; i < len; i++) {
+      result += `${getAssignmentExpression(merged[i])},`;
     }
     return result;
   }
-  return "";
+  return void 0;
+}
+function resolvePatches(ctx) {
+  return resolveAssignments(ctx.assignments);
 }
 function markRef(ctx, current) {
   ctx.markedRefs[current] = true;
@@ -304,12 +482,6 @@ function getErrorConstructor(error) {
   }
   return "Error";
 }
-var EXCLUDED_ERROR_KEYS = {
-  name: true,
-  cause: true,
-  stack: true,
-  message: true
-};
 function getErrorOptions(error) {
   let options;
   const constructor = getErrorConstructor(error);
@@ -320,7 +492,7 @@ function getErrorOptions(error) {
   }
   const names = Object.getOwnPropertyNames(error);
   for (const name of names) {
-    if (!(name in EXCLUDED_ERROR_KEYS)) {
+    if (name !== "name" && name !== "message") {
       options = options || {};
       options[name] = error[name];
     }
@@ -352,7 +524,7 @@ function generateRef(ctx, current) {
   ctx.refs.set(current, id);
   return id;
 }
-function generateSemiPrimitiveValue(current, id) {
+function generateSemiPrimitiveValue(ctx, current, id) {
   if (constructorCheck(current, Date)) {
     return [2 /* Date */, current, id];
   }
@@ -360,41 +532,81 @@ function generateSemiPrimitiveValue(current, id) {
     return [3 /* RegExp */, current, id];
   }
   if (constructorCheck(current, Int8Array)) {
-    return [13 /* TypedArray */, { constructor: "Int8Array", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int8Array"');
+    return [13 /* TypedArray */, ["Int8Array", current], id];
   }
   if (constructorCheck(current, Int16Array)) {
-    return [13 /* TypedArray */, { constructor: "Int16Array", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int16Array"');
+    return [13 /* TypedArray */, ["Int16Array", current], id];
   }
   if (constructorCheck(current, Int32Array)) {
-    return [13 /* TypedArray */, { constructor: "Int32Array", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int32Array"');
+    return [13 /* TypedArray */, ["Int32Array", current], id];
   }
   if (constructorCheck(current, Uint8Array)) {
-    return [13 /* TypedArray */, { constructor: "Uint8Array", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint8Array"');
+    return [13 /* TypedArray */, ["Uint8Array", current], id];
   }
   if (constructorCheck(current, Uint16Array)) {
-    return [13 /* TypedArray */, { constructor: "Uint16Array", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint16Array"');
+    return [13 /* TypedArray */, ["Uint16Array", current], id];
   }
   if (constructorCheck(current, Uint32Array)) {
-    return [13 /* TypedArray */, { constructor: "Uint32Array", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint32Array"');
+    return [13 /* TypedArray */, ["Uint32Array", current], id];
   }
   if (constructorCheck(current, Uint8ClampedArray)) {
-    return [13 /* TypedArray */, { constructor: "Uint8ClampedArray", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint8ClampedArray"');
+    return [13 /* TypedArray */, ["Uint8ClampedArray", current], id];
   }
   if (constructorCheck(current, Float32Array)) {
-    return [13 /* TypedArray */, { constructor: "Float32Array", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Float32Array"');
+    return [13 /* TypedArray */, ["Float32Array", current], id];
   }
   if (constructorCheck(current, Float64Array)) {
-    return [13 /* TypedArray */, { constructor: "Float64Array", array: current }, id];
+    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Float64Array"');
+    return [13 /* TypedArray */, ["Float64Array", current], id];
   }
   if (constructorCheck(current, BigInt64Array)) {
-    return [13 /* TypedArray */, { constructor: "BigInt64Array", array: current }, id];
+    assert(
+      ctx.features.has("typed-arrays") && ctx.features.has("bigint"),
+      'Unsupported value type "BigInt64Array"'
+    );
+    return [13 /* TypedArray */, ["BigInt64Array", current], id];
   }
   if (constructorCheck(current, BigUint64Array)) {
-    return [13 /* TypedArray */, { constructor: "BigUint64Array", array: current }, id];
+    assert(
+      ctx.features.has("typed-arrays") && ctx.features.has("bigint"),
+      'Unsupported value type "BigUint64Array"'
+    );
+    return [13 /* TypedArray */, ["BigUint64Array", current], id];
   }
   return void 0;
 }
 function generateTreeSync(ctx, current) {
+  function serializeProperties(properties) {
+    const keyNodes = [];
+    const valueNodes = [];
+    const deferredKeys = [];
+    const deferredValues = [];
+    const keys = Object.keys(properties);
+    let deferredSize = 0;
+    for (const key of keys) {
+      if (isIterable(properties[key])) {
+        deferredKeys.push(key);
+        deferredValues.push(properties[key]);
+        deferredSize++;
+      } else {
+        keyNodes.push(key);
+        valueNodes.push(generateTreeSync(ctx, properties[key]));
+      }
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes.push(deferredKeys[i]);
+      valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
+    }
+    return [keyNodes, valueNodes, keys.length];
+  }
   if (isPrimitive(current)) {
     return [0 /* Primitive */, current];
   }
@@ -402,11 +614,12 @@ function generateTreeSync(ctx, current) {
   if (Array.isArray(id)) {
     return id;
   }
-  const semiPrimitive = generateSemiPrimitiveValue(current, id);
+  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
   if (semiPrimitive) {
     return semiPrimitive;
   }
   if (constructorCheck(current, Set)) {
+    assert(ctx.features.has("set"), 'Unsupported type "Set"');
     const nodes = [];
     const deferred = [];
     for (const item of current.keys()) {
@@ -416,95 +629,112 @@ function generateTreeSync(ctx, current) {
         nodes.push(generateTreeSync(ctx, item));
       }
     }
-    for (const item of deferred) {
-      nodes.push(generateTreeSync(ctx, item));
+    for (let i = 0, len = deferred.length; i < len; i++) {
+      nodes.push(generateTreeSync(ctx, deferred[i]));
     }
     return [4 /* Set */, nodes, id];
   }
   if (constructorCheck(current, Map)) {
-    const nodes = [];
-    const deferred = [];
+    assert(ctx.features.has("map"), 'Unsupported type "Map"');
+    const keyNodes = [];
+    const valueNodes = [];
+    const deferredKey = [];
+    const deferredValue = [];
+    let deferredSize = 0;
     for (const [key, value] of current.entries()) {
       if (isIterable(key) || isIterable(value)) {
-        deferred.push([key, value]);
+        deferredKey.push(key);
+        deferredValue.push(value);
+        deferredSize++;
       } else {
-        const keyNode = generateTreeSync(ctx, key);
-        const valueNode = generateTreeSync(ctx, value);
-        nodes.push([keyNode, valueNode]);
+        keyNodes.push(generateTreeSync(ctx, key));
+        valueNodes.push(generateTreeSync(ctx, value));
       }
     }
-    for (const [key, value] of deferred) {
-      const keyNode = generateTreeSync(ctx, key);
-      const valueNode = generateTreeSync(ctx, value);
-      nodes.push([keyNode, valueNode]);
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes.push(generateTreeSync(ctx, deferredKey[i]));
+      valueNodes.push(generateTreeSync(ctx, deferredValue[i]));
     }
-    return [5 /* Map */, nodes, id];
+    return [5 /* Map */, [keyNodes, valueNodes, current.size], id];
   }
   if (Array.isArray(current)) {
-    const nodes = new Array(current.length);
-    const deferred = new Array(current.length);
-    for (const key in current) {
-      const item = current[key];
-      if (isIterable(item)) {
-        deferred[key] = item;
-      } else {
-        nodes[key] = generateTreeSync(ctx, item);
+    const size = current.length;
+    const nodes = new Array(size);
+    const deferred = new Array(size);
+    for (let i = 0; i < size; i++) {
+      if (i in current) {
+        if (isIterable(current[i])) {
+          deferred[i] = current[i];
+        } else {
+          nodes[i] = generateTreeSync(ctx, current[i]);
+        }
       }
     }
-    for (const key in deferred) {
-      nodes[key] = generateTreeSync(ctx, deferred[key]);
+    for (let i = 0; i < size; i++) {
+      if (i in deferred) {
+        nodes[i] = generateTreeSync(ctx, deferred[i]);
+      }
     }
     return [6 /* Array */, nodes, id];
   }
-  if (current instanceof AggregateError) {
+  if (current instanceof AggregateError && ctx.features.has("aggregate-error")) {
     const options = getErrorOptions(current);
-    return [11 /* AggregateError */, {
-      message: current.message,
-      options: options ? generateTreeSync(ctx, options) : void 0,
-      cause: "cause" in current ? generateTreeSync(ctx, { cause: current.cause }) : void 0,
-      errors: generateTreeSync(ctx, current.errors)
-    }, id];
+    const optionsNode = options ? serializeProperties(options) : void 0;
+    const errorsNode = generateTreeSync(ctx, current.errors);
+    return [11 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
   }
   if (current instanceof Error) {
     const options = getErrorOptions(current);
-    return [10 /* Error */, {
-      constructor: getErrorConstructor(current),
-      message: current.message,
-      options: options ? generateTreeSync(ctx, options) : void 0,
-      cause: "cause" in current ? generateTreeSync(ctx, { cause: current.cause }) : void 0
-    }, id];
+    const optionsNode = options ? serializeProperties(options) : void 0;
+    return [
+      10 /* Error */,
+      [getErrorConstructor(current), current.message, optionsNode],
+      id
+    ];
   }
   if (isIterable(current)) {
+    assert(ctx.features.has("symbol-iterator"), 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return [12 /* Iterable */, {
+    return [12 /* Iterable */, [
       // Parse options first before the items
-      options: options ? generateTreeSync(ctx, options) : void 0,
-      items: generateTreeSync(ctx, Array.from(current))
-    }, id];
+      options ? serializeProperties(options) : void 0,
+      generateTreeSync(ctx, Array.from(current))
+    ], id];
   }
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
-    const nodes = {};
-    const deferred = {};
-    for (const [key, item] of Object.entries(current)) {
-      if (isIterable(item)) {
-        deferred[key] = item;
-      } else {
-        nodes[key] = generateTreeSync(ctx, item);
-      }
-    }
-    for (const [key, item] of Object.entries(deferred)) {
-      nodes[key] = generateTreeSync(ctx, item);
-    }
     return [
       empty ? 8 /* NullConstructor */ : 7 /* Object */,
-      nodes,
+      serializeProperties(current),
       id
     ];
   }
   throw new Error("Unsupported value");
 }
 async function generateTreeAsync(ctx, current) {
+  async function serializeProperties(properties) {
+    const keyNodes = [];
+    const valueNodes = [];
+    const deferredKeys = [];
+    const deferredValues = [];
+    const keys = Object.keys(properties);
+    let deferredSize = 0;
+    for (const key of keys) {
+      if (isIterable(properties[key])) {
+        deferredKeys.push(key);
+        deferredValues.push(properties[key]);
+        deferredSize++;
+      } else {
+        keyNodes.push(key);
+        valueNodes.push(await generateTreeAsync(ctx, properties[key]));
+      }
+    }
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes.push(deferredKeys[i]);
+      valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
+    }
+    return [keyNodes, valueNodes, keys.length];
+  }
   if (isPrimitive(current)) {
     return [0 /* Primitive */, current];
   }
@@ -512,11 +742,12 @@ async function generateTreeAsync(ctx, current) {
   if (Array.isArray(id)) {
     return id;
   }
-  const semiPrimitive = generateSemiPrimitiveValue(current, id);
+  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
   if (semiPrimitive) {
     return semiPrimitive;
   }
   if (isPromise(current)) {
+    assert(ctx.features.has("promise"), 'Unsupported type "Promise"');
     return current.then(async (value) => [
       9 /* Promise */,
       await generateTreeAsync(ctx, value),
@@ -524,6 +755,7 @@ async function generateTreeAsync(ctx, current) {
     ]);
   }
   if (constructorCheck(current, Set)) {
+    assert(ctx.features.has("set"), 'Unsupported type "Set"');
     const nodes = [];
     const deferred = [];
     for (const item of current.keys()) {
@@ -533,97 +765,177 @@ async function generateTreeAsync(ctx, current) {
         nodes.push(await generateTreeAsync(ctx, item));
       }
     }
-    for (const item of deferred) {
-      nodes.push(await generateTreeAsync(ctx, item));
+    for (let i = 0, len = deferred.length; i < len; i++) {
+      nodes.push(await generateTreeAsync(ctx, deferred[i]));
     }
     return [4 /* Set */, nodes, id];
   }
   if (constructorCheck(current, Map)) {
-    const nodes = [];
-    const deferred = [];
+    assert(ctx.features.has("map"), 'Unsupported type "Map"');
+    const keyNodes = [];
+    const valueNodes = [];
+    const deferredKey = [];
+    const deferredValue = [];
+    let deferredSize = 0;
     for (const [key, value] of current.entries()) {
       if (isIterable(key) || isIterable(value)) {
-        deferred.push([key, value]);
+        deferredKey.push(key);
+        deferredValue.push(value);
+        deferredSize++;
       } else {
-        const keyNode = await generateTreeAsync(ctx, key);
-        const valueNode = await generateTreeAsync(ctx, value);
-        nodes.push([keyNode, valueNode]);
+        keyNodes.push(await generateTreeAsync(ctx, key));
+        valueNodes.push(await generateTreeAsync(ctx, value));
       }
     }
-    for (const [key, value] of deferred) {
-      const keyNode = await generateTreeAsync(ctx, key);
-      const valueNode = await generateTreeAsync(ctx, value);
-      nodes.push([keyNode, valueNode]);
+    for (let i = 0; i < deferredSize; i++) {
+      keyNodes.push(await generateTreeAsync(ctx, deferredKey[i]));
+      valueNodes.push(await generateTreeAsync(ctx, deferredValue[i]));
     }
-    return [5 /* Map */, nodes, id];
+    return [5 /* Map */, [keyNodes, valueNodes, current.size], id];
   }
   if (Array.isArray(current)) {
-    const nodes = new Array(current.length);
-    const deferred = new Array(current.length);
-    for (const key in current) {
-      const item = current[key];
-      if (isIterable(item)) {
-        deferred[key] = item;
-      } else {
-        nodes[key] = await generateTreeAsync(ctx, item);
+    const size = current.length;
+    const nodes = new Array(size);
+    const deferred = new Array(size);
+    for (let i = 0; i < size; i++) {
+      const item = current[i];
+      if (i in current) {
+        if (isIterable(item)) {
+          deferred[i] = item;
+        } else {
+          nodes[i] = await generateTreeAsync(ctx, item);
+        }
       }
     }
-    for (const key in deferred) {
-      nodes[key] = await generateTreeAsync(ctx, deferred[key]);
+    for (let i = 0; i < size; i++) {
+      if (i in deferred) {
+        nodes[i] = await generateTreeAsync(ctx, deferred[i]);
+      }
     }
     return [6 /* Array */, nodes, id];
   }
   if (current instanceof AggregateError) {
     const options = getErrorOptions(current);
-    return [11 /* AggregateError */, {
-      message: current.message,
-      options: options ? generateTreeSync(ctx, options) : void 0,
-      cause: "cause" in current ? await generateTreeAsync(ctx, { cause: current.cause }) : void 0,
-      errors: await generateTreeAsync(ctx, current.errors)
-    }, id];
+    const optionsNode = options ? await serializeProperties(options) : void 0;
+    const errorsNode = await generateTreeAsync(ctx, current.errors);
+    return [11 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
   }
   if (current instanceof Error) {
     const options = getErrorOptions(current);
-    return [10 /* Error */, {
-      constructor: getErrorConstructor(current),
-      message: current.message,
-      options: options ? await generateTreeAsync(ctx, options) : void 0,
-      cause: "cause" in current ? await generateTreeAsync(ctx, { cause: current.cause }) : void 0
-    }, id];
+    const optionsNode = options ? await serializeProperties(options) : void 0;
+    return [
+      10 /* Error */,
+      [getErrorConstructor(current), current.message, optionsNode],
+      id
+    ];
   }
   if (isIterable(current)) {
+    assert(ctx.features.has("symbol-iterator"), 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return [12 /* Iterable */, {
-      options: options ? await generateTreeAsync(ctx, options) : void 0,
-      items: await generateTreeAsync(ctx, Array.from(current))
-    }, id];
+    return [12 /* Iterable */, [
+      options ? await serializeProperties(options) : void 0,
+      await generateTreeAsync(ctx, Array.from(current))
+    ], id];
   }
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
-    const nodes = {};
-    const deferred = {};
-    for (const [key, item] of Object.entries(current)) {
-      if (isIterable(item)) {
-        deferred[key] = item;
-      } else {
-        nodes[key] = await generateTreeAsync(ctx, item);
-      }
-    }
-    for (const [key, item] of Object.entries(deferred)) {
-      nodes[key] = await generateTreeAsync(ctx, item);
-    }
     return [
       empty ? 8 /* NullConstructor */ : 7 /* Object */,
-      nodes,
+      await serializeProperties(current),
       id
     ];
   }
   throw new Error("Unsupported value");
 }
+function serializePrimitive(ctx, value) {
+  if (value === true) {
+    return "!0";
+  }
+  if (value === false) {
+    return "!1";
+  }
+  if (value === void 0) {
+    return "void 0";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "bigint") {
+    assert(ctx.features.has("bigint"), 'Unsupported type "BigInt"');
+    return `${value}n`;
+  }
+  if (typeof value === "string") {
+    return quote(value);
+  }
+  if (Object.is(value, -0)) {
+    return "-0";
+  }
+  if (Object.is(value, Infinity)) {
+    return "1/0";
+  }
+  if (Object.is(value, -Infinity)) {
+    return "-1/0";
+  }
+  return String(value);
+}
 function serializeTree(ctx, [type, value, id]) {
+  function serializeAssignments(targetRef, [keys, values, size]) {
+    ctx.stack.push(targetRef);
+    const mainAssignments = [];
+    for (let i = 0; i < size; i++) {
+      const parentStack = ctx.stack;
+      ctx.stack = [];
+      const refParam = serializeTree(ctx, values[i]);
+      ctx.stack = parentStack;
+      const key = keys[i];
+      const check = Number(key);
+      const parentAssignment = ctx.assignments;
+      ctx.assignments = mainAssignments;
+      if (check >= 0 || Number.isNaN(check) && /^([$A-Z_][0-9A-Z_$]*)$/i.test(key)) {
+        if (!Number.isNaN(check)) {
+          createObjectComputedAssign(ctx, targetRef, key, refParam);
+        } else {
+          createObjectIdentifierAssign(ctx, targetRef, key, refParam);
+        }
+      } else {
+        createObjectComputedAssign(ctx, targetRef, quote(key), refParam);
+      }
+      ctx.assignments = parentAssignment;
+    }
+    ctx.stack.pop();
+    return resolveAssignments(mainAssignments);
+  }
+  function serializeObject(sourceID, [keys, values, size]) {
+    let result = "";
+    ctx.stack.push(sourceID);
+    for (let i = 0; i < size; i++) {
+      const key = keys[i];
+      const val = values[i];
+      const check = Number(key);
+      if (check >= 0 || Number.isNaN(check) && /^([$A-Z_][0-9A-Z_$]*)$/i.test(key)) {
+        if (isReferenceInStack(ctx, val)) {
+          const refParam = getRefParam(ctx, val[1]);
+          if (!Number.isNaN(check)) {
+            createObjectComputedAssign(ctx, sourceID, key, refParam);
+          } else {
+            createObjectIdentifierAssign(ctx, sourceID, key, refParam);
+          }
+        } else {
+          result += `${key}:${serializeTree(ctx, val)},`;
+        }
+      } else if (isReferenceInStack(ctx, val)) {
+        const refParam = getRefParam(ctx, val[1]);
+        createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
+      } else {
+        result += `${quote(key)}:${serializeTree(ctx, val)},`;
+      }
+    }
+    ctx.stack.pop();
+    return `{${result.substring(0, result.length - 1)}}`;
+  }
   switch (type) {
     case 0 /* Primitive */:
-      return serializePrimitive(value);
+      return serializePrimitive(ctx, value);
     case 1 /* Reference */:
       return getRefParam(ctx, value);
     case 9 /* Promise */: {
@@ -643,38 +955,46 @@ function serializeTree(ctx, [type, value, id]) {
     case 3 /* RegExp */:
       return assignRef(ctx, id, String(value));
     case 13 /* TypedArray */: {
-      const values = [...value.array].map(serializePrimitive).join(",");
-      let args = `[${values}]`;
-      if (value.array.byteOffset !== 0) {
-        args += `,${value.array.byteOffset}`;
+      let values = "";
+      for (let i = 0, len = value[1].length; i < len; i++) {
+        values += `${serializePrimitive(ctx, value[1][i])},`;
       }
-      return assignRef(ctx, id, `new ${value.constructor}(${args})`);
+      let args = values ? `[${values.substring(0, values.length - 1)}]` : "[]";
+      if (value[1].byteOffset !== 0) {
+        args += `,${value[1].byteOffset}`;
+      }
+      return assignRef(ctx, id, `new ${value[0]}(${args})`);
     }
     case 4 /* Set */: {
       let serialized = "new Set";
-      if (value.length) {
-        const values = [];
+      const size = value.length;
+      if (size) {
+        let result = "";
         ctx.stack.push(id);
-        for (const item of value) {
+        for (let i = 0; i < size; i++) {
+          const item = value[i];
           if (isReferenceInStack(ctx, item)) {
             createSetAdd(ctx, id, getRefParam(ctx, item[1]));
           } else {
-            values.push(serializeTree(ctx, item));
+            result += `${serializeTree(ctx, item)},`;
           }
         }
         ctx.stack.pop();
-        if (values.length) {
-          serialized += `([${values.join(",")}])`;
+        if (result) {
+          serialized += `([${result.substring(0, result.length - 1)}])`;
         }
       }
       return assignRef(ctx, id, serialized);
     }
     case 5 /* Map */: {
       let serialized = "new Map";
-      if (value.length) {
-        const values = [];
+      const size = value[2];
+      if (size) {
+        let result = "";
         ctx.stack.push(id);
-        for (const [key, val] of value) {
+        for (let i = 0; i < size; i++) {
+          const key = value[0][i];
+          const val = value[1][i];
           if (isReferenceInStack(ctx, key)) {
             const keyRef = getRefParam(ctx, key[1]);
             if (isReferenceInStack(ctx, val)) {
@@ -693,20 +1013,21 @@ function serializeTree(ctx, [type, value, id]) {
             createMapSet(ctx, id, serializeTree(ctx, key), valueRef);
             ctx.stack = parent;
           } else {
-            values.push(`[${serializeTree(ctx, key)},${serializeTree(ctx, val)}]`);
+            result += `[${serializeTree(ctx, key)},${serializeTree(ctx, val)}],`;
           }
         }
         ctx.stack.pop();
-        if (values.length) {
-          serialized += `([${values.join(",")}])`;
+        if (result) {
+          serialized += `([${result.substring(0, result.length - 1)}])`;
         }
       }
       return assignRef(ctx, id, serialized);
     }
     case 6 /* Array */: {
+      const size = value.length;
       let values = "";
       ctx.stack.push(id);
-      for (let i = 0, len = value.length; i < len; i++) {
+      for (let i = 0; i < size; i++) {
         const item = value[i];
         if (i in value) {
           if (isReferenceInStack(ctx, item)) {
@@ -714,7 +1035,7 @@ function serializeTree(ctx, [type, value, id]) {
             values += ",";
           } else {
             values += serializeTree(ctx, item);
-            if (i < value.length - 1) {
+            if (i < size - 1) {
               values += ",";
             }
           }
@@ -726,74 +1047,93 @@ function serializeTree(ctx, [type, value, id]) {
       return assignRef(ctx, id, `[${values}]`);
     }
     case 11 /* AggregateError */: {
-      const args = [serializeTree(ctx, value.errors), quote(value.message)];
-      if (value.cause) {
-        args.push(serializeTree(ctx, value.cause));
-      }
-      let serialized = `new AggregateError(${args.join(",")})`;
-      if (value.options) {
-        const options = serializeTree(ctx, value.options);
-        serialized = `Object.assign(${serialized},${options})`;
+      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("object-assign")) {
+          const options = serializeObject(id, value[1]);
+          serialized = `Object.assign(${serialized},${options})`;
+        } else {
+          markRef(ctx, id);
+          const assignments = serializeAssignments(id, value[1]);
+          if (assignments) {
+            const ref = getRefParam(ctx, id);
+            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+          }
+        }
       }
       return assignRef(ctx, id, serialized);
     }
     case 10 /* Error */: {
-      const args = [quote(value.message)];
-      if (value.cause) {
-        args.push(serializeTree(ctx, value.cause));
-      }
-      let serialized = `new ${value.constructor}(${args.join(",")})`;
-      if (value.options) {
-        const options = serializeTree(ctx, value.options);
-        serialized = `Object.assign(${serialized},${options})`;
+      let serialized = `new ${value[0]}(${quote(value[1])})`;
+      if (value[2]) {
+        if (ctx.features.has("object-assign")) {
+          const options = serializeObject(id, value[2]);
+          serialized = `Object.assign(${serialized},${options})`;
+        } else {
+          markRef(ctx, id);
+          const assignments = serializeAssignments(id, value[2]);
+          if (assignments) {
+            const ref = getRefParam(ctx, id);
+            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+          }
+        }
       }
       return assignRef(ctx, id, serialized);
     }
     case 12 /* Iterable */: {
       const parent = ctx.stack;
       ctx.stack = [];
-      const values = serializeTree(ctx, value.items);
+      const values = serializeTree(ctx, value[1]);
       ctx.stack = parent;
-      let serialized = `{[Symbol.iterator]:()=>${values}.values()}`;
-      if (value.options) {
-        ctx.stack.push(id);
-        const options = serializeTree(ctx, value.options);
-        ctx.stack.pop();
-        serialized = `Object.assign(${serialized},${options})`;
+      let serialized;
+      if (ctx.features.has("array-values")) {
+        serialized = `${values}.values()`;
+      } else {
+        serialized = `${values}[Symbol.iterator]()`;
       }
-      return assignRef(ctx, id, serialized);
-    }
-    case 8 /* NullConstructor */:
-    case 7 /* Object */: {
-      const values = [];
-      ctx.stack.push(id);
-      for (const [key, val] of Object.entries(value)) {
-        const check = Number(key);
-        if (check >= 0 || Number.isNaN(check) && /^([$A-Z_][0-9A-Z_$]*)$/i.test(key)) {
-          if (isReferenceInStack(ctx, val)) {
-            const refParam = getRefParam(ctx, val[1]);
-            if (!Number.isNaN(check)) {
-              createObjectComputedAssign(ctx, id, key, refParam);
-            } else {
-              createObjectIdentifierAssign(ctx, id, key, refParam);
-            }
-          } else {
-            values.push(`${key}:${serializeTree(ctx, val)}`);
-          }
-        } else if (isReferenceInStack(ctx, val)) {
-          const refParam = getRefParam(ctx, val[1]);
-          createObjectComputedAssign(ctx, id, quote(key), refParam);
+      if (ctx.features.has("arrow-function")) {
+        serialized = `{[Symbol.iterator]:()=>${serialized}}`;
+      } else if (ctx.features.has("method-shorthand")) {
+        serialized = `{[Symbol.iterator](){return ${serialized}}}`;
+      } else {
+        serialized = `{[Symbol.iterator]:function(){return ${serialized}}}`;
+      }
+      if (value[0]) {
+        if (ctx.features.has("object-assign")) {
+          const options = serializeObject(id, value[0]);
+          serialized = `Object.assign(${serialized},${options})`;
         } else {
-          values.push(`${quote(key)}:${serializeTree(ctx, val)}`);
+          markRef(ctx, id);
+          const assignments = serializeAssignments(id, value[0]);
+          if (assignments) {
+            const ref = getRefParam(ctx, id);
+            return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+          }
         }
       }
-      ctx.stack.pop();
-      let serialized = `{${values.join(",")}}`;
-      if (type === 8 /* NullConstructor */) {
-        serialized = `Object.assign(Object.create(null),${serialized})`;
+      return assignRef(ctx, id, serialized);
+    }
+    case 8 /* NullConstructor */: {
+      let serialized = "Object.create(null)";
+      if (ctx.features.has("object-assign")) {
+        const fields = serializeObject(id, value);
+        if (fields !== "{}") {
+          serialized = `Object.assign(${serialized},${fields})`;
+        }
+      } else {
+        markRef(ctx, id);
+        const assignments = serializeAssignments(id, value);
+        if (assignments) {
+          const ref = getRefParam(ctx, id);
+          return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
+        }
       }
       return assignRef(ctx, id, serialized);
     }
+    case 7 /* Object */:
+      return assignRef(ctx, id, serializeObject(id, value));
     default:
       throw new Error("Unsupported type");
   }
@@ -802,33 +1142,42 @@ function serializeTree(ctx, [type, value, id]) {
 // src/index.ts
 function finalize(ctx, source, result) {
   if (ctx.vars.length) {
-    const index = getRefParam(ctx, createRef(ctx, source));
     const patches = resolvePatches(ctx);
-    const params = ctx.vars.length > 1 ? `(${ctx.vars.join(",")})` : ctx.vars[0];
-    if (result.startsWith(`${index}=`)) {
-      return `(${params}=>(${result},${patches}${index}))()`;
+    let body = result;
+    if (patches) {
+      const index = getRefParam(ctx, createRef(ctx, source));
+      if (result.startsWith(`${index}=`)) {
+        body = `${result},${patches}${index}`;
+      } else {
+        body = `${index}=${result},${patches}${index}`;
+      }
+    }
+    let params = ctx.vars.length > 1 ? ctx.vars.join(",") : ctx.vars[0];
+    if (ctx.features.has("arrow-function")) {
+      params = ctx.vars.length > 1 || ctx.vars.length === 0 ? `(${params})` : params;
+      return `(${params}=>(${body}))()`;
     }
-    return `(${params}=>(${index}=${result},${patches}${index}))()`;
+    return `(function(${params}){return ${body}})()`;
   }
   if (source.constructor === Object) {
     return `(${result})`;
   }
   return result;
 }
-function serialize(source) {
+function serialize(source, options) {
+  const ctx = createSerializationContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(source);
+    return serializePrimitive(ctx, source);
   }
-  const ctx = createSerializationContext();
   const tree = generateTreeSync(ctx, source);
   const result = serializeTree(ctx, tree);
   return finalize(ctx, source, result);
 }
-async function serializeAsync(source) {
+async function serializeAsync(source, options) {
+  const ctx = createSerializationContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(source);
+    return serializePrimitive(ctx, source);
   }
-  const ctx = createSerializationContext();
   const tree = await generateTreeAsync(ctx, source);
   const result = serializeTree(ctx, tree);
   return finalize(ctx, source, result);