seroval 0.4.0-alpha.8 → 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/serialize.d.ts

@@ -1,4 +1,4 @@
 import { SerializationContext } from '../context';
 import { SerovalNode } from './types';
 export declare function resolvePatches(ctx: SerializationContext): string | undefined;
-export default function serializeTree(ctx: SerializationContext, [type, value, id]: SerovalNode): string;
+export default function serializeTree(ctx: SerializationContext, node: SerovalNode): string;

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/tree/types.d.ts

@@ -17,63 +17,112 @@ export declare const enum SerovalNodeType {
     TypedArray = 14,
     BigIntTypedArray = 15
 }
-export type SerovalPrimitiveNode = [
-    type: SerovalNodeType.Primitive,
-    value: PrimitiveValue
-];
-export type SerovalReferenceNode = [type: SerovalNodeType.Reference, value: number];
-export type SerovalSemiPrimitiveNode = [type: SerovalNodeType.BigInt, value: string] | [type: SerovalNodeType.Date, value: string, id: number] | [type: SerovalNodeType.RegExp, value: string, id: number] | [
-    type: SerovalNodeType.TypedArray,
-    value: [constructor: string, array: string, byteOffset: number],
-    id: number
-] | [
-    type: SerovalNodeType.BigIntTypedArray,
-    value: [constructor: string, array: string, byteOffset: number],
-    id: number
-];
-export type SerovalDictionaryNode = [key: string[], value: SerovalNode[], size: number];
-export type SerovalSetNode = [type: SerovalNodeType.Set, value: SerovalNode[], id: number];
-export type SerovalMapNode = [
-    type: SerovalNodeType.Map,
-    value: [key: SerovalNode[], value: SerovalNode[], size: number],
-    id: number
-];
-export type SerovalArrayNode = [type: SerovalNodeType.Array, value: SerovalNode[], id: number];
-export type SerovalObjectNode = [
-    type: SerovalNodeType.Object,
-    value: SerovalDictionaryNode,
-    id: number
-];
-export type SerovalNullConstructorNode = [
-    type: SerovalNodeType.NullConstructor,
-    value: SerovalDictionaryNode,
-    id: number
-];
-export type SerovalPromiseNode = [type: SerovalNodeType.Promise, value: SerovalNode, id: number];
-export type SerovalErrorNode = [
-    type: SerovalNodeType.Error,
-    value: [
-        constructor: string,
-        message: string,
-        options?: SerovalDictionaryNode
-    ],
-    id: number
-];
-export type SerovalAggregateErrorNode = [
-    type: SerovalNodeType.AggregateError,
-    value: [
-        message: string,
-        options: SerovalDictionaryNode | undefined,
-        errors: SerovalNode
-    ],
-    id: number
-];
-export type SerovalIterableNode = [
-    type: SerovalNodeType.Iterable,
-    value: [
-        options: SerovalDictionaryNode | undefined,
-        items: SerovalNode[]
-    ],
-    id: number
-];
+export interface SerovalBaseNode {
+    t: SerovalNodeType;
+    s: PrimitiveValue | undefined;
+    i: number | undefined;
+    l: number | undefined;
+    c: string | undefined;
+    d: SerovalDictionaryNode | undefined;
+    m: string | undefined;
+    n: SerovalNode | undefined;
+    a: SerovalNode[] | undefined;
+}
+export interface SerovalObjectRecordNode {
+    k: string[];
+    v: SerovalNode[];
+    s: number;
+}
+export interface SerovalMapRecordNode {
+    k: SerovalNode[];
+    v: SerovalNode[];
+    s: number;
+}
+export type SerovalDictionaryNode = SerovalObjectRecordNode | SerovalMapRecordNode;
+export interface SerovalPrimitiveNode extends SerovalBaseNode {
+    t: SerovalNodeType.Primitive;
+}
+export interface SerovalReferenceNode extends SerovalBaseNode {
+    t: SerovalNodeType.Reference;
+    i: number;
+}
+export interface SerovalBigIntNode extends SerovalBaseNode {
+    t: SerovalNodeType.BigInt;
+    s: string;
+}
+export interface SerovalDateNode extends SerovalBaseNode {
+    t: SerovalNodeType.Date;
+    i: number;
+    s: string;
+}
+export interface SerovalRegExpNode extends SerovalBaseNode {
+    t: SerovalNodeType.RegExp;
+    i: number;
+    s: string;
+}
+export interface SerovalTypedArrayNode extends SerovalBaseNode {
+    t: SerovalNodeType.TypedArray;
+    i: number;
+    s: string;
+    l: number;
+    c: string;
+}
+export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
+    t: SerovalNodeType.BigIntTypedArray;
+    i: number;
+    s: string;
+    l: number;
+    c: string;
+}
+export type SerovalSemiPrimitiveNode = SerovalBigIntNode | SerovalDateNode | SerovalRegExpNode | SerovalTypedArrayNode | SerovalBigIntTypedArrayNode;
+export interface SerovalSetNode extends SerovalBaseNode {
+    t: SerovalNodeType.Set;
+    a: SerovalNode[];
+    i: number;
+}
+export interface SerovalMapNode extends SerovalBaseNode {
+    t: SerovalNodeType.Map;
+    d: SerovalMapRecordNode;
+    i: number;
+}
+export interface SerovalArrayNode extends SerovalBaseNode {
+    t: SerovalNodeType.Array;
+    a: SerovalNode[];
+    i: number;
+}
+export interface SerovalObjectNode extends SerovalBaseNode {
+    t: SerovalNodeType.Object;
+    d: SerovalObjectRecordNode;
+    i: number;
+}
+export interface SerovalNullConstructorNode extends SerovalBaseNode {
+    t: SerovalNodeType.NullConstructor;
+    d: SerovalObjectRecordNode;
+    i: number;
+}
+export interface SerovalPromiseNode extends SerovalBaseNode {
+    t: SerovalNodeType.Promise;
+    n: SerovalNode;
+    i: number;
+}
+export interface SerovalErrorNode extends SerovalBaseNode {
+    t: SerovalNodeType.Error;
+    c: string;
+    m: string;
+    d: SerovalObjectRecordNode | undefined;
+    i: number;
+}
+export interface SerovalAggregateErrorNode extends SerovalBaseNode {
+    t: SerovalNodeType.AggregateError;
+    m: string;
+    d: SerovalObjectRecordNode | undefined;
+    n: SerovalNode;
+    i: number;
+}
+export interface SerovalIterableNode extends SerovalBaseNode {
+    t: SerovalNodeType.Iterable;
+    d: SerovalObjectRecordNode | undefined;
+    a: SerovalNode[];
+    i: number;
+}
 export type SerovalNode = SerovalPrimitiveNode | SerovalReferenceNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalIterableNode;

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.8",
+  "version": "0.4.0",
   "files": [
     "dist",
     "src"
@@ -64,5 +64,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "e965d1992af3e9a86a8919de6204fe4edb7b21a2"
+  "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;