seroval 0.4.0-alpha.9 → 0.4.0

package/dist/types/context.d.ts

@@ -1,40 +1,42 @@
 interface IndexAssignment {
-    type: 'index';
-    source: string;
-    value: string;
+    t: 'index';
+    s: string;
+    k: undefined;
+    v: string;
 }
 interface MapAssignment {
-    type: 'map';
-    source: string;
-    key: string;
-    value: string;
+    t: 'map';
+    s: string;
+    k: string;
+    v: string;
 }
 interface SetAssignment {
-    type: 'set';
-    source: string;
-    value: string;
+    t: 'set';
+    s: string;
+    k: undefined;
+    v: string;
 }
 export type Assignment = IndexAssignment | MapAssignment | SetAssignment;
 export interface ParserContext {
     refs: Map<unknown, number>;
-    markedRefs: Record<number, number>;
+    markedRefs: Set<number>;
     features: number;
 }
 export interface SerializationContext {
     stack: number[];
     validRefs: number[];
     refSize: number;
-    markedRefs: Record<number, number>;
+    markedRefs: Set<number>;
     vars: string[];
     assignments: Assignment[];
     features: number;
 }
 export interface Options {
-    target: string | string[];
+    disabledFeatures: number;
 }
 export declare function createParserContext(options?: Partial<Options>): ParserContext;
 export interface SerializationOptions {
-    markedRefs: Record<number, number>;
+    markedRefs: number[] | Set<number>;
     features: number;
 }
 export declare function createSerializationContext(options: SerializationOptions): SerializationContext;
@@ -50,5 +52,5 @@ export declare function getRefParam(ctx: SerializationContext, index: number): s
 /**
  * Creates a reference ID from the given values
  */
-export declare function createRef(ctx: ParserContext, index: unknown): number;
+export declare function createRef(ctx: ParserContext, current: unknown, mark: boolean): number;
 export {};

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
+import { Feature } from './compat';
 import { Options } from './context';
 import { AsyncServerValue, PrimitiveValue, ServerValue, CommonServerValue, SemiPrimitiveValue, ErrorValue } from './types';
-export { AsyncServerValue, ServerValue, PrimitiveValue, CommonServerValue, SemiPrimitiveValue, ErrorValue, };
+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;

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

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

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

@@ -1,10 +1,6 @@
-import { SerializationContext, ParserContext } from '../context';
-import { ErrorValue, PrimitiveValue } from '../types';
-import { SerovalNode, SerovalReferenceNode } from './types';
+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 getErrorOptions(error: Error): Record<string, any> | undefined;
+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 isReferenceInStack(ctx: SerializationContext, node: SerovalNode): node is SerovalReferenceNode;
-export declare function generateRef(ctx: ParserContext, current: unknown): number | SerovalReferenceNode;
-export declare function generateSemiPrimitiveValue(ctx: ParserContext, current: unknown, id: number): SerovalNode | undefined;
-export declare function serializePrimitive(value: PrimitiveValue): string | number | null;
+export declare function isIterable(value: unknown): value is Iterable<AsyncServerValue>;

package/dist/types/types.d.ts

@@ -1,7 +1,8 @@
 export type PrimitiveValue = boolean | string | number | undefined | null;
 export type ErrorValue = Error | AggregateError | EvalError | RangeError | ReferenceError | TypeError | SyntaxError | URIError;
-export type TypedArrayValue = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-export type SemiPrimitiveValue = RegExp | Date | TypedArrayValue | bigint;
+export type TypedArrayValue = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
+export type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;
+export type SemiPrimitiveValue = RegExp | Date | TypedArrayValue | BigIntTypedArrayValue | bigint;
 export type CommonServerValue = PrimitiveValue | SemiPrimitiveValue | ErrorValue;
 export type ServerValue = CommonServerValue | Array<ServerValue> | readonly ServerValue[] | Iterable<ServerValue> | {
     [key: string | number]: ServerValue;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.4.0-alpha.9",
+  "version": "0.4.0",
   "files": [
     "dist",
     "src"
@@ -64,5 +64,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "27ff8d23e589e5968ebe968b14d050cd468ca49f"
+  "gitHead": "4767da3b4b6397d6830978b6f4d0f014d2115479"
 }

package/src/compat.ts

@@ -3,258 +3,22 @@
  * References
  * - https://kangax.github.io/compat-table/es6/
  * - MDN
- * - ESBuild
  */
 
-import assert from './assert';
-
-export type Version = [major: number, minor: number, patch: number];
-
-function compareVersion(left: Version, right: Version) {
-  let diff = left[0] - right[0];
-  if (diff === 0) {
-    diff = left[1] - right[1];
-  }
-  if (diff === 0) {
-    diff = left[2] - right[2];
-  }
-  return diff;
-}
-
-export interface PlatformVersion {
-  es: Version;
-  // desktop
-  chrome?: Version;
-  edge?: Version;
-  safari?: Version;
-  firefox?: Version;
-  opera?: Version;
-  // mobile
-  ios?: Version;
-  samsung?: Version;
-  // js runtimes
-  deno?: Version;
-  node?: Version;
-}
-
-export type Platform = keyof PlatformVersion;
-
 export const enum Feature {
   AggregateError = 0x01,
   ArrayPrototypeValues = 0x02,
   ArrowFunction = 0x04,
   BigInt = 0x08,
-  Map = 0x10,
-  MethodShorthand = 0x20,
-  ObjectAssign = 0x40,
-  Promise = 0x80,
-  Set = 0x100,
-  SymbolIterator = 0x200,
-  TypedArray = 0x400,
-  BigIntTypedArray = 0x800,
+  ErrorPrototypeStack = 0x10,
+  Map = 0x20,
+  MethodShorthand = 0x40,
+  ObjectAssign = 0x80,
+  Promise = 0x100,
+  Set = 0x200,
+  SymbolIterator = 0x400,
+  TypedArray = 0x800,
+  BigIntTypedArray = 0x1000,
 }
 
-type VersionTable = {
-  [key in Feature]: PlatformVersion;
-}
-
-const VERSION_TABLE: VersionTable = {
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError#browser_compatibility
-  [Feature.AggregateError]: {
-    es: [2021, 0, 0],
-    chrome: [85, 0, 0],
-    edge: [85, 0, 0],
-    firefox: [79, 0, 0],
-    opera: [71, 0, 0],
-    safari: [14, 0, 0],
-    ios: [14, 0, 0],
-    samsung: [14, 0, 0],
-    deno: [1, 2, 0],
-    node: [15, 0, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values#browser_compatibility
-  [Feature.ArrayPrototypeValues]: {
-    es: [6, 0, 0],
-    chrome: [66, 0, 0],
-    edge: [14, 0, 0],
-    firefox: [60, 0, 0],
-    opera: [53, 0, 0],
-    safari: [9, 0, 0],
-    ios: [9, 0, 0],
-    samsung: [9, 0, 0],
-    deno: [1, 0, 0],
-    node: [10, 9, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions#browser_compatibility
-  [Feature.ArrowFunction]: {
-    es: [6, 0, 0],
-    chrome: [45, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [24, 0, 0],
-    opera: [32, 0, 0],
-    safari: [10, 0, 0],
-    ios: [10, 0, 0],
-    samsung: [5, 0, 0],
-    deno: [1, 0, 0],
-    node: [4, 0, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#browser_compatibility
-  [Feature.BigInt]: {
-    es: [2020, 0, 0],
-    chrome: [67, 0, 0],
-    edge: [79, 0, 0],
-    firefox: [68, 0, 0],
-    opera: [54, 0, 0],
-    safari: [14, 0, 0],
-    ios: [14, 0, 0],
-    samsung: [9, 0, 0],
-    deno: [1, 0, 0],
-    node: [10, 4, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#browser_compatibility
-  [Feature.Map]: {
-    es: [6, 0, 0],
-    chrome: [38, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [13, 0, 0],
-    opera: [25, 0, 0],
-    safari: [8, 0, 0],
-    ios: [8, 0, 0],
-    samsung: [3, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 12, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions#browser_compatibility
-  [Feature.MethodShorthand]: {
-    es: [6, 0, 0],
-    chrome: [39, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [34, 0, 0],
-    opera: [26, 0, 0],
-    safari: [9, 0, 0],
-    ios: [9, 0, 0],
-    samsung: [4, 0, 0],
-    deno: [1, 0, 0],
-    node: [4, 0, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#browser_compatibility
-  [Feature.ObjectAssign]: {
-    es: [6, 0, 0],
-    chrome: [45, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [34, 0, 0],
-    opera: [32, 0, 0],
-    safari: [9, 0, 0],
-    ios: [9, 0, 0],
-    samsung: [5, 0, 0],
-    deno: [1, 0, 0],
-    node: [4, 0, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#browser_compatibility
-  [Feature.Promise]: {
-    es: [6, 0, 0],
-    chrome: [32, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [29, 0, 0],
-    opera: [19, 0, 0],
-    safari: [8, 0, 0],
-    ios: [8, 0, 0],
-    samsung: [2, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 12, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#browser_compatibility
-  [Feature.Set]: {
-    es: [6, 0, 0],
-    chrome: [38, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [13, 0, 0],
-    opera: [25, 0, 0],
-    safari: [8, 0, 0],
-    ios: [8, 0, 0],
-    samsung: [3, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 12, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator#browser_compatibility
-  [Feature.SymbolIterator]: {
-    es: [6, 0, 0],
-    chrome: [43, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [36, 0, 0],
-    opera: [30, 0, 0],
-    safari: [10, 0, 0],
-    ios: [10, 0, 0],
-    samsung: [4, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 12, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#browser_compatibility
-  [Feature.TypedArray]: {
-    es: [6, 0, 0],
-    chrome: [7, 0, 0],
-    edge: [12, 0, 0],
-    firefox: [4, 0, 0],
-    opera: [11, 6, 0],
-    safari: [5, 1, 0],
-    ios: [4, 2, 0],
-    samsung: [1, 0, 0],
-    deno: [1, 0, 0],
-    node: [0, 10, 0],
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt64Array#browser_compatibility
-  [Feature.BigIntTypedArray]: {
-    es: [2020, 0, 0],
-    chrome: [67, 0, 0],
-    edge: [79, 0, 0],
-    firefox: [68, 0, 0],
-    opera: [54, 6, 0],
-    safari: [15, 1, 0],
-    ios: [15, 2, 0],
-    samsung: [9, 0, 0],
-    deno: [1, 0, 0],
-    node: [10, 4, 0],
-  },
-};
-
-const TARGET_REGEX = /^(es|chrome|edge|safari|firefox|opera|ios|samsung|deno|node)([0-9]+(\.[0-9]+(\.[0-9]+)?)?)$/i;
-
-export type Target = [platform: Platform, version: Version];
-
-function parseTarget(target: string): Target {
-  const result = TARGET_REGEX.exec(target);
-  assert(result, `Invalid target "${target}"`);
-  const [, platform, version] = result;
-  const [major, minor = '0', patch = '0'] = version.split('.');
-  return [platform as Platform, [Number(major), Number(minor), Number(patch)]];
-}
-
-function getTargetVersions(targets: string | string[]): Target[] {
-  if (Array.isArray(targets)) {
-    const versions: Target[] = [];
-    for (const target of targets) {
-      versions.push(parseTarget(target));
-    }
-    return versions;
-  }
-  return [parseTarget(targets)];
-}
-
-export function parseTargets(targets: string | string[]): number {
-  const parsed = getTargetVersions(targets);
-  let flags = 0;
-
-  for (const key in VERSION_TABLE) {
-    const base = VERSION_TABLE[key as unknown as Feature];
-    let flag = true;
-    for (const [platform, version] of parsed) {
-      const baseVersion = base[platform];
-      flag = flag && !!baseVersion && (compareVersion(baseVersion, version) <= 0);
-    }
-    if (flag) {
-      flags |= Number(key);
-    }
-  }
-
-  return flags;
-}
+export const ALL_ENABLED = 0x1FFF;

package/src/context.ts

@@ -1,23 +1,25 @@
-import { parseTargets } from './compat';
+import { ALL_ENABLED } from './compat';
 import getIdentifier from './get-identifier';
 
 interface IndexAssignment {
-  type: 'index';
-  source: string;
-  value: string;
+  t: 'index';
+  s: string;
+  k: undefined;
+  v: string;
 }
 
 interface MapAssignment {
-  type: 'map';
-  source: string;
-  key: string;
-  value: string;
+  t: 'map';
+  s: string;
+  k: string;
+  v: string;
 }
 
 interface SetAssignment {
-  type: 'set';
-  source: string;
-  value: string;
+  t: 'set';
+  s: string;
+  k: undefined;
+  v: string;
 }
 
 // Array of assignments to be done (used for recursion)
@@ -28,7 +30,7 @@ export type Assignment =
 
 export interface ParserContext {
   refs: Map<unknown, number>;
-  markedRefs: Record<number, number>;
+  markedRefs: Set<number>;
   features: number;
 }
 
@@ -38,7 +40,7 @@ export interface SerializationContext {
   validRefs: number[];
   refSize: number;
   // Refs that are...referenced
-  markedRefs: Record<number, number>;
+  markedRefs: Set<number>;
   // Variables
   vars: string[];
   // Array of assignments to be done (used for recursion)
@@ -48,25 +50,25 @@ export interface SerializationContext {
 }
 
 export interface Options {
-  target: string | string[];
+  disabledFeatures: number;
 }
 
 const DEFAULT_OPTIONS: Options = {
-  target: 'es2023',
+  disabledFeatures: 0,
 };
 
 export function createParserContext(options: Partial<Options> = {}): ParserContext {
   // eslint-disable-next-line prefer-object-spread
   const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    markedRefs: {},
+    markedRefs: new Set(),
     refs: new Map(),
-    features: parseTargets(result.target),
+    features: ALL_ENABLED ^ result.disabledFeatures,
   };
 }
 
 export interface SerializationOptions {
-  markedRefs: Record<number, number>;
+  markedRefs: number[] | Set<number>;
   features: number;
 }
 
@@ -78,7 +80,7 @@ export function createSerializationContext(options: SerializationOptions): Seria
     validRefs: [],
     refSize: 0,
     features: options.features,
-    markedRefs: options.markedRefs,
+    markedRefs: new Set(options.markedRefs),
   };
 }
 
@@ -86,7 +88,7 @@ export function createSerializationContext(options: SerializationOptions): Seria
  * Increments the number of references the referenced value has
  */
 export function markRef(ctx: ParserContext | SerializationContext, current: number) {
-  ctx.markedRefs[current] = 1;
+  ctx.markedRefs.add(current);
 }
 
 /**
@@ -127,13 +129,22 @@ export function getRefParam(ctx: SerializationContext, index: number) {
  */
 export function createRef(
   ctx: ParserContext,
-  index: unknown,
-) {
-  const current = ctx.refs.get(index);
-  if (current != null) {
-    return current;
+  current: unknown,
+  mark: boolean,
+): number {
+  // Check if reference number already exists
+  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;
   }
+  // Create a new reference ID
   const id = ctx.refs.size;
-  ctx.refs.set(index, id);
+  ctx.refs.set(current, id);
   return id;
 }

package/src/index.ts

@@ -1,5 +1,4 @@
 /* eslint-disable no-await-in-loop */
-import { isPrimitive } from './checks';
 import { Feature } from './compat';
 import {
   SerializationContext,
@@ -10,7 +9,6 @@ import {
 } from './context';
 import parseAsync from './tree/async';
 import serializeTree, { resolvePatches } from './tree/serialize';
-import { serializePrimitive } from './tree/shared';
 import parseSync from './tree/sync';
 import { SerovalNode } from './tree/types';
 import {
@@ -29,6 +27,7 @@ export {
   CommonServerValue,
   SemiPrimitiveValue,
   ErrorValue,
+  Feature,
 };
 
 function finalize(
@@ -44,10 +43,9 @@ function finalize(
     if (patches) {
       // Get (or create) a ref from the source
       const index = getRefParam(ctx, rootID);
-      if (result.startsWith(`${index}=`)) {
-        body = `${result},${patches}${index}`;
-      } else {
-        body = `${index}=${result},${patches}${index}`;
+      body = result + ',' + patches + index;
+      if (!result.startsWith(index + '=')) {
+        body = index + '=' + body;
       }
     }
     let params = ctx.vars.length > 1
@@ -56,14 +54,14 @@ function finalize(
     // Source is probably already assigned
     if (ctx.features & Feature.ArrowFunction) {
       params = ctx.vars.length > 1 || ctx.vars.length === 0
-        ? `(${params})`
+        ? '(' + params + ')'
         : params;
-      return `(${params}=>(${body}))()`;
+      return '(' + params + '=>(' + body + '))()';
     }
-    return `(function(${params}){return ${body}})()`;
+    return '(function(' + params + '){return ' + body + '})()';
   }
   if (isObject) {
-    return `(${result})`;
+    return '(' + result + ')';
   }
   return result;
 }
@@ -73,9 +71,6 @@ export function serialize<T extends ServerValue>(
   options?: Partial<Options>,
 ) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
@@ -87,9 +82,6 @@ export async function serializeAsync<T extends AsyncServerValue>(
   options?: Partial<Options>,
 ) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
@@ -101,13 +93,13 @@ export function deserialize<T extends AsyncServerValue>(source: string): T {
   return (0, eval)(source) as T;
 }
 
-type SerovalJSON = [
-  tree: SerovalNode,
-  root: number,
-  isObject: boolean,
-  feature: number,
-  markedRefs: Record<number, number>,
-];
+interface SerovalJSON {
+  t: SerovalNode,
+  r: number,
+  i: boolean,
+  f: number,
+  m: number[],
+}
 
 export function toJSON<T extends ServerValue>(
   source: T,
@@ -115,13 +107,13 @@ export function toJSON<T extends ServerValue>(
 ) {
   const ctx = createParserContext(options);
   const [tree, root, isObject] = parseSync(ctx, source);
-  return JSON.stringify([
-    tree,
-    root,
-    isObject,
-    ctx.features,
-    ctx.markedRefs,
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(ctx.markedRefs),
+  });
 }
 
 export async function toJSONAsync<T extends AsyncServerValue>(
@@ -130,23 +122,23 @@ export async function toJSONAsync<T extends AsyncServerValue>(
 ) {
   const ctx = createParserContext(options);
   const [tree, root, isObject] = await parseAsync(ctx, source);
-  return JSON.stringify([
-    tree,
-    root,
-    isObject,
-    ctx.features,
-    ctx.markedRefs,
-  ]);
+  return JSON.stringify({
+    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;
   const serial = createSerializationContext({
-    features: parsed[3],
-    markedRefs: parsed[4],
+    features: parsed.f,
+    markedRefs: parsed.m,
   });
-  const result = serializeTree(serial, parsed[0]);
-  return finalize(serial, parsed[1], parsed[2], result);
+  const result = serializeTree(serial, parsed.t);
+  return finalize(serial, parsed.r, parsed.i, result);
 }
 
 export function fromJSON<T extends AsyncServerValue>(source: string): T {