seroval 1.4.2 → 1.5.0

package/dist/cjs/development/index.cjs

@@ -826,13 +826,29 @@ function createStreamReturnNode(id, parsed) {
     NIL
   );
 }
+function createSequenceNode(id, sequence, throwAt, doneAt) {
+  return createSerovalNode(
+    35 /* Sequence */,
+    id,
+    throwAt,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    sequence,
+    NIL,
+    NIL,
+    NIL,
+    doneAt
+  );
+}
 
 // src/core/errors.ts
 var { toString: objectToString } = Object.prototype;
 function getErrorMessageDev(type, cause) {
   if (cause instanceof Error) {
     return `Seroval caught an error during the ${type} process.
-  
+
 ${cause.name}
 ${cause.message}
 
@@ -1163,6 +1179,43 @@ var ARRAY_BUFFER_CONSTRUCTOR = (b64) => {
 };
 var SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR = /* @__PURE__ */ ARRAY_BUFFER_CONSTRUCTOR.toString();
 
+// src/core/sequence.ts
+function isSequence(value) {
+  return "__SEROVAL_SEQUENCE__" in value;
+}
+function createSequence(values, throwAt, doneAt) {
+  return {
+    __SEROVAL_SEQUENCE__: true,
+    v: values,
+    t: throwAt,
+    d: doneAt
+  };
+}
+function createSequenceFromIterable(source) {
+  const values = [];
+  let throwsAt = -1;
+  let doneAt = -1;
+  const iterator = source[SYM_ITERATOR]();
+  while (true) {
+    try {
+      const value = iterator.next();
+      values.push(value.value);
+      if (value.done) {
+        doneAt = values.length - 1;
+        break;
+      }
+    } catch (error) {
+      throwsAt = values.length;
+      values.push(error);
+    }
+  }
+  return createSequence(values, throwsAt, doneAt);
+}
+var createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
+function sequenceToIterator(sequence) {
+  return createIterator(sequence);
+}
+
 // src/core/special-reference.ts
 var ITERATOR = {};
 var ASYNC_ITERATOR = {};
@@ -1220,36 +1273,6 @@ function streamToAsyncIterable(stream) {
   );
 }
 
-// src/core/utils/iterator-to-sequence.ts
-function iteratorToSequence(source) {
-  const values = [];
-  let throwsAt = -1;
-  let doneAt = -1;
-  const iterator = source[SYM_ITERATOR]();
-  while (true) {
-    try {
-      const value = iterator.next();
-      values.push(value.value);
-      if (value.done) {
-        doneAt = values.length - 1;
-        break;
-      }
-    } catch (error) {
-      throwsAt = values.length;
-      values.push(error);
-    }
-  }
-  return {
-    v: values,
-    t: throwsAt,
-    d: doneAt
-  };
-}
-var createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
-function sequenceToIterator(sequence) {
-  return createIterator(sequence);
-}
-
 // src/core/utils/promise-to-result.ts
 async function promiseToResult(current) {
   try {
@@ -1494,7 +1517,9 @@ async function parseProperties(ctx, depth, properties) {
         await parseAsync(
           ctx,
           depth,
-          iteratorToSequence(properties)
+          createSequenceFromIterable(
+            properties
+          )
         )
       )
     );
@@ -1686,6 +1711,13 @@ async function parseStream(ctx, depth, id, current) {
     )
   );
 }
+async function parseSequence(ctx, depth, id, current) {
+  const nodes = [];
+  for (let i = 0, len = current.v.length; i < len; i++) {
+    nodes[i] = await parseAsync(ctx, depth, current.v[i]);
+  }
+  return createSequenceNode(id, nodes, current.t, current.d);
+}
 async function parseObjectAsync(ctx, depth, id, current) {
   if (Array.isArray(current)) {
     return parseArray(ctx, depth, id, current);
@@ -1693,6 +1725,9 @@ async function parseObjectAsync(ctx, depth, id, current) {
   if (isStream(current)) {
     return parseStream(ctx, depth, id, current);
   }
+  if (isSequence(current)) {
+    return parseSequence(ctx, depth, id, current);
+  }
   const currentClass = current.constructor;
   if (currentClass === OpaqueReference) {
     return parseAsync(
@@ -2307,6 +2342,17 @@ function deserializeAsyncIteratorFactory(ctx, depth, node) {
   deserialize(ctx, depth, node.a[1]);
   return NIL;
 }
+function deserializeSequence(ctx, depth, node) {
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    createSequence([], node.s, node.l)
+  );
+  for (let i = 0, len = node.a.length; i < len; i++) {
+    result.v[i] = deserialize(ctx, depth, node.a[i]);
+  }
+  return result;
+}
 function deserialize(ctx, depth, node) {
   if (depth > ctx.base.depthLimit) {
     throw new SerovalDepthLimitError(ctx.base.depthLimit);
@@ -2383,6 +2429,8 @@ function deserialize(ctx, depth, node) {
     case 29 /* AsyncIteratorFactory */:
       return deserializeAsyncIteratorFactory(ctx, depth, node);
     // case SerovalNodeType.SpecialReference:
+    case 35 /* Sequence */:
+      return deserializeSequence(ctx, depth, node);
     default:
       throw new SerovalUnsupportedNodeError(node);
   }
@@ -2647,6 +2695,9 @@ function createArrayAssign(ctx, ref, index, value) {
 function createObjectAssign(ctx, ref, key, value) {
   createAssignment(ctx.base, getRefParam(ctx, ref) + "." + key, value);
 }
+function createSequenceAssign(ctx, ref, index, value) {
+  createAssignment(ctx.base, getRefParam(ctx, ref) + ".v[" + index + "]", value);
+}
 function isIndexedValueInStack(ctx, node) {
   return node.t === 4 /* IndexedValue */ && ctx.stack.includes(node.i);
 }
@@ -3120,6 +3171,38 @@ function serializeStreamThrow(ctx, node) {
 function serializeStreamReturn(ctx, node) {
   return getRefParam(ctx, node.i) + ".return(" + serialize(ctx, node.f) + ")";
 }
+function serializeSequenceItem(ctx, id, index, item) {
+  const base = ctx.base;
+  if (isIndexedValueInStack(base, item)) {
+    markSerializerRef(base, id);
+    createSequenceAssign(
+      ctx,
+      id,
+      index,
+      getRefParam(ctx, item.i)
+    );
+    return "";
+  }
+  return serialize(ctx, item);
+}
+function serializeSequence(ctx, node) {
+  const items = node.a;
+  const size = items.length;
+  const id = node.i;
+  if (size > 0) {
+    ctx.base.stack.push(id);
+    let result = serializeSequenceItem(ctx, id, 0, items[0]);
+    for (let i = 1, item = result; i < size; i++) {
+      item = serializeSequenceItem(ctx, id, i, items[i]);
+      result += (item && result && ",") + item;
+    }
+    ctx.base.stack.pop();
+    if (result) {
+      return "{__SEROVAL_SEQUENCE__:!0,v:[" + result + "],t:" + node.s + ",d:" + node.l + "}";
+    }
+  }
+  return "{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}";
+}
 function serializeAssignable(ctx, node) {
   switch (node.t) {
     case 17 /* WKSymbol */:
@@ -3161,6 +3244,8 @@ function serializeAssignable(ctx, node) {
       return serializePlugin(ctx, node);
     case 26 /* SpecialReference */:
       return SPECIAL_REF_STRING[node.s];
+    case 35 /* Sequence */:
+      return serializeSequence(ctx, node);
     default:
       throw new SerovalUnsupportedNodeError(node);
   }
@@ -3334,7 +3419,9 @@ function parseProperties2(ctx, depth, properties) {
         parseSOS(
           ctx,
           depth,
-          iteratorToSequence(properties)
+          createSequenceFromIterable(
+            properties
+          )
         )
       )
     );
@@ -3573,6 +3660,13 @@ function parsePlugin2(ctx, depth, id, current) {
   }
   return NIL;
 }
+function parseSequence2(ctx, depth, id, current) {
+  const nodes = [];
+  for (let i = 0, len = current.v.length; i < len; i++) {
+    nodes[i] = parseSOS(ctx, depth, current.v[i]);
+  }
+  return createSequenceNode(id, nodes, current.t, current.d);
+}
 function parseObjectPhase2(ctx, depth, id, current, currentClass) {
   switch (currentClass) {
     case Object:
@@ -3685,6 +3779,9 @@ function parseObject(ctx, depth, id, current) {
   if (isStream(current)) {
     return parseStream2(ctx, depth, id, current);
   }
+  if (isSequence(current)) {
+    return parseSequence2(ctx, depth, id, current);
+  }
   const currentClass = current.constructor;
   if (currentClass === OpaqueReference) {
     return parseSOS(