seroval 1.5.6 → 1.6.0

package/src/core/context/parser.ts

@@ -1,335 +0,0 @@
-import {
-  createIndexedValueNode,
-  createReferenceNode,
-  createWKSymbolNode,
-} from '../base-primitives';
-import { ALL_ENABLED } from '../compat';
-import type { WellKnownSymbols } from '../constants';
-import { INV_SYMBOL_REF, NIL, SerovalNodeType } from '../constants';
-import { SerovalUnsupportedTypeError } from '../errors';
-import { createSerovalNode } from '../node';
-import type { PluginAccessOptions, SerovalMode } from '../plugin';
-import { hasReferenceID } from '../reference';
-import {
-  ASYNC_ITERATOR,
-  ITERATOR,
-  SPECIAL_REFS,
-  SpecialReference,
-} from '../special-reference';
-import { serializeString } from '../string';
-import { SYM_ASYNC_ITERATOR, SYM_ITERATOR } from '../symbols';
-import type {
-  SerovalArrayBufferNode,
-  SerovalAsyncIteratorFactoryNode,
-  SerovalIndexedValueNode,
-  SerovalIteratorFactoryNode,
-  SerovalMapNode,
-  SerovalNode,
-  SerovalNullConstructorNode,
-  SerovalObjectNode,
-  SerovalObjectRecordNode,
-  SerovalPromiseConstructorNode,
-  SerovalReferenceNode,
-  SerovalSpecialReferenceNode,
-  SerovalWKSymbolNode,
-} from '../types';
-import { getObjectFlag } from '../utils/get-object-flag';
-
-export interface BaseParserContextOptions extends PluginAccessOptions {
-  disabledFeatures?: number;
-  refs?: Map<unknown, number>;
-  depthLimit?: number;
-}
-
-export const enum ParserNodeType {
-  Fresh = 0,
-  Indexed = 1,
-  Referenced = 2,
-}
-
-export interface FreshNode {
-  type: ParserNodeType.Fresh;
-  value: number;
-}
-
-export interface IndexedNode {
-  type: ParserNodeType.Indexed;
-  value: SerovalIndexedValueNode;
-}
-
-export interface ReferencedNode {
-  type: ParserNodeType.Referenced;
-  value: SerovalReferenceNode;
-}
-
-type ObjectNode = FreshNode | IndexedNode | ReferencedNode;
-
-export interface BaseParserContext extends PluginAccessOptions {
-  readonly mode: SerovalMode;
-
-  marked: Set<number>;
-
-  refs: Map<unknown, number>;
-
-  features: number;
-
-  depthLimit: number;
-}
-
-export function createBaseParserContext(
-  mode: SerovalMode,
-  options: BaseParserContextOptions,
-): BaseParserContext {
-  return {
-    plugins: options.plugins,
-    mode,
-    marked: new Set(),
-    features: ALL_ENABLED ^ (options.disabledFeatures || 0),
-    refs: options.refs || new Map(),
-    depthLimit: options.depthLimit || 1000,
-  };
-}
-
-/**
- * Ensures that the value (based on an identifier) has been visited by the parser.
- * @param ctx
- * @param id
- */
-export function markParserRef(ctx: BaseParserContext, id: number): void {
-  ctx.marked.add(id);
-}
-
-export function isParserRefMarked(ctx: BaseParserContext, id: number): boolean {
-  return ctx.marked.has(id);
-}
-
-/**
- * Creates an identifier for a value
- * @param ctx
- * @param current
- */
-export function createIndexForValue<T>(
-  ctx: BaseParserContext,
-  current: T,
-): number {
-  const id = ctx.refs.size;
-  ctx.refs.set(current, id);
-  return id;
-}
-
-export function getNodeForIndexedValue<T>(
-  ctx: BaseParserContext,
-  current: T,
-): FreshNode | IndexedNode {
-  const registeredId = ctx.refs.get(current);
-  if (registeredId != null) {
-    markParserRef(ctx, registeredId);
-    return {
-      type: ParserNodeType.Indexed,
-      value: createIndexedValueNode(registeredId),
-    };
-  }
-  return {
-    type: ParserNodeType.Fresh,
-    value: createIndexForValue(ctx, current),
-  };
-}
-
-export function getReferenceNode<T>(
-  ctx: BaseParserContext,
-  current: T,
-): ObjectNode {
-  const indexed = getNodeForIndexedValue(ctx, current);
-  if (indexed.type === ParserNodeType.Indexed) {
-    return indexed;
-  }
-  // Special references are special ;)
-  if (hasReferenceID(current)) {
-    return {
-      type: ParserNodeType.Referenced,
-      value: createReferenceNode(indexed.value, current),
-    };
-  }
-  return indexed;
-}
-
-/**
- * Parsing methods
- */
-export function parseWellKnownSymbol(
-  ctx: BaseParserContext,
-  current: symbol,
-): SerovalIndexedValueNode | SerovalWKSymbolNode | SerovalReferenceNode {
-  const ref = getReferenceNode(ctx, current);
-  if (ref.type !== ParserNodeType.Fresh) {
-    return ref.value;
-  }
-  if (current in INV_SYMBOL_REF) {
-    return createWKSymbolNode(ref.value, current as WellKnownSymbols);
-  }
-  throw new SerovalUnsupportedTypeError(current);
-}
-
-export function parseSpecialReference(
-  ctx: BaseParserContext,
-  ref: SpecialReference,
-): SerovalIndexedValueNode | SerovalSpecialReferenceNode {
-  const result = getNodeForIndexedValue(ctx, SPECIAL_REFS[ref]);
-  if (result.type === ParserNodeType.Indexed) {
-    return result.value;
-  }
-  return createSerovalNode(
-    SerovalNodeType.SpecialReference,
-    result.value,
-    ref,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function parseIteratorFactory(
-  ctx: BaseParserContext,
-): SerovalIndexedValueNode | SerovalIteratorFactoryNode {
-  const result = getNodeForIndexedValue(ctx, ITERATOR);
-  if (result.type === ParserNodeType.Indexed) {
-    return result.value;
-  }
-  return createSerovalNode(
-    SerovalNodeType.IteratorFactory,
-    result.value,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    parseWellKnownSymbol(ctx, SYM_ITERATOR),
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function parseAsyncIteratorFactory(
-  ctx: BaseParserContext,
-): SerovalIndexedValueNode | SerovalAsyncIteratorFactoryNode {
-  const result = getNodeForIndexedValue(ctx, ASYNC_ITERATOR);
-  if (result.type === ParserNodeType.Indexed) {
-    return result.value;
-  }
-  return createSerovalNode(
-    SerovalNodeType.AsyncIteratorFactory,
-    result.value,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    [
-      parseSpecialReference(ctx, SpecialReference.PromiseConstructor),
-      parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR),
-    ],
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function createObjectNode(
-  id: number,
-  current: Record<string, unknown>,
-  empty: boolean,
-  record: SerovalObjectRecordNode,
-): SerovalObjectNode | SerovalNullConstructorNode {
-  return createSerovalNode(
-    empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-    id,
-    NIL,
-    NIL,
-    NIL,
-    record,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    getObjectFlag(current),
-    NIL,
-  );
-}
-
-export function createMapNode(
-  ctx: BaseParserContext,
-  id: number,
-  k: SerovalNode[],
-  v: SerovalNode[],
-): SerovalMapNode {
-  return createSerovalNode(
-    SerovalNodeType.Map,
-    id,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    { k, v },
-    NIL,
-    parseSpecialReference(ctx, SpecialReference.MapSentinel),
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function createPromiseConstructorNode(
-  ctx: BaseParserContext,
-  id: number,
-  resolver: number,
-): SerovalPromiseConstructorNode {
-  return createSerovalNode(
-    SerovalNodeType.PromiseConstructor,
-    id,
-    resolver,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    parseSpecialReference(ctx, SpecialReference.PromiseConstructor),
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function createArrayBufferNode(
-  ctx: BaseParserContext,
-  id: number,
-  current: ArrayBuffer,
-): SerovalArrayBufferNode {
-  const bytes = new Uint8Array(current);
-  let result = '';
-  for (let i = 0, len = bytes.length; i < len; i++) {
-    result += String.fromCharCode(bytes[i]);
-  }
-  return createSerovalNode(
-    SerovalNodeType.ArrayBuffer,
-    id,
-    serializeString(btoa(result)),
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    parseSpecialReference(ctx, SpecialReference.ArrayBufferConstructor),
-    NIL,
-    NIL,
-    NIL,
-  );
-}