seroval 1.4.1 → 1.4.2

package/src/core/special-reference.ts

@@ -0,0 +1,42 @@
+import {
+  SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
+  SERIALIZED_PROMISE_CONSTRUCTOR,
+  SERIALIZED_PROMISE_FAILURE,
+  SERIALIZED_PROMISE_SUCCESS,
+  SERIALIZED_STREAM_CONSTRUCTOR,
+} from './constructors';
+
+export const ITERATOR = {};
+
+export const ASYNC_ITERATOR = {};
+
+export const enum SpecialReference {
+  MapSentinel = 0,
+  PromiseConstructor = 1,
+  PromiseSuccess = 2,
+  PromiseFailure = 3,
+  StreamConstructor = 4,
+  ArrayBufferConstructor = 5,
+}
+
+/**
+ * Placeholder references
+ */
+export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
+  [SpecialReference.MapSentinel]: {},
+  [SpecialReference.PromiseConstructor]: {},
+  [SpecialReference.PromiseSuccess]: {},
+  [SpecialReference.PromiseFailure]: {},
+  [SpecialReference.StreamConstructor]: {},
+  [SpecialReference.ArrayBufferConstructor]: {},
+};
+
+export const SPECIAL_REF_STRING: Record<SpecialReference, string> = {
+  [SpecialReference.MapSentinel]: '[]',
+  [SpecialReference.PromiseConstructor]: SERIALIZED_PROMISE_CONSTRUCTOR,
+  [SpecialReference.PromiseSuccess]: SERIALIZED_PROMISE_SUCCESS,
+  [SpecialReference.PromiseFailure]: SERIALIZED_PROMISE_FAILURE,
+  [SpecialReference.StreamConstructor]: SERIALIZED_STREAM_CONSTRUCTOR,
+  [SpecialReference.ArrayBufferConstructor]:
+    SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
+};

package/src/core/stream.ts

@@ -0,0 +1,71 @@
+import {
+  ASYNC_ITERATOR_CONSTRUCTOR,
+  PROMISE_CONSTRUCTOR,
+  STREAM_CONSTRUCTOR,
+} from './constructors';
+import { SYM_ASYNC_ITERATOR } from './symbols';
+
+export interface StreamListener<T> {
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+
+export interface Stream<T> {
+  __SEROVAL_STREAM__: true;
+
+  on(listener: StreamListener<T>): () => void;
+
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+
+export function isStream<T>(value: object): value is Stream<T> {
+  return '__SEROVAL_STREAM__' in value;
+}
+
+export function createStream<T>(): Stream<T> {
+  return STREAM_CONSTRUCTOR() as unknown as Stream<T>;
+}
+
+export function createStreamFromAsyncIterable<T>(
+  iterable: AsyncIterable<T>,
+): Stream<T> {
+  const stream = createStream<T>();
+
+  const iterator = iterable[SYM_ASYNC_ITERATOR]();
+
+  async function push(): Promise<void> {
+    try {
+      const value = await iterator.next();
+      if (value.done) {
+        stream.return(value.value as T);
+      } else {
+        stream.next(value.value);
+        await push();
+      }
+    } catch (error) {
+      stream.throw(error);
+    }
+  }
+
+  push().catch(() => {
+    // no-op
+  });
+
+  return stream;
+}
+
+const createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(
+  SYM_ASYNC_ITERATOR,
+  PROMISE_CONSTRUCTOR,
+);
+
+export function streamToAsyncIterable<T>(
+  stream: Stream<T>,
+): () => AsyncIterableIterator<T> {
+  return createAsyncIterable(
+    stream,
+  ) as unknown as () => AsyncIterableIterator<T>;
+}

package/src/core/string.ts

@@ -0,0 +1,86 @@
+import { NIL } from './constants';
+
+export function serializeChar(str: string): string | undefined {
+  switch (str) {
+    case '"':
+      return '\\"';
+    case '\\':
+      return '\\\\';
+    case '\n':
+      return '\\n';
+    case '\r':
+      return '\\r';
+    case '\b':
+      return '\\b';
+    case '\t':
+      return '\\t';
+    case '\f':
+      return '\\f';
+    case '<':
+      return '\\x3C';
+    case '\u2028':
+      return '\\u2028';
+    case '\u2029':
+      return '\\u2029';
+    default:
+      return NIL;
+  }
+}
+
+// Written by https://github.com/DylanPiercey and is distributed under the MIT license.
+// Creates a JavaScript double quoted string and escapes all characters
+// not listed as DoubleStringCharacters on
+// Also includes "<" to escape "</script>" and "\" to avoid invalid escapes in the output.
+// http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+export function serializeString(str: string): string {
+  let result = '';
+  let lastPos = 0;
+  let replacement: string | undefined;
+  for (let i = 0, len = str.length; i < len; i++) {
+    replacement = serializeChar(str[i]);
+    if (replacement) {
+      result += str.slice(lastPos, i) + replacement;
+      lastPos = i + 1;
+    }
+  }
+  if (lastPos === 0) {
+    result = str;
+  } else {
+    result += str.slice(lastPos);
+  }
+  return result;
+}
+
+function deserializeReplacer(str: string): string {
+  switch (str) {
+    case '\\\\':
+      return '\\';
+    case '\\"':
+      return '"';
+    case '\\n':
+      return '\n';
+    case '\\r':
+      return '\r';
+    case '\\b':
+      return '\b';
+    case '\\t':
+      return '\t';
+    case '\\f':
+      return '\f';
+    case '\\x3C':
+      return '\x3C';
+    case '\\u2028':
+      return '\u2028';
+    case '\\u2029':
+      return '\u2029';
+    default:
+      return str;
+  }
+}
+
+export function deserializeString(str: string): string {
+  return str.replace(
+    /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,
+    deserializeReplacer,
+  );
+}

package/src/core/symbols.ts

@@ -0,0 +1,18 @@
+export const SYM_ASYNC_ITERATOR: typeof Symbol.asyncIterator = Symbol.asyncIterator;
+export const SYM_HAS_INSTANCE: typeof Symbol.hasInstance = Symbol.hasInstance;
+export const SYM_IS_CONCAT_SPREADABLE: typeof Symbol.isConcatSpreadable = Symbol.isConcatSpreadable;
+export const SYM_ITERATOR: typeof Symbol.iterator = Symbol.iterator;
+export const SYM_MATCH: typeof Symbol.match = Symbol.match;
+export const SYM_MATCH_ALL: typeof Symbol.matchAll = Symbol.matchAll;
+export const SYM_REPLACE: typeof Symbol.replace = Symbol.replace;
+export const SYM_SEARCH: typeof Symbol.search = Symbol.search;
+export const SYM_SPECIES: typeof Symbol.species = Symbol.species;
+export const SYM_SPLIT: typeof Symbol.split = Symbol.split;
+export const SYM_TO_PRIMITIVE: typeof Symbol.toPrimitive = Symbol.toPrimitive;
+export const SYM_TO_STRING_TAG: typeof Symbol.toStringTag = Symbol.toStringTag;
+export const SYM_UNSCOPABLES: typeof Symbol.unscopables = Symbol.unscopables;
+
+// For the future
+
+// export const SYM_DISPOSE = Symbol.dispose;
+// export const SYM_ASYNC_DISPOSE = Symbol.asyncDispose;

package/src/core/tree/index.ts

@@ -0,0 +1,134 @@
+import {
+  createAsyncParserContext,
+  parseTopAsync,
+} from '../context/async-parser';
+import {
+  createVanillaDeserializerContext,
+  deserializeTop,
+} from '../context/deserializer';
+import type { BaseParserContextOptions } from '../context/parser';
+import {
+  createVanillaSerializerContext,
+  serializeTopVanilla,
+} from '../context/serializer';
+import { createSyncParserContext, parseTop } from '../context/sync-parser';
+import {
+  type PluginAccessOptions,
+  resolvePlugins,
+  SerovalMode,
+} from '../plugin';
+import type { SerovalNode } from '../types';
+import { ALL_ENABLED } from '../compat';
+export type SyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
+export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
+
+export function serialize<T>(
+  source: T,
+  options: SyncParserContextOptions = {},
+): string {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createSyncParserContext(SerovalMode.Vanilla, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  const tree = parseTop(ctx, source);
+  const serial = createVanillaSerializerContext({
+    plugins,
+    features: ctx.base.features,
+    markedRefs: ctx.base.marked,
+  });
+  return serializeTopVanilla(serial, tree);
+}
+
+export async function serializeAsync<T>(
+  source: T,
+  options: AsyncParserContextOptions = {},
+): Promise<string> {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createAsyncParserContext(SerovalMode.Vanilla, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  const tree = await parseTopAsync(ctx, source);
+  const serial = createVanillaSerializerContext({
+    plugins,
+    features: ctx.base.features,
+    markedRefs: ctx.base.marked,
+  });
+  return serializeTopVanilla(serial, tree);
+}
+
+export function deserialize<T>(source: string): T {
+  return (0, eval)(source) as T;
+}
+
+export interface SerovalJSON {
+  t: SerovalNode;
+  f: number;
+  m: number[];
+}
+
+export interface FromJSONOptions extends PluginAccessOptions {
+  disabledFeatures?: number;
+}
+
+export function toJSON<T>(
+  source: T,
+  options: SyncParserContextOptions = {},
+): SerovalJSON {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createSyncParserContext(SerovalMode.Vanilla, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  return {
+    t: parseTop(ctx, source),
+    f: ctx.base.features,
+    m: Array.from(ctx.base.marked),
+  };
+}
+
+export async function toJSONAsync<T>(
+  source: T,
+  options: AsyncParserContextOptions = {},
+): Promise<SerovalJSON> {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createAsyncParserContext(SerovalMode.Vanilla, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  return {
+    t: await parseTopAsync(ctx, source),
+    f: ctx.base.features,
+    m: Array.from(ctx.base.marked),
+  };
+}
+
+export function compileJSON(
+  source: SerovalJSON,
+  options: PluginAccessOptions = {},
+): string {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createVanillaSerializerContext({
+    plugins,
+    features: source.f,
+    markedRefs: source.m,
+  });
+  return serializeTopVanilla(ctx, source.t);
+}
+
+export function fromJSON<T>(
+  source: SerovalJSON,
+  options: FromJSONOptions = {},
+): T {
+  const plugins = resolvePlugins(options.plugins);
+  const disabledFeatures = options.disabledFeatures || 0;
+  const sourceFeatures = source.f ?? ALL_ENABLED;
+  const ctx = createVanillaDeserializerContext({
+    plugins,
+    markedRefs: source.m,
+    features: sourceFeatures & ~disabledFeatures,
+    disabledFeatures,
+  });
+  return deserializeTop(ctx, source.t) as T;
+}

package/src/core/types.ts

@@ -0,0 +1,366 @@
+import type {
+  ErrorConstructorTag,
+  SerovalConstant,
+  SerovalNodeType,
+  SerovalObjectFlags,
+  Symbols,
+} from './constants';
+import type { SpecialReference } from './special-reference';
+
+export interface SerovalBaseNode {
+  // Type of the node
+  t: SerovalNodeType;
+  // Reference ID
+  i: number | undefined;
+  // Serialized value
+  s: unknown;
+  // Constructor name / RegExp source
+  c: string | undefined;
+  // message/flags
+  m: string | undefined;
+  // properties (objects)
+  p: SerovalObjectRecordNode | undefined;
+  // entries (for Map, etc.)
+  e: SerovalMapRecordNode | undefined;
+  // array of nodes
+  a: (SerovalNode | 0)[] | undefined;
+  // fulfilled node
+  f: SerovalNode | undefined;
+  // byte offset/object flags
+  b: number | undefined;
+  // object flag
+  o: SerovalObjectFlags | undefined;
+  // length
+  l: number | undefined;
+}
+
+export type SerovalObjectRecordKey = string | SerovalNode;
+
+export interface SerovalObjectRecordNode {
+  k: SerovalObjectRecordKey[];
+  v: SerovalNode[];
+}
+
+export interface SerovalMapRecordNode {
+  k: SerovalNode[];
+  v: SerovalNode[];
+}
+
+export interface SerovalNumberNode extends SerovalBaseNode {
+  t: SerovalNodeType.Number;
+  s: number;
+}
+
+export interface SerovalStringNode extends SerovalBaseNode {
+  t: SerovalNodeType.String;
+  s: string;
+}
+
+export interface SerovalConstantNode extends SerovalBaseNode {
+  t: SerovalNodeType.Constant;
+  s: SerovalConstant;
+}
+
+export type SerovalPrimitiveNode =
+  | SerovalNumberNode
+  | SerovalStringNode
+  | SerovalConstantNode;
+
+export interface SerovalIndexedValueNode extends SerovalBaseNode {
+  t: SerovalNodeType.IndexedValue;
+  // id
+  i: number;
+}
+
+export interface SerovalBigIntNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigInt;
+  // value in string
+  s: string;
+}
+
+export interface SerovalDateNode extends SerovalBaseNode {
+  t: SerovalNodeType.Date;
+  // id (Dates are stateful)
+  i: number;
+  // value in ISO string
+  s: string;
+}
+
+export interface SerovalRegExpNode extends SerovalBaseNode {
+  t: SerovalNodeType.RegExp;
+  // id (RegExp are stateful)
+  i: number;
+  // source
+  c: string;
+  // flags
+  m: string;
+}
+
+export interface SerovalArrayBufferNode extends SerovalBaseNode {
+  t: SerovalNodeType.ArrayBuffer;
+  // id
+  i: number;
+  // byte string
+  s: string;
+  // array buffer constructor
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.TypedArray;
+  // id
+  i: number;
+  // TypedArray Constructor
+  c: string;
+  // ArrayBuffer reference
+  f: SerovalNode;
+  // Byte Offset
+  b: number;
+  // length
+  l: number;
+}
+
+export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigIntTypedArray;
+  i: number;
+  // TypedArray Constructor
+  c: string;
+  // ArrayBuffer reference
+  f: SerovalNode;
+  // Byte Offset
+  b: number;
+  // length
+  l: number;
+}
+
+export type SerovalSemiPrimitiveNode =
+  | SerovalBigIntNode
+  | SerovalDateNode
+  | SerovalRegExpNode
+  | SerovalTypedArrayNode
+  | SerovalBigIntTypedArrayNode;
+
+export interface SerovalSetNode extends SerovalBaseNode {
+  t: SerovalNodeType.Set;
+  // id
+  i: number;
+  // Items in Set (as array)
+  a: SerovalNode[];
+}
+
+export interface SerovalMapNode extends SerovalBaseNode {
+  t: SerovalNodeType.Map;
+  i: number;
+  // key/value pairs
+  e: SerovalMapRecordNode;
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.Array;
+  // items
+  a: (SerovalNode | 0)[];
+  i: number;
+  o: SerovalObjectFlags;
+}
+
+export interface SerovalObjectNode extends SerovalBaseNode {
+  t: SerovalNodeType.Object;
+  // key/value pairs
+  p: SerovalObjectRecordNode;
+  i: number;
+  o: SerovalObjectFlags;
+}
+
+export interface SerovalNullConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.NullConstructor;
+  // key/value pairs
+  p: SerovalObjectRecordNode;
+  i: number;
+  o: SerovalObjectFlags;
+}
+
+export interface SerovalPromiseNode extends SerovalBaseNode {
+  t: SerovalNodeType.Promise;
+  s: 0 | 1;
+  // resolved value
+  f: SerovalNode;
+  i: number;
+}
+
+export interface SerovalErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.Error;
+  // constructor name
+  s: ErrorConstructorTag;
+  // message
+  m: string;
+  // other properties
+  p: SerovalObjectRecordNode | undefined;
+  i: number;
+}
+
+export interface SerovalAggregateErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.AggregateError;
+  i: number;
+  // message
+  m: string;
+  // other properties
+  p: SerovalObjectRecordNode | undefined;
+}
+
+export interface SerovalWKSymbolNode extends SerovalBaseNode {
+  t: SerovalNodeType.WKSymbol;
+  i: number;
+  s: Symbols;
+}
+
+export interface SerovalReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Reference;
+  i: number;
+  // id of the reference in the map
+  s: string;
+}
+
+export interface SerovalDataViewNode extends SerovalBaseNode {
+  t: SerovalNodeType.DataView;
+  i: number;
+  // reference to array buffer
+  f: SerovalNode;
+  // byte offset
+  b: number;
+  // byte length
+  l: number;
+}
+
+export interface SerovalBoxedNode extends SerovalBaseNode {
+  t: SerovalNodeType.Boxed;
+  i: number;
+  f: SerovalNode;
+}
+
+export interface SerovalPromiseConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseConstructor;
+  i: number;
+  s: number;
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalPromiseResolveNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseSuccess;
+  i: number;
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
+}
+
+export interface SerovalPromiseRejectNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseFailure;
+  i: number;
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
+}
+
+export interface SerovalPluginNode extends SerovalBaseNode {
+  t: SerovalNodeType.Plugin;
+  i: number;
+  // value
+  s: unknown;
+  // tag name
+  c: string;
+}
+
+/**
+ * Represents special values as placeholders
+ */
+export interface SerovalSpecialReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.SpecialReference;
+  i: number;
+  s: SpecialReference;
+}
+
+export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.IteratorFactory;
+  i: number;
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
+  t: SerovalNodeType.IteratorFactoryInstance;
+  a: [instance: SerovalNodeWithID, sequence: SerovalNode];
+}
+
+export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.AsyncIteratorFactory;
+  i: number;
+  a: [promise: SerovalNodeWithID, symbol: SerovalNodeWithID];
+}
+
+export interface SerovalAsyncIteratorFactoryInstanceNode
+  extends SerovalBaseNode {
+  t: SerovalNodeType.AsyncIteratorFactoryInstance;
+  a: [instance: SerovalNodeWithID, sequence: SerovalNode];
+}
+
+export interface SerovalStreamConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamConstructor;
+  i: number;
+  a: SerovalNode[];
+  // special reference to the constructor
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalStreamNextNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamNext;
+  i: number;
+  // Next value
+  f: SerovalNode;
+}
+
+export interface SerovalStreamThrowNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamThrow;
+  i: number;
+  // Throw value
+  f: SerovalNode;
+}
+
+export interface SerovalStreamReturnNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamReturn;
+  i: number;
+  // Return value
+  f: SerovalNode;
+}
+
+export type SerovalSyncNode =
+  | SerovalPrimitiveNode
+  | SerovalIndexedValueNode
+  | SerovalSemiPrimitiveNode
+  | SerovalSetNode
+  | SerovalMapNode
+  | SerovalArrayNode
+  | SerovalObjectNode
+  | SerovalNullConstructorNode
+  | SerovalPromiseNode
+  | SerovalErrorNode
+  | SerovalAggregateErrorNode
+  | SerovalWKSymbolNode
+  | SerovalReferenceNode
+  | SerovalArrayBufferNode
+  | SerovalDataViewNode
+  | SerovalBoxedNode
+  | SerovalPluginNode
+  | SerovalSpecialReferenceNode
+  | SerovalIteratorFactoryNode
+  | SerovalIteratorFactoryInstanceNode
+  | SerovalAsyncIteratorFactoryNode
+  | SerovalAsyncIteratorFactoryInstanceNode;
+
+export type SerovalAsyncNode =
+  | SerovalPromiseNode
+  | SerovalPromiseConstructorNode
+  | SerovalPromiseResolveNode
+  | SerovalPromiseRejectNode
+  | SerovalStreamConstructorNode
+  | SerovalStreamNextNode
+  | SerovalStreamThrowNode
+  | SerovalStreamReturnNode;
+
+export type SerovalNode = SerovalSyncNode | SerovalAsyncNode;
+
+export type SerovalNodeWithID = Extract<SerovalNode, { i: number }>;