seroval 0.4.0-alpha.0 → 0.4.0-alpha.2

package/dist/esm/development/index.mjs

@@ -19,65 +19,6 @@ function isIterable(obj) {
   return !!obj && typeof obj === "object" && !isIterableBuiltin(obj) && Symbol.iterator in obj && typeof obj[Symbol.iterator] === "function";
 }
 
-// src/quote.ts
-function quote(str) {
-  let result = "";
-  let lastPos = 0;
-  for (let i = 0, len = str.length; i < len; i++) {
-    let replacement;
-    switch (str[i]) {
-      case '"':
-        replacement = '\\"';
-        break;
-      case "\\":
-        replacement = "\\\\";
-        break;
-      case "<":
-        replacement = "\\x3C";
-        break;
-      case "\n":
-        replacement = "\\n";
-        break;
-      case "\r":
-        replacement = "\\r";
-        break;
-      case "\u2028":
-        replacement = "\\u2028";
-        break;
-      case "\u2029":
-        replacement = "\\u2029";
-        break;
-      default:
-        continue;
-    }
-    result += str.slice(lastPos, i) + replacement;
-    lastPos = i + 1;
-  }
-  if (lastPos === 0) {
-    result = str;
-  } else {
-    result += str.slice(lastPos);
-  }
-  return `"${result}"`;
-}
-
-// src/get-identifier.ts
-var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
-var REF_START_CHARS_LEN = REF_START_CHARS.length;
-var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
-var REF_CHARS_LEN = REF_CHARS.length;
-function getIdentifier(index) {
-  let mod = index % REF_START_CHARS_LEN;
-  let ref = REF_START_CHARS[mod];
-  index = (index - mod) / REF_START_CHARS_LEN;
-  while (index > 0) {
-    mod = index % REF_CHARS_LEN;
-    ref += REF_CHARS[mod];
-    index = (index - mod) / REF_CHARS_LEN;
-  }
-  return ref;
-}
-
 // src/assert.ts
 function assert(cond, error) {
   if (!cond) {
@@ -98,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
-  "aggregate-error": {
+  [0 /* AggregateError */]: {
     es: [2021, 0, 0],
     chrome: [85, 0, 0],
     edge: [85, 0, 0],
@@ -111,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
-  "array-values": {
+  [1 /* ArrayPrototypeValues */]: {
     es: [6, 0, 0],
     chrome: [66, 0, 0],
     edge: [14, 0, 0],
@@ -124,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
-  "arrow-function": {
+  [2 /* ArrowFunction */]: {
     es: [6, 0, 0],
     chrome: [45, 0, 0],
     edge: [12, 0, 0],
@@ -137,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
-  bigint: {
+  [3 /* BigInt */]: {
     es: [2020, 0, 0],
     chrome: [67, 0, 0],
     edge: [79, 0, 0],
@@ -150,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
-  map: {
+  [4 /* Map */]: {
     es: [6, 0, 0],
     chrome: [38, 0, 0],
     edge: [12, 0, 0],
@@ -163,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
-  "method-shorthand": {
+  [5 /* MethodShorthand */]: {
     es: [6, 0, 0],
     chrome: [39, 0, 0],
     edge: [12, 0, 0],
@@ -176,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
-  "object-assign": {
+  [6 /* ObjectAssign */]: {
     es: [6, 0, 0],
     chrome: [45, 0, 0],
     edge: [12, 0, 0],
@@ -189,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
-  promise: {
+  [7 /* Promise */]: {
     es: [6, 0, 0],
     chrome: [32, 0, 0],
     edge: [12, 0, 0],
@@ -202,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
-  set: {
+  [8 /* Set */]: {
     es: [6, 0, 0],
     chrome: [38, 0, 0],
     edge: [12, 0, 0],
@@ -215,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
-  "symbol-iterator": {
+  [9 /* SymbolIterator */]: {
     es: [6, 0, 0],
     chrome: [43, 0, 0],
     edge: [12, 0, 0],
@@ -228,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
-  "typed-arrays": {
+  [10 /* TypedArray */]: {
     es: [6, 0, 0],
     chrome: [7, 0, 0],
     edge: [12, 0, 0],
@@ -259,26 +200,82 @@ function getTargetVersions(targets) {
   }
   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);
+    const base = VERSION_TABLE[key];
+    let flag = true;
+    for (const [platform, version] of parsed) {
+      const baseVersion = base[platform];
+      flag = flag && !!baseVersion && compareVersion(baseVersion, version) <= 0;
+    }
+    if (flag) {
+      flags.add(Number(key));
     }
   }
   return flags;
 }
 
+// src/quote.ts
+function quote(str) {
+  let result = "";
+  let lastPos = 0;
+  for (let i = 0, len = str.length; i < len; i++) {
+    let replacement;
+    switch (str[i]) {
+      case '"':
+        replacement = '\\"';
+        break;
+      case "\\":
+        replacement = "\\\\";
+        break;
+      case "<":
+        replacement = "\\x3C";
+        break;
+      case "\n":
+        replacement = "\\n";
+        break;
+      case "\r":
+        replacement = "\\r";
+        break;
+      case "\u2028":
+        replacement = "\\u2028";
+        break;
+      case "\u2029":
+        replacement = "\\u2029";
+        break;
+      default:
+        continue;
+    }
+    result += str.slice(lastPos, i) + replacement;
+    lastPos = i + 1;
+  }
+  if (lastPos === 0) {
+    result = str;
+  } else {
+    result += str.slice(lastPos);
+  }
+  return `"${result}"`;
+}
+
+// src/get-identifier.ts
+var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
+var REF_START_CHARS_LEN = REF_START_CHARS.length;
+var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
+var REF_CHARS_LEN = REF_CHARS.length;
+function getIdentifier(index) {
+  let mod = index % REF_START_CHARS_LEN;
+  let ref = REF_START_CHARS[mod];
+  index = (index - mod) / REF_START_CHARS_LEN;
+  while (index > 0) {
+    mod = index % REF_CHARS_LEN;
+    ref += REF_CHARS[mod];
+    index = (index - mod) / REF_CHARS_LEN;
+  }
+  return ref;
+}
+
 // src/tree.ts
 var DEFAULT_OPTIONS = {
   target: "es2023"
@@ -503,81 +500,81 @@ function generateSemiPrimitiveValue(ctx, current, id) {
     return [3 /* RegExp */, current, id];
   }
   if (constructorCheck(current, Int8Array)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int8Array"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int8Array"');
     return [13 /* TypedArray */, ["Int8Array", current], id];
   }
   if (constructorCheck(current, Int16Array)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int16Array"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int16Array"');
     return [13 /* TypedArray */, ["Int16Array", current], id];
   }
   if (constructorCheck(current, Int32Array)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Int32Array"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Int32Array"');
     return [13 /* TypedArray */, ["Int32Array", current], id];
   }
   if (constructorCheck(current, Uint8Array)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint8Array"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint8Array"');
     return [13 /* TypedArray */, ["Uint8Array", current], id];
   }
   if (constructorCheck(current, Uint16Array)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint16Array"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint16Array"');
     return [13 /* TypedArray */, ["Uint16Array", current], id];
   }
   if (constructorCheck(current, Uint32Array)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint32Array"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint32Array"');
     return [13 /* TypedArray */, ["Uint32Array", current], id];
   }
   if (constructorCheck(current, Uint8ClampedArray)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Uint8ClampedArray"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Uint8ClampedArray"');
     return [13 /* TypedArray */, ["Uint8ClampedArray", current], id];
   }
   if (constructorCheck(current, Float32Array)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Float32Array"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Float32Array"');
     return [13 /* TypedArray */, ["Float32Array", current], id];
   }
   if (constructorCheck(current, Float64Array)) {
-    assert(ctx.features.has("typed-arrays"), 'Unsupported value type "Float64Array"');
+    assert(ctx.features.has(10 /* TypedArray */), 'Unsupported value type "Float64Array"');
     return [13 /* TypedArray */, ["Float64Array", current], id];
   }
   if (constructorCheck(current, BigInt64Array)) {
     assert(
-      ctx.features.has("typed-arrays") && ctx.features.has("bigint"),
+      ctx.features.has(10 /* TypedArray */) && ctx.features.has(3 /* BigInt */),
       'Unsupported value type "BigInt64Array"'
     );
     return [13 /* TypedArray */, ["BigInt64Array", current], id];
   }
   if (constructorCheck(current, BigUint64Array)) {
     assert(
-      ctx.features.has("typed-arrays") && ctx.features.has("bigint"),
+      ctx.features.has(10 /* TypedArray */) && ctx.features.has(3 /* 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]));
+function serializePropertiesSync(ctx, 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]));
     }
-    return [keyNodes, valueNodes, keys.length];
   }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes.push(deferredKeys[i]);
+    valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
+  }
+  return [keyNodes, valueNodes, keys.length];
+}
+function generateTreeSync(ctx, current) {
   if (isPrimitive(current)) {
     return [0 /* Primitive */, current];
   }
@@ -590,7 +587,7 @@ function generateTreeSync(ctx, current) {
     return semiPrimitive;
   }
   if (constructorCheck(current, Set)) {
-    assert(ctx.features.has("set"), 'Unsupported type "Set"');
+    assert(ctx.features.has(8 /* Set */), 'Unsupported type "Set"');
     const nodes = [];
     const deferred = [];
     for (const item of current.keys()) {
@@ -606,7 +603,7 @@ function generateTreeSync(ctx, current) {
     return [4 /* Set */, nodes, id];
   }
   if (constructorCheck(current, Map)) {
-    assert(ctx.features.has("map"), 'Unsupported type "Map"');
+    assert(ctx.features.has(4 /* Map */), 'Unsupported type "Map"');
     const keyNodes = [];
     const valueNodes = [];
     const deferredKey = [];
@@ -648,15 +645,15 @@ function generateTreeSync(ctx, current) {
     }
     return [6 /* Array */, nodes, id];
   }
-  if (current instanceof AggregateError && ctx.features.has("aggregate-error")) {
+  if (current instanceof AggregateError && ctx.features.has(0 /* AggregateError */)) {
     const options = getErrorOptions(current);
-    const optionsNode = options ? serializeProperties(options) : void 0;
+    const optionsNode = options ? serializePropertiesSync(ctx, 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);
-    const optionsNode = options ? serializeProperties(options) : void 0;
+    const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
     return [
       10 /* Error */,
       [getErrorConstructor(current), current.message, optionsNode],
@@ -664,11 +661,11 @@ function generateTreeSync(ctx, current) {
     ];
   }
   if (isIterable(current)) {
-    assert(ctx.features.has("symbol-iterator"), 'Unsupported type "Iterable"');
+    assert(ctx.features.has(9 /* SymbolIterator */), 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
     return [12 /* Iterable */, [
       // Parse options first before the items
-      options ? serializeProperties(options) : void 0,
+      options ? serializePropertiesSync(ctx, options) : void 0,
       generateTreeSync(ctx, Array.from(current))
     ], id];
   }
@@ -676,36 +673,36 @@ function generateTreeSync(ctx, current) {
   if (current.constructor === Object || empty) {
     return [
       empty ? 8 /* NullConstructor */ : 7 /* Object */,
-      serializeProperties(current),
+      serializePropertiesSync(ctx, 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]));
+async function serializePropertiesAsync(ctx, 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]));
     }
-    return [keyNodes, valueNodes, keys.length];
   }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes.push(deferredKeys[i]);
+    valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
+  }
+  return [keyNodes, valueNodes, keys.length];
+}
+async function generateTreeAsync(ctx, current) {
   if (isPrimitive(current)) {
     return [0 /* Primitive */, current];
   }
@@ -718,7 +715,7 @@ async function generateTreeAsync(ctx, current) {
     return semiPrimitive;
   }
   if (isPromise(current)) {
-    assert(ctx.features.has("promise"), 'Unsupported type "Promise"');
+    assert(ctx.features.has(7 /* Promise */), 'Unsupported type "Promise"');
     return current.then(async (value) => [
       9 /* Promise */,
       await generateTreeAsync(ctx, value),
@@ -726,7 +723,7 @@ async function generateTreeAsync(ctx, current) {
     ]);
   }
   if (constructorCheck(current, Set)) {
-    assert(ctx.features.has("set"), 'Unsupported type "Set"');
+    assert(ctx.features.has(8 /* Set */), 'Unsupported type "Set"');
     const nodes = [];
     const deferred = [];
     for (const item of current.keys()) {
@@ -742,7 +739,7 @@ async function generateTreeAsync(ctx, current) {
     return [4 /* Set */, nodes, id];
   }
   if (constructorCheck(current, Map)) {
-    assert(ctx.features.has("map"), 'Unsupported type "Map"');
+    assert(ctx.features.has(4 /* Map */), 'Unsupported type "Map"');
     const keyNodes = [];
     const valueNodes = [];
     const deferredKey = [];
@@ -787,13 +784,13 @@ async function generateTreeAsync(ctx, current) {
   }
   if (current instanceof AggregateError) {
     const options = getErrorOptions(current);
-    const optionsNode = options ? await serializeProperties(options) : void 0;
+    const optionsNode = options ? await serializePropertiesAsync(ctx, 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);
-    const optionsNode = options ? await serializeProperties(options) : void 0;
+    const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
     return [
       10 /* Error */,
       [getErrorConstructor(current), current.message, optionsNode],
@@ -801,10 +798,10 @@ async function generateTreeAsync(ctx, current) {
     ];
   }
   if (isIterable(current)) {
-    assert(ctx.features.has("symbol-iterator"), 'Unsupported type "Iterable"');
+    assert(ctx.features.has(9 /* SymbolIterator */), 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
     return [12 /* Iterable */, [
-      options ? await serializeProperties(options) : void 0,
+      options ? await serializePropertiesAsync(ctx, options) : void 0,
       await generateTreeAsync(ctx, Array.from(current))
     ], id];
   }
@@ -812,7 +809,7 @@ async function generateTreeAsync(ctx, current) {
   if (current.constructor === Object || empty) {
     return [
       empty ? 8 /* NullConstructor */ : 7 /* Object */,
-      await serializeProperties(current),
+      await serializePropertiesAsync(ctx, current),
       id
     ];
   }
@@ -832,7 +829,7 @@ function serializePrimitive(ctx, value) {
     return "null";
   }
   if (typeof value === "bigint") {
-    assert(ctx.features.has("bigint"), 'Unsupported type "BigInt"');
+    assert(ctx.features.has(3 /* BigInt */), 'Unsupported type "BigInt"');
     return `${value}n`;
   }
   if (typeof value === "string") {
@@ -849,61 +846,62 @@ function serializePrimitive(ctx, value) {
   }
   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);
-        }
+var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
+function serializeAssignments(ctx, 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) && IDENTIFIER_CHECK.test(key)) {
+      if (!Number.isNaN(check)) {
+        createObjectComputedAssign(ctx, targetRef, key, refParam);
       } else {
-        createObjectComputedAssign(ctx, targetRef, quote(key), refParam);
+        createObjectIdentifierAssign(ctx, targetRef, key, refParam);
       }
-      ctx.assignments = parentAssignment;
+    } else {
+      createObjectComputedAssign(ctx, targetRef, quote(key), refParam);
     }
-    ctx.stack.pop();
-    return resolveAssignments(mainAssignments);
+    ctx.assignments = parentAssignment;
   }
-  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);
-          }
+  ctx.stack.pop();
+  return resolveAssignments(mainAssignments);
+}
+function serializeObject(ctx, 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) && IDENTIFIER_CHECK.test(key)) {
+      if (isReferenceInStack(ctx, val)) {
+        const refParam = getRefParam(ctx, val[1]);
+        if (!Number.isNaN(check)) {
+          createObjectComputedAssign(ctx, sourceID, key, refParam);
         } else {
-          result += `${key}:${serializeTree(ctx, val)},`;
+          createObjectIdentifierAssign(ctx, sourceID, key, refParam);
         }
-      } else if (isReferenceInStack(ctx, val)) {
-        const refParam = getRefParam(ctx, val[1]);
-        createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
       } else {
-        result += `${quote(key)}:${serializeTree(ctx, val)},`;
+        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)}}`;
   }
+  ctx.stack.pop();
+  return `{${result.substring(0, result.length - 1)}}`;
+}
+function serializeTree(ctx, [type, value, id]) {
   switch (type) {
     case 0 /* Primitive */:
       return serializePrimitive(ctx, value);
@@ -1022,12 +1020,12 @@ function serializeTree(ctx, [type, value, 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]);
+        if (ctx.features.has(6 /* ObjectAssign */)) {
+          const options = serializeObject(ctx, id, value[1]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
           markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[1]);
+          const assignments = serializeAssignments(ctx, id, value[1]);
           if (assignments) {
             const ref = getRefParam(ctx, id);
             return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
@@ -1039,12 +1037,12 @@ function serializeTree(ctx, [type, value, id]) {
     case 10 /* Error */: {
       let serialized = `new ${value[0]}(${quote(value[1])})`;
       if (value[2]) {
-        if (ctx.features.has("object-assign")) {
-          const options = serializeObject(id, value[2]);
+        if (ctx.features.has(6 /* ObjectAssign */)) {
+          const options = serializeObject(ctx, id, value[2]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
           markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[2]);
+          const assignments = serializeAssignments(ctx, id, value[2]);
           if (assignments) {
             const ref = getRefParam(ctx, id);
             return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
@@ -1059,25 +1057,25 @@ function serializeTree(ctx, [type, value, id]) {
       const values = serializeTree(ctx, value[1]);
       ctx.stack = parent;
       let serialized;
-      if (ctx.features.has("array-values")) {
+      if (ctx.features.has(1 /* ArrayPrototypeValues */)) {
         serialized = `${values}.values()`;
       } else {
         serialized = `${values}[Symbol.iterator]()`;
       }
-      if (ctx.features.has("arrow-function")) {
+      if (ctx.features.has(2 /* ArrowFunction */)) {
         serialized = `{[Symbol.iterator]:()=>${serialized}}`;
-      } else if (ctx.features.has("method-shorthand")) {
+      } else if (ctx.features.has(5 /* MethodShorthand */)) {
         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]);
+        if (ctx.features.has(6 /* ObjectAssign */)) {
+          const options = serializeObject(ctx, id, value[0]);
           serialized = `Object.assign(${serialized},${options})`;
         } else {
           markRef(ctx, id);
-          const assignments = serializeAssignments(id, value[0]);
+          const assignments = serializeAssignments(ctx, id, value[0]);
           if (assignments) {
             const ref = getRefParam(ctx, id);
             return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
@@ -1088,14 +1086,14 @@ function serializeTree(ctx, [type, value, id]) {
     }
     case 8 /* NullConstructor */: {
       let serialized = "Object.create(null)";
-      if (ctx.features.has("object-assign")) {
-        const fields = serializeObject(id, value);
+      if (ctx.features.has(6 /* ObjectAssign */)) {
+        const fields = serializeObject(ctx, id, value);
         if (fields !== "{}") {
           serialized = `Object.assign(${serialized},${fields})`;
         }
       } else {
         markRef(ctx, id);
-        const assignments = serializeAssignments(id, value);
+        const assignments = serializeAssignments(ctx, id, value);
         if (assignments) {
           const ref = getRefParam(ctx, id);
           return `(${assignRef(ctx, id, serialized)},${assignments}${ref})`;
@@ -1104,7 +1102,7 @@ function serializeTree(ctx, [type, value, id]) {
       return assignRef(ctx, id, serialized);
     }
     case 7 /* Object */:
-      return assignRef(ctx, id, serializeObject(id, value));
+      return assignRef(ctx, id, serializeObject(ctx, id, value));
     default:
       throw new Error("Unsupported type");
   }
@@ -1124,7 +1122,7 @@ function finalize(ctx, source, result) {
       }
     }
     let params = ctx.vars.length > 1 ? ctx.vars.join(",") : ctx.vars[0];
-    if (ctx.features.has("arrow-function")) {
+    if (ctx.features.has(2 /* ArrowFunction */)) {
       params = ctx.vars.length > 1 || ctx.vars.length === 0 ? `(${params})` : params;
       return `(${params}=>(${body}))()`;
     }