seroval 0.4.1 → 0.5.1

package/dist/types/compat.d.ts

@@ -14,7 +14,7 @@ export declare const enum Feature {
     ObjectAssign = 128,
     Promise = 256,
     Set = 512,
-    SymbolIterator = 1024,
+    Symbol = 1024,
     TypedArray = 2048,
     BigIntTypedArray = 4096
 }

package/dist/types/context.d.ts

@@ -1,3 +1,4 @@
+import { AsyncServerValue } from './types';
 interface IndexAssignment {
     t: 'index';
     s: string;
@@ -30,6 +31,7 @@ export interface SerializationContext {
     vars: string[];
     assignments: Assignment[];
     features: number;
+    valueMap: Map<number, AsyncServerValue>;
 }
 export interface Options {
     disabledFeatures: number;
@@ -49,8 +51,6 @@ export declare function markRef(ctx: ParserContext | SerializationContext, curre
  * Calling this function means the value has been referenced somewhere
  */
 export declare function getRefParam(ctx: SerializationContext, index: number): string;
-/**
- * Creates a reference ID from the given values
- */
-export declare function createRef(ctx: ParserContext, current: unknown, mark: boolean): number;
+export declare function getRootID(ctx: ParserContext, current: AsyncServerValue): number;
+export declare function createRef(ctx: ParserContext, current: AsyncServerValue): number;
 export {};

package/dist/types/quote.d.ts

@@ -1 +1,2 @@
 export default function quote(str: string): string;
+export declare function invQuote(str: string): string;

package/dist/types/tree/deserialize.d.ts

@@ -0,0 +1,4 @@
+import { SerializationContext } from '../context';
+import { AsyncServerValue } from '../types';
+import { SerovalNode } from './types';
+export default function deserializeTree(ctx: SerializationContext, node: SerovalNode): AsyncServerValue;

package/dist/types/tree/primitives.d.ts

@@ -1,17 +1,21 @@
 import { ParserContext } from '../context';
 import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
-import { SerovalBigIntNode, SerovalBigIntTypedArrayNode, SerovalDateNode, SerovalPrimitiveNode, SerovalReferenceNode, SerovalRegExpNode, SerovalTypedArrayNode } from './types';
-export declare function createPrimitiveNode(value: string | number | null): SerovalPrimitiveNode;
-export declare const TRUE_NODE: SerovalPrimitiveNode;
-export declare const FALSE_NODE: SerovalPrimitiveNode;
-export declare const UNDEFINED_NODE: SerovalPrimitiveNode;
-export declare const NULL_NODE: SerovalPrimitiveNode;
-export declare const NEG_ZERO_NODE: SerovalPrimitiveNode;
-export declare const INFINITY_NODE: SerovalPrimitiveNode;
-export declare const NEG_INFINITY_NODE: SerovalPrimitiveNode;
+import { WellKnownSymbols } from './symbols';
+import { SerovalBigIntNode, SerovalBigIntTypedArrayNode, SerovalBooleanNode, SerovalDateNode, SerovalInfinityNode, SerovalNaNNode, SerovalNegativeInfinityNode, SerovalNegativeZeroNode, SerovalNullNode, SerovalNumberNode, SerovalReferenceNode, SerovalRegExpNode, SerovalStringNode, SerovalTypedArrayNode, SerovalUndefinedNode, SerovalWKSymbolNode } from './types';
+export declare const TRUE_NODE: SerovalBooleanNode;
+export declare const FALSE_NODE: SerovalBooleanNode;
+export declare const UNDEFINED_NODE: SerovalUndefinedNode;
+export declare const NULL_NODE: SerovalNullNode;
+export declare const NEG_ZERO_NODE: SerovalNegativeZeroNode;
+export declare const INFINITY_NODE: SerovalInfinityNode;
+export declare const NEG_INFINITY_NODE: SerovalNegativeInfinityNode;
+export declare const NAN_NODE: SerovalNaNNode;
+export declare function createNumberNode(value: number): SerovalNumberNode;
+export declare function createStringNode(value: string): SerovalStringNode;
 export declare function createBigIntNode(ctx: ParserContext, current: bigint): SerovalBigIntNode;
 export declare function createReferenceNode(id: number): SerovalReferenceNode;
 export declare function createDateNode(id: number, current: Date): SerovalDateNode;
 export declare function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode;
 export declare function createTypedArrayNode(ctx: ParserContext, id: number, current: TypedArrayValue): SerovalTypedArrayNode;
 export declare function createBigIntTypedArrayNode(ctx: ParserContext, id: number, current: BigIntTypedArrayValue): SerovalBigIntTypedArrayNode;
+export declare function createWKSymbolNode(current: WellKnownSymbols): SerovalWKSymbolNode;

package/dist/types/tree/shared.d.ts

@@ -1,6 +1,9 @@
 import { ParserContext } from '../context';
 import { AsyncServerValue, ErrorValue } from '../types';
-export declare function getErrorConstructor(error: ErrorValue): "EvalError" | "RangeError" | "ReferenceError" | "SyntaxError" | "TypeError" | "URIError" | "Error";
+export declare function getErrorConstructorName(error: ErrorValue): "EvalError" | "RangeError" | "ReferenceError" | "SyntaxError" | "TypeError" | "URIError" | "Error";
+export declare function getErrorConstructor(errorName: string): ErrorConstructor;
 export declare function getErrorOptions(ctx: ParserContext, error: Error): Record<string, any> | undefined;
 export declare function getIterableOptions(obj: Iterable<any>): Record<string, unknown> | undefined;
 export declare function isIterable(value: unknown): value is Iterable<AsyncServerValue>;
+export declare function getTypedArrayConstructor(name: string): Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor;
+export declare function isValidIdentifier(name: string): boolean;

package/dist/types/tree/symbols.d.ts

@@ -0,0 +1,33 @@
+export declare 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 declare const SYMBOL_STRING: Record<Symbols, string>;
+export declare const INV_SYMBOL_REF: {
+    [Symbol.asyncIterator]: Symbols;
+    [Symbol.hasInstance]: Symbols;
+    [Symbol.isConcatSpreadable]: Symbols;
+    [Symbol.iterator]: Symbols;
+    [Symbol.match]: Symbols;
+    [Symbol.matchAll]: Symbols;
+    [Symbol.replace]: Symbols;
+    [Symbol.search]: Symbols;
+    [Symbol.species]: Symbols;
+    [Symbol.split]: Symbols;
+    [Symbol.toPrimitive]: Symbols;
+    [Symbol.toStringTag]: Symbols;
+    [Symbol.unscopables]: Symbols;
+};
+export type WellKnownSymbols = keyof typeof INV_SYMBOL_REF;
+export declare const SYMBOL_REF: Record<Symbols, WellKnownSymbols>;

package/dist/types/tree/types.d.ts

@@ -1,32 +1,41 @@
-import { PrimitiveValue } from '../types';
+import { Symbols } from './symbols';
 export declare const enum SerovalNodeType {
-    Primitive = 0,
-    BigInt = 1,
-    Reference = 2,
-    Date = 3,
-    RegExp = 4,
-    Set = 5,
-    Map = 6,
-    Array = 7,
-    Object = 8,
-    NullConstructor = 9,
-    Promise = 10,
-    Error = 11,
-    AggregateError = 12,
-    Iterable = 13,
-    TypedArray = 14,
-    BigIntTypedArray = 15
+    Number = 0,
+    String = 1,
+    Boolean = 2,
+    Null = 3,
+    Undefined = 4,
+    NegativeZero = 5,
+    Infinity = 6,
+    NegativeInfinity = 7,
+    NaN = 8,
+    BigInt = 9,
+    Reference = 10,
+    Date = 11,
+    RegExp = 12,
+    Set = 13,
+    Map = 14,
+    Array = 15,
+    Object = 16,
+    NullConstructor = 17,
+    Promise = 18,
+    Error = 19,
+    AggregateError = 20,
+    Iterable = 21,
+    TypedArray = 22,
+    BigIntTypedArray = 23,
+    WKSymbol = 24
 }
 export interface SerovalBaseNode {
     t: SerovalNodeType;
-    s: PrimitiveValue | undefined;
     i: number | undefined;
+    s: any;
     l: number | undefined;
     c: string | undefined;
-    d: SerovalDictionaryNode | undefined;
     m: string | undefined;
-    n: SerovalNode | undefined;
+    d: SerovalDictionaryNode | undefined;
     a: SerovalNode[] | undefined;
+    f: SerovalNode | undefined;
 }
 export interface SerovalObjectRecordNode {
     k: string[];
@@ -39,9 +48,37 @@ export interface SerovalMapRecordNode {
     s: number;
 }
 export type SerovalDictionaryNode = SerovalObjectRecordNode | SerovalMapRecordNode;
-export interface SerovalPrimitiveNode extends SerovalBaseNode {
-    t: SerovalNodeType.Primitive;
+export interface SerovalNumberNode extends SerovalBaseNode {
+    t: SerovalNodeType.Number;
+    s: number;
+}
+export interface SerovalStringNode extends SerovalBaseNode {
+    t: SerovalNodeType.String;
+    s: string;
+}
+export interface SerovalBooleanNode extends SerovalBaseNode {
+    t: SerovalNodeType.Boolean;
+    s: boolean;
+}
+export interface SerovalNullNode extends SerovalBaseNode {
+    t: SerovalNodeType.Null;
+}
+export interface SerovalUndefinedNode extends SerovalBaseNode {
+    t: SerovalNodeType.Undefined;
+}
+export interface SerovalNegativeZeroNode extends SerovalBaseNode {
+    t: SerovalNodeType.NegativeZero;
+}
+export interface SerovalInfinityNode extends SerovalBaseNode {
+    t: SerovalNodeType.Infinity;
+}
+export interface SerovalNegativeInfinityNode extends SerovalBaseNode {
+    t: SerovalNodeType.NegativeInfinity;
+}
+export interface SerovalNaNNode extends SerovalBaseNode {
+    t: SerovalNodeType.NaN;
 }
+export type SerovalPrimitiveNode = SerovalNumberNode | SerovalStringNode | SerovalBooleanNode | SerovalNullNode | SerovalUndefinedNode | SerovalNegativeZeroNode | SerovalNegativeInfinityNode | SerovalInfinityNode | SerovalNaNNode;
 export interface SerovalReferenceNode extends SerovalBaseNode {
     t: SerovalNodeType.Reference;
     i: number;
@@ -58,25 +95,27 @@ export interface SerovalDateNode extends SerovalBaseNode {
 export interface SerovalRegExpNode extends SerovalBaseNode {
     t: SerovalNodeType.RegExp;
     i: number;
-    s: string;
+    c: string;
+    m: string;
 }
 export interface SerovalTypedArrayNode extends SerovalBaseNode {
     t: SerovalNodeType.TypedArray;
     i: number;
-    s: string;
+    s: string[];
     l: number;
     c: string;
 }
 export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
     t: SerovalNodeType.BigIntTypedArray;
     i: number;
-    s: string;
+    s: string[];
     l: number;
     c: string;
 }
 export type SerovalSemiPrimitiveNode = SerovalBigIntNode | SerovalDateNode | SerovalRegExpNode | SerovalTypedArrayNode | SerovalBigIntTypedArrayNode;
 export interface SerovalSetNode extends SerovalBaseNode {
     t: SerovalNodeType.Set;
+    l: number;
     a: SerovalNode[];
     i: number;
 }
@@ -87,6 +126,7 @@ export interface SerovalMapNode extends SerovalBaseNode {
 }
 export interface SerovalArrayNode extends SerovalBaseNode {
     t: SerovalNodeType.Array;
+    l: number;
     a: SerovalNode[];
     i: number;
 }
@@ -102,7 +142,7 @@ export interface SerovalNullConstructorNode extends SerovalBaseNode {
 }
 export interface SerovalPromiseNode extends SerovalBaseNode {
     t: SerovalNodeType.Promise;
-    n: SerovalNode;
+    f: SerovalNode;
     i: number;
 }
 export interface SerovalErrorNode extends SerovalBaseNode {
@@ -116,13 +156,19 @@ export interface SerovalAggregateErrorNode extends SerovalBaseNode {
     t: SerovalNodeType.AggregateError;
     m: string;
     d: SerovalObjectRecordNode | undefined;
-    n: SerovalNode;
+    l: number;
+    a: SerovalNode[];
     i: number;
 }
 export interface SerovalIterableNode extends SerovalBaseNode {
     t: SerovalNodeType.Iterable;
     d: SerovalObjectRecordNode | undefined;
+    l: number;
     a: SerovalNode[];
     i: number;
 }
-export type SerovalNode = SerovalPrimitiveNode | SerovalReferenceNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalIterableNode;
+export interface SerovalWKSymbolNode extends SerovalBaseNode {
+    t: SerovalNodeType.WKSymbol;
+    s: Symbols;
+}
+export type SerovalNode = SerovalPrimitiveNode | SerovalReferenceNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalIterableNode | SerovalWKSymbolNode;

package/dist/types/types.d.ts

@@ -1,4 +1,5 @@
-export type PrimitiveValue = boolean | string | number | undefined | null;
+import { WellKnownSymbols } from './tree/symbols';
+export type PrimitiveValue = boolean | string | number | undefined | null | WellKnownSymbols;
 export type ErrorValue = Error | AggregateError | EvalError | RangeError | ReferenceError | TypeError | SyntaxError | URIError;
 export type TypedArrayValue = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
 export type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "files": [
     "dist",
     "src"
@@ -14,10 +14,10 @@
     "pridepack"
   ],
   "devDependencies": {
-    "@types/node": "^18.11.18",
+    "@types/node": "^18.15.3",
     "eslint": "^8.32.0",
     "eslint-config-lxsmnsyc": "^0.4.8",
-    "pridepack": "2.4.0",
+    "pridepack": "2.4.1",
     "tslib": "^2.4.1",
     "typescript": "^4.9.4",
     "vitest": "^0.28.1"
@@ -64,5 +64,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "a3cfb8eae6e1f9a2d2939b03c5ae88fa24c738f8"
+  "gitHead": "2154c039056b24f706dbb1c2006acd99383e9305"
 }

package/src/compat.ts

@@ -16,7 +16,7 @@ export const enum Feature {
   ObjectAssign = 0x80,
   Promise = 0x100,
   Set = 0x200,
-  SymbolIterator = 0x400,
+  Symbol = 0x400,
   TypedArray = 0x800,
   BigIntTypedArray = 0x1000,
 }

package/src/context.ts

@@ -1,5 +1,6 @@
 import { ALL_ENABLED } from './compat';
 import getIdentifier from './get-identifier';
+import { AsyncServerValue } from './types';
 
 interface IndexAssignment {
   t: 'index';
@@ -47,6 +48,8 @@ export interface SerializationContext {
   assignments: Assignment[];
   // Supported features
   features: number;
+
+  valueMap: Map<number, AsyncServerValue>;
 }
 
 export interface Options {
@@ -81,6 +84,7 @@ export function createSerializationContext(options: SerializationOptions): Seria
     refSize: 0,
     features: options.features,
     markedRefs: new Set(options.markedRefs),
+    valueMap: new Map(),
   };
 }
 
@@ -90,61 +94,51 @@ export function createSerializationContext(options: SerializationOptions): Seria
 export function markRef(ctx: ParserContext | SerializationContext, current: number) {
   ctx.markedRefs.add(current);
 }
-
-/**
- * Creates a new reference ID from a given reference ID
- * This new reference ID means that the reference itself
- * has been referenced at least once, and is used to generate
- * the variables
- */
-function createValidRef(
-  ctx: SerializationContext,
-  index: number,
-) {
-  const current = ctx.validRefs[index];
-  if (current == null) {
-    const value = ctx.refSize++;
-    ctx.validRefs[index] = value;
-    return value;
-  }
-  return current;
-}
-
 /**
  * Creates the reference param (identifier) from the given reference ID
  * Calling this function means the value has been referenced somewhere
  */
 export function getRefParam(ctx: SerializationContext, index: number) {
-  const actualIndex = createValidRef(ctx, index);
-  if (ctx.vars[actualIndex]) {
-    return ctx.vars[actualIndex];
+  /**
+   * Creates a new reference ID from a given reference ID
+   * This new reference ID means that the reference itself
+   * has been referenced at least once, and is used to generate
+   * the variables
+   */
+  let actualIndex = ctx.validRefs[index];
+  if (actualIndex == null) {
+    actualIndex = ctx.refSize++;
+    ctx.validRefs[index] = actualIndex;
+  }
+  let identifier = ctx.vars[actualIndex];
+  if (identifier == null) {
+    identifier = getIdentifier(actualIndex);
+    ctx.vars[actualIndex] = identifier;
   }
-  const result = getIdentifier(actualIndex);
-  ctx.vars[actualIndex] = result;
-  return result;
+  return identifier;
+}
+
+export function getRootID(
+  ctx: ParserContext,
+  current: AsyncServerValue,
+) {
+  const ref = ctx.refs.get(current);
+  if (ref == null) {
+    return ctx.refs.size;
+  }
+  return ref;
 }
 
-/**
- * Creates a reference ID from the given values
- */
 export function createRef(
   ctx: ParserContext,
-  current: unknown,
-  mark: boolean,
-): number {
-  // Check if reference number already exists
+  current: AsyncServerValue,
+) {
   const ref = ctx.refs.get(current);
-  if (ref != null) {
-    // Exists, means this value is currently
-    // being referenced
-    // Mark reference
-    if (mark) {
-      markRef(ctx, ref);
-    }
-    return ref;
+  if (ref == null) {
+    const id = ctx.refs.size;
+    ctx.refs.set(current, id);
+    return id;
   }
-  // Create a new reference ID
-  const id = ctx.refs.size;
-  ctx.refs.set(current, id);
-  return id;
+  markRef(ctx, ref);
+  return ref;
 }

package/src/index.ts

@@ -8,6 +8,7 @@ import {
   createSerializationContext,
 } from './context';
 import parseAsync from './tree/async';
+import deserializeTree from './tree/deserialize';
 import serializeTree, { resolvePatches } from './tree/serialize';
 import parseSync from './tree/sync';
 import { SerovalNode } from './tree/types';
@@ -141,7 +142,11 @@ export function compileJSON(source: SerovalJSON): string {
 }
 
 export function fromJSON<T extends AsyncServerValue>(source: SerovalJSON): T {
-  return deserialize<T>(compileJSON(source));
+  const serial = createSerializationContext({
+    features: source.f,
+    markedRefs: source.m,
+  });
+  return deserializeTree(serial, source.t) as T;
 }
 
 export default serialize;

package/src/quote.ts

@@ -41,5 +41,16 @@ export default function quote(str: string) {
   } else {
     result += str.slice(lastPos);
   }
-  return '"' + result + '"';
+  return result;
+}
+
+export function invQuote(str: string): string {
+  return str
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\')
+    .replace(/\\x3C/g, '<')
+    .replace(/\\n/g, '\n')
+    .replace(/\\r/g, '\r')
+    .replace(/\\u2028/g, '\u2028')
+    .replace(/\\u2029/g, '\u2029');
 }