0.13.0

docs/compatibility.md

@@ -46,21 +46,17 @@ By default, all feature flags are enabled. The following are the feature flags a
 
 - [`AggregateError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError)
   - Compiles down to `Error` instead.
-- [`ArrayPrototypeValues`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values)
-  - Used for `Iterable`, uses `Symbol.iterator` instead.
 - [`ArrowFunction`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions)
   - Uses function expressions for top-level and for deferred `Promise` values
-  - method shorthands (if `MethodShortand` is not set) or function expressions for `Iterable`.
+  - Uses function expressions for `Iterable`
+  - Uses function expressions for `AsyncIterable`
 - [`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
   - Disables serialization of `BigInt`, `BigInt64Array` and `BigUint64Array`
 - [`ErrorPrototypeStack`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/stack)
   - Skipped when detected.
   - Affects both `Error` and `AggregateError`
 - [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
   - Disables serialization of `Map`
-- [`MethodShorthand`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions)
-  - Uses function expressions instead.
-  - Only affects `Iterable`
 - [`ObjectAssign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
   - Uses manual object assignments instead.
   - Affects `Iterable`, `Error`, `AggregateError` and `Object.create(null)`
@@ -91,9 +87,9 @@ By default, all feature flags are enabled. The following are the feature flags a
 
 ## Supported Types
 
-- sync = `serialize`, `toJSON`, `crossSerialize`
-- async = `serializeAsync`, `toJSONAsync`, `crossSerializeAsync`
-- streaming = `crossSerializeStream`, `Serializer`
+- sync = `serialize`, `toJSON`, `crossSerialize`, `toCrossJSON`
+- async = `serializeAsync`, `toJSONAsync`, `crossSerializeAsync`, `toCrossJSONAsync`
+- streaming = `crossSerializeStream`, `toCrossJSONStream`, `Serializer`
 
 | Type | sync | async | streaming |
 | --- | --- | --- | --- |

docs/serialization.md

@@ -9,6 +9,9 @@
 - `crossSerialize`
 - `crossSerializeAsync`
 - `crossSerializeStream`
+- `toCrossJSON`
+- `toCrossJSONAsync`
+- `toCrossJSONStream`
 
 ## Basic serialization
 
@@ -117,8 +120,5 @@ const BufferPlugin = createPlugin<Buffer, SerovalNode>({
   deserialize(node, ctx) {
     return Buffer.from(ctx.deserialize(node) as string, 'base64');
   },
-  isIterable() {
-    return true;
-  },
 });
 ```

packages/seroval/assets/global-header.js

@@ -36,17 +36,16 @@ self._$ = self._$ || {
   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();
-    }
+  Se(stream, data) {
+    stream.c.enqueue(data);
+  },
+  St(stream, data) {
+    stream.c.error(data);
+    this.uS(stream);
+  },
+  Sc(stream) {
+    stream.c.close();
+    this.uS(stream);
   },
   // ReadableStream constructor
   S(stream, controller) {

packages/seroval/src/core/base-primitives.ts

@@ -1,4 +1,5 @@
-import assert from './assert';
+import type { BigIntTypedArrayValue, TypedArrayValue } from '../types';
+import assert from './utils/assert';
 import type { WellKnownSymbols } from './constants';
 import { INV_SYMBOL_REF, SerovalNodeType } from './constants';
 import {
@@ -8,20 +9,34 @@ import {
   NEG_ZERO_NODE,
 } from './literals';
 import { getReferenceID } from './reference';
+import { getErrorConstructor } from './utils/error';
 import { serializeString } from './string';
 import type {
+  SerovalAggregateErrorNode,
   SerovalArrayBufferNode,
+  SerovalArrayNode,
+  SerovalAsyncIteratorFactoryInstanceNode,
   SerovalBigIntNode,
+  SerovalBigIntTypedArrayNode,
+  SerovalBoxedNode,
   SerovalConstantNode,
+  SerovalDataViewNode,
   SerovalDateNode,
+  SerovalErrorNode,
   SerovalIndexedValueNode,
+  SerovalIteratorFactoryInstanceNode,
+  SerovalNode,
   SerovalNumberNode,
+  SerovalObjectRecordNode,
   SerovalPluginNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalSetNode,
   SerovalStringNode,
+  SerovalTypedArrayNode,
   SerovalWKSymbolNode,
 } from './types';
+import { getObjectFlag } from './utils/get-object-flag';
 
 export function createNumberNode(value: number): SerovalConstantNode | SerovalNumberNode {
   switch (value) {
@@ -228,3 +243,216 @@ export function createPluginNode(
     o: undefined,
   };
 }
+
+export function createArrayNode(
+  id: number,
+  current: unknown[],
+  parsedItems: SerovalNode[],
+): SerovalArrayNode {
+  return {
+    t: SerovalNodeType.Array,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: parsedItems,
+    f: undefined,
+    b: undefined,
+    o: getObjectFlag(current),
+  };
+}
+
+export function createBoxedNode(
+  id: number,
+  boxed: SerovalNode,
+): SerovalBoxedNode {
+  return {
+    t: SerovalNodeType.Boxed,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: boxed,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createTypedArrayNode(
+  id: number,
+  current: TypedArrayValue,
+  buffer: SerovalNode,
+): SerovalTypedArrayNode {
+  return {
+    t: SerovalNodeType.TypedArray,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: buffer,
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createBigIntTypedArrayNode(
+  id: number,
+  current: BigIntTypedArrayValue,
+  buffer: SerovalNode,
+): SerovalBigIntTypedArrayNode {
+  return {
+    t: SerovalNodeType.BigIntTypedArray,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: buffer,
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createDataViewNode(
+  id: number,
+  current: DataView,
+  buffer: SerovalNode,
+): SerovalDataViewNode {
+  return {
+    t: SerovalNodeType.DataView,
+    i: id,
+    s: undefined,
+    l: current.byteLength,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: buffer,
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createErrorNode(
+  id: number,
+  current: Error,
+  options: SerovalObjectRecordNode | undefined,
+): SerovalErrorNode {
+  return {
+    t: SerovalNodeType.Error,
+    i: id,
+    s: getErrorConstructor(current),
+    l: undefined,
+    c: undefined,
+    m: serializeString(current.message),
+    p: options,
+    e: undefined,
+    a: undefined,
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createAggregateErrorNode(
+  id: number,
+  current: AggregateError,
+  options: SerovalObjectRecordNode | undefined,
+): SerovalAggregateErrorNode {
+  return {
+    t: SerovalNodeType.AggregateError,
+    i: id,
+    s: getErrorConstructor(current),
+    l: undefined,
+    c: undefined,
+    m: serializeString(current.message),
+    p: options,
+    e: undefined,
+    a: undefined,
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createSetNode(
+  id: number,
+  size: number,
+  items: SerovalNode[],
+): SerovalSetNode {
+  return {
+    t: SerovalNodeType.Set,
+    i: id,
+    s: undefined,
+    l: size,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: items,
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createIteratorFactoryInstanceNode(
+  factory: SerovalNode,
+  items: SerovalNode,
+): SerovalIteratorFactoryInstanceNode {
+  return {
+    t: SerovalNodeType.IteratorFactoryInstance,
+    i: undefined,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: [
+      factory,
+      items,
+    ],
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createAsyncIteratorFactoryInstanceNode(
+  factory: SerovalNode,
+  items: SerovalNode,
+): SerovalAsyncIteratorFactoryInstanceNode {
+  return {
+    t: SerovalNodeType.AsyncIteratorFactoryInstance,
+    i: undefined,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: [
+      factory,
+      items,
+    ],
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}

packages/seroval/src/core/compat.ts

@@ -6,12 +6,10 @@
 
 export const enum Feature {
   AggregateError = 0x01,
-  ArrayPrototypeValues = 0x02,
   ArrowFunction = 0x04,
   BigInt = 0x08,
   ErrorPrototypeStack = 0x10,
   Map = 0x20,
-  MethodShorthand = 0x40,
   ObjectAssign = 0x80,
   Promise = 0x100,
   Set = 0x200,

packages/seroval/src/core/constants.ts

@@ -51,6 +51,13 @@ export const enum SerovalNodeType {
   CustomEvent = 38,
   DOMException = 39,
   Plugin = 40,
+  MapSentinel = 41,
+  IteratorFactory = 42,
+  IteratorFactoryInstance = 43,
+  AsyncIteratorFactory = 44,
+  AsyncIteratorFactoryInstance = 45,
+  ReadableStream = 46,
+  ReadableStreamFactory = 47,
 }
 
 export const enum SerovalObjectFlags {
@@ -186,5 +193,3 @@ export const ERROR_CONSTRUCTOR: Record<ErrorConstructorTag, ErrorConstructors> =
   [ErrorConstructorTag.TypeError]: TypeError,
   [ErrorConstructorTag.URIError]: URIError,
 };
-
-export const UNIVERSAL_SENTINEL = Symbol('why');