seroval 0.4.0 → 0.5.0

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;

package/dist/types/index.d.ts

@@ -1,12 +1,20 @@
 import { Feature } from './compat';
 import { Options } from './context';
+import { SerovalNode } from './tree/types';
 import { AsyncServerValue, PrimitiveValue, ServerValue, CommonServerValue, SemiPrimitiveValue, ErrorValue } from './types';
 export { AsyncServerValue, ServerValue, PrimitiveValue, CommonServerValue, SemiPrimitiveValue, ErrorValue, Feature, };
 export declare function serialize<T extends ServerValue>(source: T, options?: Partial<Options>): string;
 export declare function serializeAsync<T extends AsyncServerValue>(source: T, options?: Partial<Options>): Promise<string>;
 export declare function deserialize<T extends AsyncServerValue>(source: string): T;
-export declare function toJSON<T extends ServerValue>(source: T, options?: Partial<Options>): string;
-export declare function toJSONAsync<T extends AsyncServerValue>(source: T, options?: Partial<Options>): Promise<string>;
-export declare function compileJSON(source: string): string;
-export declare function fromJSON<T extends AsyncServerValue>(source: string): T;
+export interface SerovalJSON {
+    t: SerovalNode;
+    r: number;
+    i: boolean;
+    f: number;
+    m: number[];
+}
+export declare function toJSON<T extends ServerValue>(source: T, options?: Partial<Options>): SerovalJSON;
+export declare function toJSONAsync<T extends AsyncServerValue>(source: T, options?: Partial<Options>): Promise<SerovalJSON>;
+export declare function compileJSON(source: SerovalJSON): string;
+export declare function fromJSON<T extends AsyncServerValue>(source: SerovalJSON): T;
 export default serialize;

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;
+    n: 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;
 }
@@ -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.0",
+  "version": "0.5.0",
   "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": "4767da3b4b6397d6830978b6f4d0f014d2115479"
+  "gitHead": "7c2e32b409df6bc01b5d5b38fdd3f9980a8b4984"
 }

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(),
   };
 }
 

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';
@@ -93,7 +94,7 @@ export function deserialize<T extends AsyncServerValue>(source: string): T {
   return (0, eval)(source) as T;
 }
 
-interface SerovalJSON {
+export interface SerovalJSON {
   t: SerovalNode,
   r: number,
   i: boolean,
@@ -104,45 +105,48 @@ interface SerovalJSON {
 export function toJSON<T extends ServerValue>(
   source: T,
   options?: Partial<Options>,
-) {
+): SerovalJSON {
   const ctx = createParserContext(options);
   const [tree, root, isObject] = parseSync(ctx, source);
-  return JSON.stringify({
+  return {
     t: tree,
     r: root,
     i: isObject,
     f: ctx.features,
     m: Array.from(ctx.markedRefs),
-  });
+  };
 }
 
 export async function toJSONAsync<T extends AsyncServerValue>(
   source: T,
   options?: Partial<Options>,
-) {
+): Promise<SerovalJSON> {
   const ctx = createParserContext(options);
   const [tree, root, isObject] = await parseAsync(ctx, source);
-  return JSON.stringify({
+  return {
     t: tree,
     r: root,
     i: isObject,
     f: ctx.features,
     m: Array.from(ctx.markedRefs),
-  });
+  };
 }
 
-export function compileJSON(source: string): string {
-  const parsed = JSON.parse(source) as SerovalJSON;
+export function compileJSON(source: SerovalJSON): string {
   const serial = createSerializationContext({
-    features: parsed.f,
-    markedRefs: parsed.m,
+    features: source.f,
+    markedRefs: source.m,
   });
-  const result = serializeTree(serial, parsed.t);
-  return finalize(serial, parsed.r, parsed.i, result);
+  const result = serializeTree(serial, source.t);
+  return finalize(serial, source.r, source.i, result);
 }
 
-export function fromJSON<T extends AsyncServerValue>(source: string): T {
-  return deserialize<T>(compileJSON(source));
+export function fromJSON<T extends AsyncServerValue>(source: SerovalJSON): T {
+  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');
 }

package/src/tree/async.ts

@@ -3,7 +3,6 @@
 import assert from '../assert';
 import { Feature } from '../compat';
 import { createRef, ParserContext } from '../context';
-import quote from '../quote';
 import {
   AsyncServerValue,
   BigIntTypedArrayValue,
@@ -13,22 +12,28 @@ import {
   createBigIntNode,
   createBigIntTypedArrayNode,
   createDateNode,
-  createPrimitiveNode,
+  createNumberNode,
   createReferenceNode,
   createRegExpNode,
+  createStringNode,
   createTypedArrayNode,
+  createWKSymbolNode,
   FALSE_NODE,
+  INFINITY_NODE,
+  NAN_NODE,
+  NEG_INFINITY_NODE,
   NEG_ZERO_NODE,
   NULL_NODE,
   TRUE_NODE,
   UNDEFINED_NODE,
 } from './primitives';
 import {
-  getErrorConstructor,
+  getErrorConstructorName,
   getErrorOptions,
   getIterableOptions,
   isIterable,
 } from './shared';
+import { INV_SYMBOL_REF } from './symbols';
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
@@ -90,7 +95,7 @@ async function generateArrayNode(
     t: SerovalNodeType.Array,
     i: id,
     s: undefined,
-    l: undefined,
+    l: current.length,
     c: undefined,
     m: undefined,
     d: undefined,
@@ -168,7 +173,7 @@ async function generateSetNode(
     t: SerovalNodeType.Set,
     i: id,
     s: undefined,
-    l: undefined,
+    l: len,
     c: undefined,
     m: undefined,
     d: undefined,
@@ -218,20 +223,21 @@ async function generateIterableNode(
   id: number,
   current: Iterable<AsyncServerValue>,
 ): Promise<SerovalIterableNode> {
-  assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
+  assert(ctx.features & Feature.Symbol, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
+  const array = Array.from(current);
   return {
     t: SerovalNodeType.Iterable,
     i: id,
     s: undefined,
-    l: undefined,
+    l: array.length,
     c: undefined,
     m: undefined,
     // Parse options first before the items
     d: options
       ? await generateProperties(ctx, options as Record<string, AsyncServerValue>)
       : undefined,
-    a: await generateNodeList(ctx, Array.from(current)),
+    a: await generateNodeList(ctx, array),
     n: undefined,
   };
 }
@@ -294,12 +300,12 @@ async function generateAggregateErrorNode(
     t: SerovalNodeType.AggregateError,
     i: id,
     s: undefined,
-    l: undefined,
+    l: current.errors.length,
     c: undefined,
     m: current.message,
     d: optionsNode,
-    a: undefined,
-    n: await parse(ctx, current.errors),
+    a: await generateNodeList(ctx, current.errors as AsyncServerValue[]),
+    n: undefined,
   };
 }
 
@@ -317,7 +323,7 @@ async function generateErrorNode(
     i: id,
     s: undefined,
     l: undefined,
-    c: getErrorConstructor(current),
+    c: getErrorConstructorName(current),
     m: current.message,
     d: optionsNode,
     a: undefined,
@@ -335,18 +341,22 @@ async function parse(
     case 'undefined':
       return UNDEFINED_NODE;
     case 'string':
-      return createPrimitiveNode(quote(current));
+      return createStringNode(current);
     case 'number':
+      // eslint-disable-next-line no-self-compare
+      if (current !== current) {
+        return NAN_NODE;
+      }
       if (Object.is(current, -0)) {
         return NEG_ZERO_NODE;
       }
       if (Object.is(current, Infinity)) {
-        return createPrimitiveNode('1/0');
+        return INFINITY_NODE;
       }
       if (Object.is(current, -Infinity)) {
-        return createPrimitiveNode('-1/0');
+        return NEG_INFINITY_NODE;
       }
-      return createPrimitiveNode(current);
+      return createNumberNode(current);
     case 'bigint':
       return createBigIntNode(ctx, current);
     case 'object': {
@@ -443,6 +453,10 @@ async function parse(
       }
       throw new Error('Unsupported type');
     }
+    case 'symbol':
+      assert(ctx.features & Feature.Symbol, 'Unsupported type "symbol"');
+      assert(current in INV_SYMBOL_REF, 'seroval only supports well-known symbols');
+      return createWKSymbolNode(current);
     default:
       throw new Error('Unsupported type');
   }