seroval 0.4.0-alpha.1 → 0.4.0-alpha.3

package/dist/esm/development/index.mjs

@@ -551,30 +551,33 @@ function generateSemiPrimitiveValue(ctx, 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 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[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key];
+      deferredSize++;
+    } else {
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key]);
+      nodesSize++;
     }
-    return [keyNodes, valueNodes, keys.length];
   }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
+  }
+  return [keyNodes, valueNodes, size];
+}
+function generateTreeSync(ctx, current) {
   if (isPrimitive(current)) {
     return [0 /* Primitive */, current];
   }
@@ -588,42 +591,48 @@ function generateTreeSync(ctx, current) {
   }
   if (constructorCheck(current, Set)) {
     assert(ctx.features.has(8 /* Set */), 'Unsupported type "Set"');
-    const nodes = [];
-    const deferred = [];
+    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];
   }
   if (constructorCheck(current, Map)) {
     assert(ctx.features.has(4 /* Map */), 'Unsupported type "Map"');
-    const keyNodes = [];
-    const valueNodes = [];
-    const deferredKey = [];
-    const deferredValue = [];
+    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 [5 /* Map */, [keyNodes, valueNodes, len], id];
   }
   if (Array.isArray(current)) {
     const size = current.length;
@@ -647,13 +656,13 @@ function generateTreeSync(ctx, current) {
   }
   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],
@@ -665,7 +674,7 @@ function generateTreeSync(ctx, current) {
     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];
   }
@@ -673,36 +682,39 @@ 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 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[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key];
+      deferredSize++;
+    } else {
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key]);
+      nodesSize++;
     }
-    return [keyNodes, valueNodes, keys.length];
   }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
+  }
+  return [keyNodes, valueNodes, size];
+}
+async function generateTreeAsync(ctx, current) {
   if (isPrimitive(current)) {
     return [0 /* Primitive */, current];
   }
@@ -724,42 +736,48 @@ async function generateTreeAsync(ctx, current) {
   }
   if (constructorCheck(current, Set)) {
     assert(ctx.features.has(8 /* Set */), 'Unsupported type "Set"');
-    const nodes = [];
-    const deferred = [];
+    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];
   }
   if (constructorCheck(current, Map)) {
     assert(ctx.features.has(4 /* Map */), 'Unsupported type "Map"');
-    const keyNodes = [];
-    const valueNodes = [];
-    const deferredKey = [];
-    const deferredValue = [];
+    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 [5 /* Map */, [keyNodes, valueNodes, len], id];
   }
   if (Array.isArray(current)) {
     const size = current.length;
@@ -784,13 +802,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,7 +819,7 @@ async function generateTreeAsync(ctx, current) {
     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];
   }
@@ -809,7 +827,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
     ];
   }
@@ -846,61 +864,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 (IDENTIFIER_CHECK.test(key) || check >= 0) {
+      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);
+    const isIdentifier = IDENTIFIER_CHECK.test(key) || check >= 0;
+    if (isReferenceInStack(ctx, val)) {
+      const refParam = getRefParam(ctx, val[1]);
+      if (isIdentifier) {
+        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)},`;
+        createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
       }
+    } else if (isIdentifier) {
+      result += `${key}:${serializeTree(ctx, val)},`;
+    } 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);
@@ -1020,11 +1039,11 @@ function serializeTree(ctx, [type, value, id]) {
       ctx.stack.pop();
       if (value[1]) {
         if (ctx.features.has(6 /* ObjectAssign */)) {
-          const options = serializeObject(id, value[1]);
+          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})`;
@@ -1037,11 +1056,11 @@ function serializeTree(ctx, [type, value, id]) {
       let serialized = `new ${value[0]}(${quote(value[1])})`;
       if (value[2]) {
         if (ctx.features.has(6 /* ObjectAssign */)) {
-          const options = serializeObject(id, value[2]);
+          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})`;
@@ -1070,11 +1089,11 @@ function serializeTree(ctx, [type, value, id]) {
       }
       if (value[0]) {
         if (ctx.features.has(6 /* ObjectAssign */)) {
-          const options = serializeObject(id, value[0]);
+          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})`;
@@ -1086,13 +1105,13 @@ function serializeTree(ctx, [type, value, id]) {
     case 8 /* NullConstructor */: {
       let serialized = "Object.create(null)";
       if (ctx.features.has(6 /* ObjectAssign */)) {
-        const fields = serializeObject(id, value);
+        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})`;
@@ -1101,7 +1120,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");
   }