seroval 1.4.1 → 1.4.2

package/src/core/base-primitives.ts

@@ -0,0 +1,514 @@
+import type { WellKnownSymbols } from './constants';
+import { INV_SYMBOL_REF, NIL, SerovalNodeType } from './constants';
+import {
+  INFINITY_NODE,
+  NAN_NODE,
+  NEG_INFINITY_NODE,
+  NEG_ZERO_NODE,
+} from './literals';
+import { createSerovalNode } from './node';
+import { getReferenceID } from './reference';
+import { serializeString } from './string';
+import type {
+  SerovalAggregateErrorNode,
+  SerovalArrayNode,
+  SerovalAsyncIteratorFactoryInstanceNode,
+  SerovalBigIntNode,
+  SerovalBigIntTypedArrayNode,
+  SerovalBoxedNode,
+  SerovalConstantNode,
+  SerovalDataViewNode,
+  SerovalDateNode,
+  SerovalErrorNode,
+  SerovalIndexedValueNode,
+  SerovalIteratorFactoryInstanceNode,
+  SerovalNode,
+  SerovalNodeWithID,
+  SerovalNumberNode,
+  SerovalObjectRecordNode,
+  SerovalPluginNode,
+  SerovalReferenceNode,
+  SerovalRegExpNode,
+  SerovalSetNode,
+  SerovalStreamConstructorNode,
+  SerovalStreamNextNode,
+  SerovalStreamReturnNode,
+  SerovalStreamThrowNode,
+  SerovalStringNode,
+  SerovalTypedArrayNode,
+  SerovalWKSymbolNode,
+} from './types';
+import { getErrorConstructor } from './utils/error';
+import { getObjectFlag } from './utils/get-object-flag';
+import type {
+  BigIntTypedArrayValue,
+  TypedArrayValue,
+} from './utils/typed-array';
+
+export function createNumberNode(
+  value: number,
+): SerovalConstantNode | SerovalNumberNode {
+  switch (value) {
+    case Number.POSITIVE_INFINITY:
+      return INFINITY_NODE;
+    case Number.NEGATIVE_INFINITY:
+      return NEG_INFINITY_NODE;
+  }
+  if (value !== value) {
+    return NAN_NODE;
+  }
+  if (Object.is(value, -0)) {
+    return NEG_ZERO_NODE;
+  }
+  return createSerovalNode(
+    SerovalNodeType.Number,
+    NIL,
+    value,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createStringNode(value: string): SerovalStringNode {
+  return createSerovalNode(
+    SerovalNodeType.String,
+    NIL,
+    serializeString(value),
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createBigIntNode(current: bigint): SerovalBigIntNode {
+  return createSerovalNode(
+    SerovalNodeType.BigInt,
+    NIL,
+    '' + current,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createIndexedValueNode(id: number): SerovalIndexedValueNode {
+  return createSerovalNode(
+    SerovalNodeType.IndexedValue,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createDateNode(id: number, current: Date): SerovalDateNode {
+  const timestamp = current.valueOf();
+  return createSerovalNode(
+    SerovalNodeType.Date,
+    id,
+    timestamp !== timestamp ? '' : current.toISOString(),
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createRegExpNode(
+  id: number,
+  current: RegExp,
+): SerovalRegExpNode {
+  return createSerovalNode(
+    SerovalNodeType.RegExp,
+    id,
+    NIL,
+    serializeString(current.source),
+    current.flags,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createWKSymbolNode(
+  id: number,
+  current: WellKnownSymbols,
+): SerovalWKSymbolNode {
+  return createSerovalNode(
+    SerovalNodeType.WKSymbol,
+    id,
+    INV_SYMBOL_REF[current],
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createReferenceNode<T>(
+  id: number,
+  ref: T,
+): SerovalReferenceNode {
+  return createSerovalNode(
+    SerovalNodeType.Reference,
+    id,
+    serializeString(getReferenceID(ref)),
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createPluginNode(
+  id: number,
+  tag: string,
+  value: unknown,
+): SerovalPluginNode {
+  return createSerovalNode(
+    SerovalNodeType.Plugin,
+    id,
+    value,
+    serializeString(tag),
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createArrayNode(
+  id: number,
+  current: unknown[],
+  parsedItems: SerovalArrayNode['a'],
+): SerovalArrayNode {
+  return createSerovalNode(
+    SerovalNodeType.Array,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    parsedItems,
+    NIL,
+    NIL,
+    getObjectFlag(current),
+    NIL,
+  );
+}
+
+export function createBoxedNode(
+  id: number,
+  boxed: SerovalNode,
+): SerovalBoxedNode {
+  return createSerovalNode(
+    SerovalNodeType.Boxed,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    boxed,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createTypedArrayNode(
+  id: number,
+  current: TypedArrayValue,
+  buffer: SerovalNode,
+): SerovalTypedArrayNode {
+  return createSerovalNode(
+    SerovalNodeType.TypedArray,
+    id,
+    NIL,
+    current.constructor.name,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    buffer,
+    current.byteOffset,
+    NIL,
+    current.length,
+  );
+}
+
+export function createBigIntTypedArrayNode(
+  id: number,
+  current: BigIntTypedArrayValue,
+  buffer: SerovalNode,
+): SerovalBigIntTypedArrayNode {
+  return createSerovalNode(
+    SerovalNodeType.BigIntTypedArray,
+    id,
+    NIL,
+    current.constructor.name,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    buffer,
+    current.byteOffset,
+    NIL,
+    current.byteLength,
+  );
+}
+
+export function createDataViewNode(
+  id: number,
+  current: DataView,
+  buffer: SerovalNode,
+): SerovalDataViewNode {
+  return createSerovalNode(
+    SerovalNodeType.DataView,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    buffer,
+    current.byteOffset,
+    NIL,
+    current.byteLength,
+  );
+}
+
+export function createErrorNode(
+  id: number,
+  current: Error,
+  options: SerovalObjectRecordNode | undefined,
+): SerovalErrorNode {
+  return createSerovalNode(
+    SerovalNodeType.Error,
+    id,
+    getErrorConstructor(current),
+    NIL,
+    serializeString(current.message),
+    options,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createAggregateErrorNode(
+  id: number,
+  current: AggregateError,
+  options: SerovalObjectRecordNode | undefined,
+): SerovalAggregateErrorNode {
+  return createSerovalNode(
+    SerovalNodeType.AggregateError,
+    id,
+    getErrorConstructor(current),
+    NIL,
+    serializeString(current.message),
+    options,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createSetNode(
+  id: number,
+  items: SerovalNode[],
+): SerovalSetNode {
+  return createSerovalNode(
+    SerovalNodeType.Set,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    items,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createIteratorFactoryInstanceNode(
+  factory: SerovalNodeWithID,
+  items: SerovalNode,
+): SerovalIteratorFactoryInstanceNode {
+  return createSerovalNode(
+    SerovalNodeType.IteratorFactoryInstance,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    [factory, items],
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createAsyncIteratorFactoryInstanceNode(
+  factory: SerovalNodeWithID,
+  items: SerovalNode,
+): SerovalAsyncIteratorFactoryInstanceNode {
+  return createSerovalNode(
+    SerovalNodeType.AsyncIteratorFactoryInstance,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    [factory, items],
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createStreamConstructorNode(
+  id: number,
+  factory: SerovalNodeWithID,
+  sequence: SerovalNode[],
+): SerovalStreamConstructorNode {
+  return createSerovalNode(
+    SerovalNodeType.StreamConstructor,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    sequence,
+    factory,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createStreamNextNode(
+  id: number,
+  parsed: SerovalNode,
+): SerovalStreamNextNode {
+  return createSerovalNode(
+    SerovalNodeType.StreamNext,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    parsed,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createStreamThrowNode(
+  id: number,
+  parsed: SerovalNode,
+): SerovalStreamThrowNode {
+  return createSerovalNode(
+    SerovalNodeType.StreamThrow,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    parsed,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export function createStreamReturnNode(
+  id: number,
+  parsed: SerovalNode,
+): SerovalStreamReturnNode {
+  return createSerovalNode(
+    SerovalNodeType.StreamReturn,
+    id,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    parsed,
+    NIL,
+    NIL,
+    NIL,
+  );
+}

package/src/core/compat.ts

@@ -0,0 +1,23 @@
+/**
+ * References
+ * - https://compat-table.github.io/compat-table/es6/
+ * - MDN
+ */
+
+export enum Feature {
+  AggregateError = 0x01,
+  // @deprecated
+  ArrowFunction = 0x02,
+  ErrorPrototypeStack = 0x04,
+  ObjectAssign = 0x08,
+  BigIntTypedArray = 0x10,
+  RegExp = 0x20,
+}
+
+export const ALL_ENABLED =
+  Feature.AggregateError |
+  Feature.ArrowFunction |
+  Feature.ErrorPrototypeStack |
+  Feature.ObjectAssign |
+  Feature.BigIntTypedArray |
+  Feature.RegExp;

package/src/core/constants.ts

@@ -0,0 +1,201 @@
+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,
+  True = 2,
+  False = 3,
+  NegZero = 4,
+  Inf = 5,
+  NegInf = 6,
+  Nan = 7,
+}
+
+export const enum SerovalNodeType {
+  Number = 0,
+  String = 1,
+  Constant = 2,
+  BigInt = 3,
+  IndexedValue = 4,
+  Date = 5,
+  RegExp = 6,
+  Set = 7,
+  Map = 8,
+  Array = 9,
+  Object = 10,
+  NullConstructor = 11,
+  Promise = 12,
+  Error = 13,
+  AggregateError = 14,
+  TypedArray = 15,
+  BigIntTypedArray = 16,
+  WKSymbol = 17,
+  Reference = 18,
+  ArrayBuffer = 19,
+  DataView = 20,
+  Boxed = 21,
+  PromiseConstructor = 22,
+  PromiseSuccess = 23,
+  PromiseFailure = 24,
+  Plugin = 25,
+  SpecialReference = 26,
+  IteratorFactory = 27,
+  IteratorFactoryInstance = 28,
+  AsyncIteratorFactory = 29,
+  AsyncIteratorFactoryInstance = 30,
+  StreamConstructor = 31,
+  StreamNext = 32,
+  StreamThrow = 33,
+  StreamReturn = 34,
+}
+
+export const enum SerovalObjectFlags {
+  None = 0,
+  NonExtensible = 1,
+  Sealed = 2,
+  Frozen = 3,
+}
+
+export const enum Symbols {
+  AsyncIterator = 0,
+  HasInstance = 1,
+  IsConcatSpreadable = 2,
+  Iterator = 3,
+  Match = 4,
+  MatchAll = 5,
+  Replace = 6,
+  Search = 7,
+  Species = 8,
+  Split = 9,
+  ToPrimitive = 10,
+  ToStringTag = 11,
+  Unscopables = 12,
+}
+
+export const SYMBOL_STRING: Record<Symbols, string> = {
+  [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',
+};
+
+export const INV_SYMBOL_REF = /* @__PURE__ */ {
+  [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]: 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> = {
+  [SerovalConstant.True]: '!0',
+  [SerovalConstant.False]: '!1',
+  [SerovalConstant.Undefined]: 'void 0',
+  [SerovalConstant.Null]: 'null',
+  [SerovalConstant.NegZero]: '-0',
+  [SerovalConstant.Inf]: '1/0',
+  [SerovalConstant.NegInf]: '-1/0',
+  [SerovalConstant.Nan]: '0/0',
+};
+
+export const NIL = void 0;
+
+export const CONSTANT_VAL: Record<SerovalConstant, unknown> = {
+  [SerovalConstant.True]: true,
+  [SerovalConstant.False]: false,
+  [SerovalConstant.Undefined]: NIL,
+  [SerovalConstant.Null]: null,
+  [SerovalConstant.NegZero]: -0,
+  [SerovalConstant.Inf]: Number.POSITIVE_INFINITY,
+  [SerovalConstant.NegInf]: Number.NEGATIVE_INFINITY,
+  [SerovalConstant.Nan]: Number.NaN,
+};
+
+export const enum ErrorConstructorTag {
+  Error = 0,
+  EvalError = 1,
+  RangeError = 2,
+  ReferenceError = 3,
+  SyntaxError = 4,
+  TypeError = 5,
+  URIError = 6,
+}
+
+export const ERROR_CONSTRUCTOR_STRING: Record<ErrorConstructorTag, string> = {
+  [ErrorConstructorTag.Error]: 'Error',
+  [ErrorConstructorTag.EvalError]: 'EvalError',
+  [ErrorConstructorTag.RangeError]: 'RangeError',
+  [ErrorConstructorTag.ReferenceError]: 'ReferenceError',
+  [ErrorConstructorTag.SyntaxError]: 'SyntaxError',
+  [ErrorConstructorTag.TypeError]: 'TypeError',
+  [ErrorConstructorTag.URIError]: 'URIError',
+};
+
+type ErrorConstructors =
+  | ErrorConstructor
+  | EvalErrorConstructor
+  | RangeErrorConstructor
+  | ReferenceErrorConstructor
+  | SyntaxErrorConstructor
+  | TypeErrorConstructor
+  | URIErrorConstructor;
+
+export const ERROR_CONSTRUCTOR: Record<ErrorConstructorTag, ErrorConstructors> =
+  {
+    [ErrorConstructorTag.Error]: Error,
+    [ErrorConstructorTag.EvalError]: EvalError,
+    [ErrorConstructorTag.RangeError]: RangeError,
+    [ErrorConstructorTag.ReferenceError]: ReferenceError,
+    [ErrorConstructorTag.SyntaxError]: SyntaxError,
+    [ErrorConstructorTag.TypeError]: TypeError,
+    [ErrorConstructorTag.URIError]: URIError,
+  };