seroval 1.5.6 → 1.6.0

package/src/core/sequence.ts

@@ -1,59 +0,0 @@
-import { ITERATOR_CONSTRUCTOR } from './constructors';
-import { SYM_ITERATOR } from './symbols';
-
-export interface Sequence {
-  __SEROVAL_SEQUENCE__: true;
-
-  v: unknown[];
-  t: number;
-  d: number;
-}
-
-export function isSequence(value: object): value is Sequence {
-  return '__SEROVAL_SEQUENCE__' in value;
-}
-
-export function createSequence(
-  values: unknown[],
-  throwAt: number,
-  doneAt: number,
-): Sequence {
-  return {
-    __SEROVAL_SEQUENCE__: true,
-
-    v: values,
-    t: throwAt,
-    d: doneAt,
-  };
-}
-
-export function createSequenceFromIterable<T>(source: Iterable<T>): Sequence {
-  const values: unknown[] = [];
-  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);
-}
-
-const createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
-
-export function sequenceToIterator<T>(
-  sequence: Sequence,
-): () => IterableIterator<T> {
-  return createIterator(sequence) as unknown as () => IterableIterator<T>;
-}

package/src/core/special-reference.ts

@@ -1,42 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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;
-}