seroval 0.11.0 → 0.11.2

package/src/core/cross/stream.ts

@@ -96,7 +96,7 @@ function generateNodeList(
   for (let i = 0; i < size; i++) {
     if (i in current) {
       item = current[i];
-      if (isIterable(item)) {
+      if (isIterable(ctx, item)) {
         deferred[i] = item;
       } else {
         nodes[i] = crossParseStream(ctx, item);
@@ -146,7 +146,7 @@ function generateMapNode(
   let nodeSize = 0;
   for (const [key, value] of current.entries()) {
     // Either key or value might be an iterable
-    if (isIterable(key) || isIterable(value)) {
+    if (isIterable(ctx, key) || isIterable(ctx, value)) {
       deferredKey[deferredSize] = key;
       deferredValue[deferredSize] = value;
       deferredSize++;
@@ -188,7 +188,7 @@ function generateSetNode(
   let nodeSize = 0;
   for (const item of current.keys()) {
     // Iterables are lazy, so the evaluation must be deferred
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferred[deferredSize++] = item;
     } else {
       nodes[nodeSize++] = crossParseStream(ctx, item);
@@ -231,7 +231,7 @@ function generateProperties(
   for (const key of keys) {
     item = properties[key];
     escaped = serializeString(key);
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
@@ -281,7 +281,7 @@ function generatePlainProperties(
   for (const key of keys) {
     item = properties[key];
     escaped = serializeString(key);
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
@@ -507,57 +507,17 @@ function generateBoxedNode(
   };
 }
 
-function generateReadableStreamNode(
+function pushReadableStreamState(
   ctx: StreamingCrossParserContext,
   id: number,
-  current: ReadableStream<unknown>,
-): SerovalReadableStreamConstructorNode {
-  const reader = current.getReader();
-  pushPendingState(ctx);
-
-  function push(): void {
-    reader.read().then(
-      (data) => {
-        if (ctx.alive) {
-          if (data.done) {
-            ctx.onParse({
-              t: SerovalNodeType.ReadableStreamClose,
-              i: id,
-              s: undefined,
-              l: undefined,
-              c: undefined,
-              m: undefined,
-              p: undefined,
-              e: undefined,
-              a: undefined,
-              f: undefined,
-              b: undefined,
-              o: undefined,
-            }, false);
-            popPendingState(ctx);
-          } else {
-            ctx.onParse({
-              t: SerovalNodeType.ReadableStreamEnqueue,
-              i: id,
-              s: undefined,
-              l: undefined,
-              c: undefined,
-              m: undefined,
-              p: undefined,
-              e: undefined,
-              a: undefined,
-              f: crossParseStream(ctx, data.value),
-              b: undefined,
-              o: undefined,
-            }, false);
-            push();
-          }
-        }
-      },
-      (value) => {
-        if (ctx.alive) {
+  reader: ReadableStreamDefaultReader,
+): void {
+  reader.read().then(
+    (data) => {
+      if (ctx.alive) {
+        if (data.done) {
           ctx.onParse({
-            t: SerovalNodeType.ReadableStreamError,
+            t: SerovalNodeType.ReadableStreamClose,
             i: id,
             s: undefined,
             l: undefined,
@@ -566,17 +526,59 @@ function generateReadableStreamNode(
             p: undefined,
             e: undefined,
             a: undefined,
-            f: crossParseStream(ctx, value),
+            f: undefined,
             b: undefined,
             o: undefined,
           }, false);
           popPendingState(ctx);
+        } else {
+          ctx.onParse({
+            t: SerovalNodeType.ReadableStreamEnqueue,
+            i: id,
+            s: undefined,
+            l: undefined,
+            c: undefined,
+            m: undefined,
+            p: undefined,
+            e: undefined,
+            a: undefined,
+            f: crossParseStream(ctx, data.value),
+            b: undefined,
+            o: undefined,
+          }, false);
+          pushReadableStreamState(ctx, id, reader);
         }
-      },
-    );
-  }
+      }
+    },
+    (value) => {
+      if (ctx.alive) {
+        ctx.onParse({
+          t: SerovalNodeType.ReadableStreamError,
+          i: id,
+          s: undefined,
+          l: undefined,
+          c: undefined,
+          m: undefined,
+          p: undefined,
+          e: undefined,
+          a: undefined,
+          f: crossParseStream(ctx, value),
+          b: undefined,
+          o: undefined,
+        }, false);
+        popPendingState(ctx);
+      }
+    },
+  );
+}
 
-  push();
+function generateReadableStreamNode(
+  ctx: StreamingCrossParserContext,
+  id: number,
+  current: ReadableStream<unknown>,
+): SerovalReadableStreamConstructorNode {
+  pushPendingState(ctx);
+  pushReadableStreamState(ctx, id, current.getReader());
 
   return {
     t: SerovalNodeType.ReadableStreamConstructor,
@@ -845,7 +847,7 @@ export default function crossParseStream<T>(
 ): SerovalNode {
   const t = typeof current;
   if (ctx.features & Feature.BigInt && t === 'bigint') {
-    return createBigIntNode(ctx, current as bigint);
+    return createBigIntNode(current as bigint);
   }
   switch (t) {
     case 'boolean':

package/src/core/cross/sync.ts

@@ -71,7 +71,7 @@ function generateNodeList(ctx: CrossParserContext, current: unknown[]): SerovalS
   for (let i = 0; i < size; i++) {
     if (i in current) {
       item = current[i];
-      if (isIterable(item)) {
+      if (isIterable(ctx, item)) {
         deferred[i] = item;
       } else {
         nodes[i] = crossParseSync(ctx, item);
@@ -121,7 +121,7 @@ function generateMapNode(
   let nodeSize = 0;
   for (const [key, value] of current.entries()) {
     // Either key or value might be an iterable
-    if (isIterable(key) || isIterable(value)) {
+    if (isIterable(ctx, key) || isIterable(ctx, value)) {
       deferredKey[deferredSize] = key;
       deferredValue[deferredSize] = value;
       deferredSize++;
@@ -163,7 +163,7 @@ function generateSetNode(
   let nodeSize = 0;
   for (const item of current.keys()) {
     // Iterables are lazy, so the evaluation must be deferred
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferred[deferredSize++] = item;
     } else {
       nodes[nodeSize++] = crossParseSync(ctx, item);
@@ -206,7 +206,7 @@ function generateProperties(
   for (const key of keys) {
     item = properties[key];
     escaped = serializeString(key);
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
@@ -252,7 +252,7 @@ function generatePlainProperties(
   for (const key of keys) {
     item = properties[key];
     escaped = serializeString(key);
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
@@ -602,7 +602,7 @@ export default function crossParseSync<T>(
 ): SerovalSyncNode {
   const t = typeof current;
   if (ctx.features & Feature.BigInt && t === 'bigint') {
-    return createBigIntNode(ctx, current as bigint);
+    return createBigIntNode(current as bigint);
   }
   switch (t) {
     case 'boolean':

package/src/core/cross/web-api.ts

@@ -1,8 +1,5 @@
-import assert from '../assert';
-import { Feature } from '../compat';
 import type { CrossParserContext } from './context';
 import { serializeString } from '../string';
-import UnsupportedTypeError from '../UnsupportedTypeError';
 import { serializeArrayBuffer } from './primitives';
 import type {
   SerovalBlobNode,
@@ -15,7 +12,6 @@ export async function createBlobNode(
   id: number,
   current: Blob,
 ): Promise<SerovalBlobNode> {
-  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
   return {
     t: SerovalNodeType.Blob,
     i: id,
@@ -37,7 +33,6 @@ export async function createFileNode(
   id: number,
   current: File,
 ): Promise<SerovalFileNode> {
-  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
   return {
     t: SerovalNodeType.File,
     i: id,

package/src/core/shared.ts

@@ -1,4 +1,4 @@
-import { Feature } from './compat';
+import { BIGINT_FLAG, Feature } from './compat';
 import type {
   ErrorValue,
 } from '../types';
@@ -82,6 +82,7 @@ export function getErrorOptions(
 }
 
 export function isIterable(
+  ctx: BaseParserContext,
   value: unknown,
 ): value is Iterable<unknown> {
   if (!value || typeof value !== 'object') {
@@ -90,23 +91,48 @@ export function isIterable(
   if (Array.isArray(value)) {
     return false;
   }
-  switch (value.constructor) {
-    case Map:
-    case Set:
-    case Int8Array:
-    case Int16Array:
-    case Int32Array:
-    case Uint8Array:
-    case Uint16Array:
-    case Uint32Array:
-    case Uint8ClampedArray:
-    case Float32Array:
-    case Float64Array:
-    case BigInt64Array:
-    case BigUint64Array:
-      return false;
-    default:
-      break;
+  const currentClass = value.constructor;
+  if (ctx.features & Feature.TypedArray) {
+    switch (currentClass) {
+      case Int8Array:
+      case Int16Array:
+      case Int32Array:
+      case Uint8Array:
+      case Uint16Array:
+      case Uint32Array:
+      case Uint8ClampedArray:
+      case Float32Array:
+      case Float64Array:
+        return false;
+      default:
+        break;
+    }
+  }
+  // BigInt Typed Arrays
+  if ((ctx.features & BIGINT_FLAG) === BIGINT_FLAG) {
+    switch (currentClass) {
+      case BigInt64Array:
+      case BigUint64Array:
+        return false;
+      default:
+        break;
+    }
+  }
+  // ES Collection
+  if (ctx.features & Feature.Map && currentClass === Map) {
+    return false;
+  }
+  if (ctx.features & Feature.Set && currentClass === Set) {
+    return false;
+  }
+  if (ctx.features & Feature.WebAPI) {
+    switch (currentClass) {
+      case Headers:
+      case File:
+        return false;
+      default:
+        break;
+    }
   }
   return Symbol.iterator in value;
 }

package/src/core/tree/async.ts

@@ -96,7 +96,7 @@ async function generateNodeList(
   for (let i = 0; i < size; i++) {
     if (i in current) {
       item = current[i];
-      if (isIterable(item)) {
+      if (isIterable(ctx, item)) {
         deferred[i] = item;
       } else {
         nodes[i] = await parseAsync(ctx, item);
@@ -146,7 +146,7 @@ async function generateMapNode(
   let nodeSize = 0;
   for (const [key, value] of current.entries()) {
     // Either key or value might be an iterable
-    if (isIterable(key) || isIterable(value)) {
+    if (isIterable(ctx, key) || isIterable(ctx, value)) {
       deferredKey[deferredSize] = key;
       deferredValue[deferredSize] = value;
       deferredSize++;
@@ -188,7 +188,7 @@ async function generateSetNode(
   let nodeSize = 0;
   for (const item of current.keys()) {
     // Iterables are lazy, so the evaluation must be deferred
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferred[deferredSize++] = item;
     } else {
       nodes[nodeSize++] = await parseAsync(ctx, item);
@@ -231,7 +231,7 @@ async function generateProperties(
   for (const key of keys) {
     item = properties[key];
     escaped = serializeString(key);
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
@@ -281,7 +281,7 @@ async function generatePlainProperties(
   for (const key of keys) {
     item = properties[key];
     escaped = serializeString(key);
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
@@ -721,7 +721,7 @@ export default async function parseAsync<T>(
 ): Promise<SerovalNode> {
   const t = typeof current;
   if (ctx.features & Feature.BigInt && t === 'bigint') {
-    return createBigIntNode(ctx, current as bigint);
+    return createBigIntNode(current as bigint);
   }
   switch (t) {
     case 'boolean':

package/src/core/tree/primitives.ts

@@ -106,7 +106,7 @@ export function createSymbolNode(
   if (hasReferenceID(current)) {
     return createReferenceNode(id, current);
   }
-  return createWKSymbolNode(ctx, id, current as WellKnownSymbols);
+  return createWKSymbolNode(id, current as WellKnownSymbols);
 }
 
 export function createFunctionNode(

package/src/core/tree/sync.ts

@@ -72,7 +72,7 @@ function generateNodeList(ctx: ParserContext, current: unknown[]): SerovalSyncNo
   for (let i = 0; i < size; i++) {
     if (i in current) {
       item = current[i];
-      if (isIterable(item)) {
+      if (isIterable(ctx, item)) {
         deferred[i] = item;
       } else {
         nodes[i] = parseSync(ctx, item);
@@ -122,7 +122,7 @@ function generateMapNode(
   let nodeSize = 0;
   for (const [key, value] of current.entries()) {
     // Either key or value might be an iterable
-    if (isIterable(key) || isIterable(value)) {
+    if (isIterable(ctx, key) || isIterable(ctx, value)) {
       deferredKey[deferredSize] = key;
       deferredValue[deferredSize] = value;
       deferredSize++;
@@ -164,7 +164,7 @@ function generateSetNode(
   let nodeSize = 0;
   for (const item of current.keys()) {
     // Iterables are lazy, so the evaluation must be deferred
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferred[deferredSize++] = item;
     } else {
       nodes[nodeSize++] = parseSync(ctx, item);
@@ -207,7 +207,7 @@ function generateProperties(
   for (const key of keys) {
     item = properties[key];
     escaped = serializeString(key);
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
@@ -254,7 +254,7 @@ function generatePlainProperties(
   for (const key of keys) {
     item = properties[key];
     escaped = serializeString(key);
-    if (isIterable(item)) {
+    if (isIterable(ctx, item)) {
       deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
@@ -602,7 +602,7 @@ export default function parseSync<T>(
 ): SerovalSyncNode {
   const t = typeof current;
   if (ctx.features & Feature.BigInt && t === 'bigint') {
-    return createBigIntNode(ctx, current as bigint);
+    return createBigIntNode(current as bigint);
   }
   switch (t) {
     case 'boolean':

package/src/core/tree/web-api.ts

@@ -1,8 +1,5 @@
-import assert from '../assert';
-import { Feature } from '../compat';
 import type { ParserContext } from './context';
 import { serializeString } from '../string';
-import UnsupportedTypeError from '../UnsupportedTypeError';
 import { serializeArrayBuffer } from './primitives';
 import type {
   SerovalBlobNode,
@@ -15,7 +12,6 @@ export async function createBlobNode(
   id: number,
   current: Blob,
 ): Promise<SerovalBlobNode> {
-  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
   return {
     t: SerovalNodeType.Blob,
     i: id,
@@ -37,7 +33,6 @@ export async function createFileNode(
   id: number,
   current: File,
 ): Promise<SerovalFileNode> {
-  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
   return {
     t: SerovalNodeType.File,
     i: id,

package/src/core/header.js

@@ -1,61 +0,0 @@
-/**
- * This file is used to represent the minified header script located at ./keys.ts
- * If anything, this code is the unminified, readable version of it.
- */
-
-// Global references array. Global because we (ideally) want <script> elements to share it.
-self._$ = self._$ || {
-  // Promise constructor, used to construct deferred Promises
-  P(success, failure, promise) {
-    promise = new Promise(function (resolve, reject) {
-      success = resolve;
-      failure = reject;
-    });
-  
-    promise.s = success;
-    promise.f = failure;
-  
-    return promise;
-  },
-  // This unsets the custom properties of the Promise instance
-  uP(promise) {
-    delete promise.s;
-    delete promise.f;
-  },
-  // Promise resolution
-  Ps(promise, data) {
-    promise.s(data);
-    promise.value = data;
-    this.uP(promise);
-  },
-  Pf(promise, data) {
-    promise.f(data);
-    this.uP(promise);
-  },
-  // Unset stream
-  uS(stream) {
-    delete stream.c;
-  },
-  Se(stream, type, data, controller) {
-    controller = stream.c;
-    switch (type) {
-      case 0: return controller.enqueue(data);
-      case 1:
-        this.uS(stream);
-        return controller.error(data);
-      case 2:
-        this.uS(stream);
-        return controller.close();
-    }
-  },
-  // ReadableStream constructor
-  S(stream, controller) {
-    stream = new ReadableStream({
-      start: function (c) {
-        controller = c;
-      }
-    });
-    stream.c = controller;
-    return stream;
-  },
-};