seroval 0.4.0-alpha.2 → 0.4.0-alpha.3

package/dist/esm/development/index.mjs

@@ -552,27 +552,30 @@ function generateSemiPrimitiveValue(ctx, current, 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)) {
@@ -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;
@@ -680,27 +689,30 @@ function generateTreeSync(ctx, current) {
   throw new Error("Unsupported value");
 }
 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)) {
@@ -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;
@@ -859,7 +877,7 @@ 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 (IDENTIFIER_CHECK.test(key) || check >= 0) {
       if (!Number.isNaN(check)) {
         createObjectComputedAssign(ctx, targetRef, key, refParam);
       } else {
@@ -880,20 +898,20 @@ 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]);
+    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 {
           createObjectIdentifierAssign(ctx, sourceID, key, refParam);
         }
       } else {
-        result += `${key}:${serializeTree(ctx, val)},`;
+        createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
       }
-    } else if (isReferenceInStack(ctx, val)) {
-      const refParam = getRefParam(ctx, val[1]);
-      createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
+    } else if (isIdentifier) {
+      result += `${key}:${serializeTree(ctx, val)},`;
     } else {
       result += `${quote(key)}:${serializeTree(ctx, val)},`;
     }