seroval 1.3.2 → 1.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "files": [
     "dist",
     "src"
@@ -14,25 +14,13 @@
     "pridepack"
   ],
   "devDependencies": {
-    "@types/node": "^22.15.12",
-    "@vitest/ui": "^3.1.3",
+    "@types/node": "^24.10.0",
+    "@vitest/ui": "^4.0.6",
     "pridepack": "2.6.4",
     "ts-prune": "^0.10.3",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.3"
-  },
-  "scripts": {
-    "prepublishOnly": "pridepack clean && pridepack build",
-    "build": "pridepack build",
-    "type-check": "pridepack check",
-    "clean": "pridepack clean",
-    "watch": "pridepack watch",
-    "start": "pridepack start",
-    "dev": "pridepack dev",
-    "test": "vitest",
-    "test:ui": "vitest --ui",
-    "prune": "ts-prune"
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.6"
   },
   "private": false,
   "description": "Stringify JS values",
@@ -65,5 +53,15 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "c1e47dd1233aaec1d4fae82c5776c31d5850def9"
-}
+  "scripts": {
+    "build": "pridepack build",
+    "type-check": "pridepack check",
+    "clean": "pridepack clean",
+    "watch": "pridepack watch",
+    "start": "pridepack start",
+    "dev": "pridepack dev",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "prune": "ts-prune"
+  }
+}

package/src/core/base-primitives.ts

@@ -11,7 +11,6 @@ import { getReferenceID } from './reference';
 import { serializeString } from './string';
 import type {
   SerovalAggregateErrorNode,
-  SerovalArrayBufferNode,
   SerovalArrayNode,
   SerovalAsyncIteratorFactoryInstanceNode,
   SerovalBigIntNode,
@@ -166,32 +165,6 @@ export function createRegExpNode(
   );
 }
 
-export function createArrayBufferNode(
-  id: number,
-  current: ArrayBuffer,
-): SerovalArrayBufferNode {
-  const bytes = new Uint8Array(current);
-  const len = bytes.length;
-  const values = new Array<number>(len);
-  for (let i = 0; i < len; i++) {
-    values[i] = bytes[i];
-  }
-  return createSerovalNode(
-    SerovalNodeType.ArrayBuffer,
-    id,
-    values,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
 export function createWKSymbolNode(
   id: number,
   current: WellKnownSymbols,

package/src/core/compat.ts

@@ -4,8 +4,9 @@
  * - MDN
  */
 
-export const enum Feature {
+export enum Feature {
   AggregateError = 0x01,
+  // @deprecated
   ArrowFunction = 0x02,
   ErrorPrototypeStack = 0x04,
   ObjectAssign = 0x08,

package/src/core/constants.ts

@@ -1,3 +1,5 @@
+import { SYM_ASYNC_ITERATOR, SYM_HAS_INSTANCE, SYM_IS_CONCAT_SPREADABLE, SYM_ITERATOR, SYM_MATCH, SYM_MATCH_ALL, SYM_REPLACE, SYM_SEARCH, SYM_SPECIES, SYM_SPLIT, SYM_TO_PRIMITIVE, SYM_TO_STRING_TAG, SYM_UNSCOPABLES } from "./symbols";
+
 export const enum SerovalConstant {
   Null = 0,
   Undefined = 1,
@@ -87,37 +89,37 @@ export const SYMBOL_STRING: Record<Symbols, string> = {
 };
 
 export const INV_SYMBOL_REF = /* @__PURE__ */ {
-  [Symbol.asyncIterator]: Symbols.AsyncIterator,
-  [Symbol.hasInstance]: Symbols.HasInstance,
-  [Symbol.isConcatSpreadable]: Symbols.IsConcatSpreadable,
-  [Symbol.iterator]: Symbols.Iterator,
-  [Symbol.match]: Symbols.Match,
-  [Symbol.matchAll]: Symbols.MatchAll,
-  [Symbol.replace]: Symbols.Replace,
-  [Symbol.search]: Symbols.Search,
-  [Symbol.species]: Symbols.Species,
-  [Symbol.split]: Symbols.Split,
-  [Symbol.toPrimitive]: Symbols.ToPrimitive,
-  [Symbol.toStringTag]: Symbols.ToStringTag,
-  [Symbol.unscopables]: Symbols.Unscopables,
+  [SYM_ASYNC_ITERATOR]: Symbols.AsyncIterator,
+  [SYM_HAS_INSTANCE]: Symbols.HasInstance,
+  [SYM_IS_CONCAT_SPREADABLE]: Symbols.IsConcatSpreadable,
+  [SYM_ITERATOR]: Symbols.Iterator,
+  [SYM_MATCH]: Symbols.Match,
+  [SYM_MATCH_ALL]: Symbols.MatchAll,
+  [SYM_REPLACE]: Symbols.Replace,
+  [SYM_SEARCH]: Symbols.Search,
+  [SYM_SPECIES]: Symbols.Species,
+  [SYM_SPLIT]: Symbols.Split,
+  [SYM_TO_PRIMITIVE]: Symbols.ToPrimitive,
+  [SYM_TO_STRING_TAG]: Symbols.ToStringTag,
+  [SYM_UNSCOPABLES]: Symbols.Unscopables,
 };
 
 export type WellKnownSymbols = keyof typeof INV_SYMBOL_REF;
 
 export const SYMBOL_REF: Record<Symbols, WellKnownSymbols> = {
-  [Symbols.AsyncIterator]: Symbol.asyncIterator,
-  [Symbols.HasInstance]: Symbol.hasInstance,
-  [Symbols.IsConcatSpreadable]: Symbol.isConcatSpreadable,
-  [Symbols.Iterator]: Symbol.iterator,
-  [Symbols.Match]: Symbol.match,
-  [Symbols.MatchAll]: Symbol.matchAll,
-  [Symbols.Replace]: Symbol.replace,
-  [Symbols.Search]: Symbol.search,
-  [Symbols.Species]: Symbol.species,
-  [Symbols.Split]: Symbol.split,
-  [Symbols.ToPrimitive]: Symbol.toPrimitive,
-  [Symbols.ToStringTag]: Symbol.toStringTag,
-  [Symbols.Unscopables]: Symbol.unscopables,
+  [Symbols.AsyncIterator]: SYM_ASYNC_ITERATOR,
+  [Symbols.HasInstance]: SYM_HAS_INSTANCE,
+  [Symbols.IsConcatSpreadable]: SYM_IS_CONCAT_SPREADABLE,
+  [Symbols.Iterator]: SYM_ITERATOR,
+  [Symbols.Match]: SYM_MATCH,
+  [Symbols.MatchAll]: SYM_MATCH_ALL,
+  [Symbols.Replace]: SYM_REPLACE,
+  [Symbols.Search]: SYM_SEARCH,
+  [Symbols.Species]: SYM_SPECIES,
+  [Symbols.Split]: SYM_SPLIT,
+  [Symbols.ToPrimitive]: SYM_TO_PRIMITIVE,
+  [Symbols.ToStringTag]: SYM_TO_STRING_TAG,
+  [Symbols.Unscopables]: SYM_UNSCOPABLES,
 };
 
 export const CONSTANT_STRING: Record<SerovalConstant, string> = {

package/src/core/constructors.ts

@@ -0,0 +1,269 @@
+import type { Stream } from './stream';
+
+type SpecialPromise = Promise<unknown> & { s?: 1 | 2; v?: unknown };
+
+export interface PromiseConstructorResolver {
+  p: SpecialPromise;
+  s: (value: unknown) => void;
+  f: (value: unknown) => void;
+}
+
+export const PROMISE_CONSTRUCTOR = (): PromiseConstructorResolver => {
+  const resolver = {
+    p: 0,
+    s: 0,
+    f: 0,
+  } as unknown as PromiseConstructorResolver;
+  resolver.p = new Promise((resolve, reject) => {
+    resolver.s = resolve;
+    resolver.f = reject;
+  });
+  return resolver;
+};
+
+export const PROMISE_SUCCESS = (
+  resolver: PromiseConstructorResolver,
+  data: unknown,
+): void => {
+  resolver.s(data);
+  resolver.p.s = 1;
+  resolver.p.v = data;
+};
+
+export const PROMISE_FAILURE = (
+  resolver: PromiseConstructorResolver,
+  data: unknown,
+): void => {
+  resolver.f(data);
+  resolver.p.s = 2;
+  resolver.p.v = data;
+};
+
+export const SERIALIZED_PROMISE_CONSTRUCTOR =
+  /* @__PURE__ */ PROMISE_CONSTRUCTOR.toString();
+export const SERIALIZED_PROMISE_SUCCESS =
+  /* @__PURE__ */ PROMISE_SUCCESS.toString();
+export const SERIALIZED_PROMISE_FAILURE =
+  /* @__PURE__ */ PROMISE_FAILURE.toString();
+
+interface StreamListener<T> {
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+
+export const STREAM_CONSTRUCTOR = () => {
+  const buffer: unknown[] = [];
+  const listeners: StreamListener<unknown>[] = [];
+  let alive = true;
+  let success = false;
+  let count = 0;
+  const flush = (
+    value: unknown,
+    mode: keyof StreamListener<unknown>,
+    x?: number,
+  ) => {
+    for (x = 0; x < count; x++) {
+      if (listeners[x]) {
+        listeners[x][mode](value);
+      }
+    }
+  };
+  const up = (
+    listener: StreamListener<unknown>,
+    x?: number,
+    z?: number,
+    current?: unknown,
+  ) => {
+    for (x = 0, z = buffer.length; x < z; x++) {
+      current = buffer[x];
+      if (!alive && x === z - 1) {
+        listener[success ? 'return' : 'throw'](current);
+      } else {
+        listener.next(current);
+      }
+    }
+  };
+  const on = (listener: StreamListener<unknown>, temp?: number) => {
+    if (alive) {
+      temp = count++;
+      listeners[temp] = listener;
+    }
+    up(listener);
+    return () => {
+      if (alive) {
+        listeners[temp!] = listeners[count];
+        listeners[count--] = undefined as any;
+      }
+    };
+  };
+  return {
+    __SEROVAL_STREAM__: true,
+    on: (listener: StreamListener<unknown>) => on(listener),
+    next: (value: unknown) => {
+      if (alive) {
+        buffer.push(value);
+        flush(value, 'next');
+      }
+    },
+    throw: (value: unknown) => {
+      if (alive) {
+        buffer.push(value);
+        flush(value, 'throw');
+        alive = false;
+        success = false;
+        listeners.length = 0;
+      }
+    },
+    return: (value: unknown) => {
+      if (alive) {
+        buffer.push(value);
+        flush(value, 'return');
+        alive = false;
+        success = true;
+        listeners.length = 0;
+      }
+    },
+  };
+};
+
+export const SERIALIZED_STREAM_CONSTRUCTOR =
+  /* @__PURE__ */ STREAM_CONSTRUCTOR.toString();
+
+export interface Sequence {
+  v: unknown[];
+  t: number;
+  d: number;
+}
+
+export const ITERATOR_CONSTRUCTOR =
+  (symbol: symbol) => (sequence: Sequence) => () => {
+    let index = 0;
+    const instance = {
+      [symbol]: () => instance,
+      next: () => {
+        if (index > sequence.d) {
+          return {
+            done: true,
+            value: undefined,
+          };
+        }
+        const currentIndex = index++;
+        const data = sequence.v[currentIndex];
+        if (currentIndex === sequence.t) {
+          throw data;
+        }
+        return {
+          done: currentIndex === sequence.d,
+          value: data,
+        };
+      },
+    };
+    return instance;
+  };
+
+export const SERIALIZED_ITERATOR_CONSTRUCTOR =
+  /* @__PURE__ */ ITERATOR_CONSTRUCTOR.toString();
+
+export const ASYNC_ITERATOR_CONSTRUCTOR =
+  (symbol: symbol, createPromise: typeof PROMISE_CONSTRUCTOR) =>
+  (stream: Stream<unknown>) =>
+  () => {
+    let count = 0;
+    let doneAt = -1;
+    let isThrow = false;
+    const buffer: unknown[] = [];
+    const pending: PromiseConstructorResolver[] = [];
+    const finalize = (i = 0, len = pending.length) => {
+      for (; i < len; i++) {
+        pending[i].s({
+          done: true,
+          value: undefined,
+        });
+      }
+    };
+    stream.on({
+      next: value => {
+        const temp = pending.shift();
+        if (temp) {
+          temp.s({ done: false, value });
+        }
+        buffer.push(value);
+      },
+      throw: value => {
+        const temp = pending.shift();
+        if (temp) {
+          temp.f(value);
+        }
+        finalize();
+        doneAt = buffer.length;
+        isThrow = true;
+        buffer.push(value);
+      },
+      return: value => {
+        const temp = pending.shift();
+        if (temp) {
+          temp.s({ done: true, value });
+        }
+        finalize();
+        doneAt = buffer.length;
+        buffer.push(value);
+      },
+    });
+
+    const instance = {
+      [symbol]: () => instance,
+      next: () => {
+        if (doneAt === -1) {
+          const index = count++;
+          if (index >= buffer.length) {
+            const temp = createPromise();
+            pending.push(temp);
+            return temp.p;
+          }
+          return {
+            done: false,
+            value: buffer[index],
+          };
+        }
+        if (count > doneAt) {
+          return {
+            done: true,
+            value: undefined,
+          };
+        }
+        const index = count++;
+        const value = buffer[index];
+        if (index !== doneAt) {
+          return {
+            done: false,
+            value,
+          };
+        }
+        if (isThrow) {
+          throw value;
+        }
+        return {
+          done: true,
+          value,
+        };
+      },
+    };
+
+    return instance;
+  };
+
+export const SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR =
+  /* @__PURE__ */ ASYNC_ITERATOR_CONSTRUCTOR.toString();
+
+export const ARRAY_BUFFER_CONSTRUCTOR = (length: number, b64: string) => {
+  const decoded = atob(b64);
+  const arr = new Uint8Array(length);
+  for (let i = 0; i < length; i++) {
+    arr[i] = decoded.charCodeAt(i);
+  }
+  return arr.buffer;
+};
+
+export const SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR =
+  /* @__PURE__ */ ARRAY_BUFFER_CONSTRUCTOR.toString();