seroval - npm Package Compare versions

Comparing version 1.5.6 to 1.6.0

dist/index.d.ts

+//#region src/core/compat.d.ts
+/**
+ * References
+ * - https://compat-table.github.io/compat-table/es6/
+ * - MDN
+ */
+declare enum Feature {
+  AggregateError = 1,
+  ArrowFunction = 2,
+  ErrorPrototypeStack = 4,
+  ObjectAssign = 8,
+  BigIntTypedArray = 16,
+  RegExp = 32,
+  Temporal = 64
+}
+//#endregion
+//#region src/core/constants.d.ts
+declare const enum SerovalConstant {
+  Null = 0,
+  Undefined = 1,
+  True = 2,
+  False = 3,
+  NegZero = 4,
+  Inf = 5,
+  NegInf = 6,
+  Nan = 7
+}
+declare 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,
+  Sequence = 35,
+  Temporal = 36
+}
+declare const enum SerovalTemporalType {
+  Instant = 0,
+  Duration = 1,
+  PlainDate = 2,
+  PlainDateTime = 3,
+  PlainMonthDay = 4,
+  PlainTime = 5,
+  PlainYearMonth = 6,
+  ZonedDateTime = 7
+}
+declare const enum SerovalObjectFlags {
+  None = 0,
+  NonExtensible = 1,
+  Sealed = 2,
+  Frozen = 3
+}
+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
+}
+declare const enum ErrorConstructorTag {
+  Error = 0,
+  EvalError = 1,
+  RangeError = 2,
+  ReferenceError = 3,
+  SyntaxError = 4,
+  TypeError = 5,
+  URIError = 6
+}
+//#endregion
+//#region src/core/special-reference.d.ts
+declare const enum SpecialReference {
+  MapSentinel = 0,
+  PromiseConstructor = 1,
+  PromiseSuccess = 2,
+  PromiseFailure = 3,
+  StreamConstructor = 4,
+  ArrayBufferConstructor = 5
+}
+//#endregion
+//#region src/core/types.d.ts
+interface SerovalBaseNode {
+  t: SerovalNodeType;
+  i: number | undefined;
+  s: unknown;
+  c: string | SerovalTemporalType | undefined;
+  m: string | undefined;
+  p: SerovalObjectRecordNode | undefined;
+  e: SerovalMapRecordNode | undefined;
+  a: (SerovalNode | 0)[] | undefined;
+  f: SerovalNode | undefined;
+  b: number | undefined;
+  o: SerovalObjectFlags | undefined;
+  l: number | undefined;
+}
+type SerovalObjectRecordKey = string | SerovalNode;
+interface SerovalObjectRecordNode {
+  k: SerovalObjectRecordKey[];
+  v: SerovalNode[];
+}
+interface SerovalMapRecordNode {
+  k: SerovalNode[];
+  v: SerovalNode[];
+}
+interface SerovalNumberNode extends SerovalBaseNode {
+  t: SerovalNodeType.Number;
+  s: number;
+}
+interface SerovalStringNode extends SerovalBaseNode {
+  t: SerovalNodeType.String;
+  s: string;
+}
+interface SerovalConstantNode extends SerovalBaseNode {
+  t: SerovalNodeType.Constant;
+  s: SerovalConstant;
+}
+type SerovalPrimitiveNode = SerovalNumberNode | SerovalStringNode | SerovalConstantNode;
+interface SerovalIndexedValueNode extends SerovalBaseNode {
+  t: SerovalNodeType.IndexedValue;
+  i: number;
+}
+interface SerovalBigIntNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigInt;
+  s: string;
+}
+interface SerovalDateNode extends SerovalBaseNode {
+  t: SerovalNodeType.Date;
+  i: number;
+  s: string;
+}
+interface SerovalRegExpNode extends SerovalBaseNode {
+  t: SerovalNodeType.RegExp;
+  i: number;
+  c: string;
+  m: string;
+}
+interface SerovalArrayBufferNode extends SerovalBaseNode {
+  t: SerovalNodeType.ArrayBuffer;
+  i: number;
+  s: string;
+  f: SerovalNodeWithID;
+}
+interface SerovalTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.TypedArray;
+  i: number;
+  c: string;
+  f: SerovalNode;
+  b: number;
+  l: number;
+}
+interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigIntTypedArray;
+  i: number;
+  c: string;
+  f: SerovalNode;
+  b: number;
+  l: number;
+}
+interface SerovalTemporalNode extends SerovalBaseNode {
+  t: SerovalNodeType.Temporal;
+  i: number;
+  c: SerovalTemporalType;
+  s: string;
+}
+type SerovalSemiPrimitiveNode = SerovalBigIntNode | SerovalDateNode | SerovalRegExpNode | SerovalTypedArrayNode | SerovalBigIntTypedArrayNode | SerovalTemporalNode;
+interface SerovalSetNode extends SerovalBaseNode {
+  t: SerovalNodeType.Set;
+  i: number;
+  a: SerovalNode[];
+}
+interface SerovalMapNode extends SerovalBaseNode {
+  t: SerovalNodeType.Map;
+  i: number;
+  e: SerovalMapRecordNode;
+  f: SerovalNodeWithID;
+}
+interface SerovalArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.Array;
+  a: (SerovalNode | 0)[];
+  i: number;
+  o: SerovalObjectFlags;
+}
+interface SerovalObjectNode extends SerovalBaseNode {
+  t: SerovalNodeType.Object;
+  p: SerovalObjectRecordNode;
+  i: number;
+  o: SerovalObjectFlags;
+}
+interface SerovalNullConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.NullConstructor;
+  p: SerovalObjectRecordNode;
+  i: number;
+  o: SerovalObjectFlags;
+}
+interface SerovalPromiseNode extends SerovalBaseNode {
+  t: SerovalNodeType.Promise;
+  s: 0 | 1;
+  f: SerovalNode;
+  i: number;
+}
+interface SerovalErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.Error;
+  s: ErrorConstructorTag;
+  m: string;
+  p: SerovalObjectRecordNode | undefined;
+  i: number;
+}
+interface SerovalAggregateErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.AggregateError;
+  i: number;
+  m: string;
+  p: SerovalObjectRecordNode | undefined;
+}
+interface SerovalWKSymbolNode extends SerovalBaseNode {
+  t: SerovalNodeType.WKSymbol;
+  i: number;
+  s: Symbols;
+}
+interface SerovalReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Reference;
+  i: number;
+  s: string;
+}
+interface SerovalDataViewNode extends SerovalBaseNode {
+  t: SerovalNodeType.DataView;
+  i: number;
+  f: SerovalNode;
+  b: number;
+  l: number;
+}
+interface SerovalBoxedNode extends SerovalBaseNode {
+  t: SerovalNodeType.Boxed;
+  i: number;
+  f: SerovalNode;
+}
+interface SerovalPromiseConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseConstructor;
+  i: number;
+  s: number;
+  f: SerovalNodeWithID;
+}
+interface SerovalPromiseResolveNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseSuccess;
+  i: number;
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
+}
+interface SerovalPromiseRejectNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseFailure;
+  i: number;
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
+}
+interface SerovalPluginNode extends SerovalBaseNode {
+  t: SerovalNodeType.Plugin;
+  i: number;
+  s: Record<string, SerovalNode>;
+  c: string;
+}
+/**
+ * Represents special values as placeholders
+ */
+interface SerovalSpecialReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.SpecialReference;
+  i: number;
+  s: SpecialReference;
+}
+interface SerovalIteratorFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.IteratorFactory;
+  i: number;
+  f: SerovalNodeWithID;
+}
+interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
+  t: SerovalNodeType.IteratorFactoryInstance;
+  a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
+}
+interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.AsyncIteratorFactory;
+  i: number;
+  a: [promise: SerovalNodeWithID, symbol: SerovalNodeWithID];
+}
+interface SerovalAsyncIteratorFactoryInstanceNode extends SerovalBaseNode {
+  t: SerovalNodeType.AsyncIteratorFactoryInstance;
+  a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
+}
+interface SerovalStreamConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamConstructor;
+  i: number;
+  a: SerovalNode[];
+  f: SerovalNodeWithID;
+}
+interface SerovalStreamNextNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamNext;
+  i: number;
+  f: SerovalNode;
+}
+interface SerovalStreamThrowNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamThrow;
+  i: number;
+  f: SerovalNode;
+}
+interface SerovalStreamReturnNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamReturn;
+  i: number;
+  f: SerovalNode;
+}
+interface SerovalSequenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Sequence;
+  i: number;
+  s: number;
+  a: SerovalNode[];
+  l: number;
+}
+type SerovalSyncNode = SerovalPrimitiveNode | SerovalIndexedValueNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalWKSymbolNode | SerovalReferenceNode | SerovalArrayBufferNode | SerovalDataViewNode | SerovalBoxedNode | SerovalPluginNode | SerovalSpecialReferenceNode | SerovalIteratorFactoryNode | SerovalIteratorFactoryInstanceNode | SerovalAsyncIteratorFactoryNode | SerovalAsyncIteratorFactoryInstanceNode | SerovalSequenceNode;
+type SerovalAsyncNode = SerovalPromiseNode | SerovalPromiseConstructorNode | SerovalPromiseResolveNode | SerovalPromiseRejectNode | SerovalStreamConstructorNode | SerovalStreamNextNode | SerovalStreamThrowNode | SerovalStreamReturnNode;
+type SerovalNode = SerovalSyncNode | SerovalAsyncNode;
+type SerovalNodeWithID = Extract<SerovalNode, {
+  i: number;
+}>;
+//#endregion
+//#region src/core/context/deserializer.d.ts
+interface BaseDeserializerContextOptions extends PluginAccessOptions {
+  refs?: Map<number, unknown>;
+  features?: number;
+  disabledFeatures?: number;
+  depthLimit?: number;
+}
+interface BaseDeserializerContext extends PluginAccessOptions {
+  readonly mode: SerovalMode;
+  /**
+   * Mapping ids to values
+   */
+  refs: Map<number, unknown> & {
+    types: Map<number, SerovalNodeType>;
+  };
+  features: number;
+  depthLimit: number;
+}
+interface VanillaDeserializerContextOptions extends Omit<BaseDeserializerContextOptions, 'refs'> {
+  markedRefs: number[] | Set<number>;
+}
+interface VanillaDeserializerState {
+  marked: Set<number>;
+}
+interface VanillaDeserializerContext {
+  mode: SerovalMode.Vanilla;
+  base: BaseDeserializerContext;
+  child: DeserializePluginContext | undefined;
+  state: VanillaDeserializerState;
+}
+interface CrossDeserializerContext {
+  mode: SerovalMode.Cross;
+  base: BaseDeserializerContext;
+  child: DeserializePluginContext | undefined;
+}
+type CrossDeserializerContextOptions = BaseDeserializerContextOptions;
+type DeserializerContext = VanillaDeserializerContext | CrossDeserializerContext;
+declare class DeserializePluginContext {
+  private _p;
+  private depth;
+  constructor(_p: DeserializerContext, depth: number);
+  deserialize<T>(node: SerovalNode): T;
+}
+//#endregion
+//#region src/core/context/serializer.d.ts
+declare const enum AssignmentType {
+  Index = 0,
+  Add = 1,
+  Set = 2,
+  Delete = 3,
+  Define = 4
+}
+interface IndexAssignment {
+  t: AssignmentType.Index;
+  s: string;
+  k: undefined;
+  v: string;
+}
+interface SetAssignment {
+  t: AssignmentType.Set;
+  s: string;
+  k: string;
+  v: string;
+}
+interface AddAssignment {
+  t: AssignmentType.Add;
+  s: string;
+  k: undefined;
+  v: string;
+}
+interface DeleteAssignment {
+  t: AssignmentType.Delete;
+  s: string;
+  k: string;
+  v: undefined;
+}
+interface DefineAssignment {
+  t: AssignmentType.Define;
+  s: string;
+  k: string;
+  v: undefined;
+}
+type Assignment = IndexAssignment | AddAssignment | SetAssignment | DeleteAssignment | DefineAssignment;
+interface FlaggedObject {
+  type: SerovalObjectFlags;
+  value: string;
+}
+interface BaseSerializerContextOptions extends PluginAccessOptions {
+  features: number;
+  markedRefs: number[] | Set<number>;
+}
+interface BaseSerializerContext extends PluginAccessOptions {
+  readonly mode: SerovalMode;
+  features: number;
+  stack: number[];
+  /**
+   * Array of object mutations
+   */
+  flags: FlaggedObject[];
+  /**
+   * Array of assignments to be done (used for recursion)
+   */
+  assignments: Assignment[];
+  /**
+   * Refs that are...referenced
+   */
+  marked: Set<number>;
+}
+interface CrossContextOptions {
+  scopeId?: string;
+}
+interface VanillaSerializerState {
+  valid: Map<number, number>;
+  vars: string[];
+}
+interface VanillaSerializerContext {
+  mode: SerovalMode.Vanilla;
+  base: BaseSerializerContext;
+  state: VanillaSerializerState;
+  child: SerializePluginContext | undefined;
+}
+type VanillaSerializerContextOptions = BaseSerializerContextOptions;
+interface CrossSerializerContext {
+  mode: SerovalMode.Cross;
+  base: BaseSerializerContext;
+  state: CrossContextOptions;
+  child: SerializePluginContext | undefined;
+}
+interface CrossSerializerContextOptions extends BaseSerializerContextOptions, CrossContextOptions {}
+type SerializerContext = VanillaSerializerContext | CrossSerializerContext;
+declare class SerializePluginContext {
+  private _p;
+  constructor(_p: SerializerContext);
+  serialize(node: SerovalNode): string;
+}
+//#endregion
+//#region src/core/context/parser.d.ts
+interface BaseParserContextOptions extends PluginAccessOptions {
+  disabledFeatures?: number;
+  refs?: Map<unknown, number>;
+  depthLimit?: number;
+}
+interface BaseParserContext extends PluginAccessOptions {
+  readonly mode: SerovalMode;
+  marked: Set<number>;
+  refs: Map<unknown, number>;
+  features: number;
+  depthLimit: number;
+}
+//#endregion
+//#region src/core/context/sync-parser.d.ts
+type SyncParserContextOptions = BaseParserContextOptions;
+declare const enum ParserMode {
+  Sync = 1,
+  Stream = 2
+}
+interface SyncParserContext {
+  type: ParserMode.Sync;
+  base: BaseParserContext;
+  child: SyncParsePluginContext | undefined;
+}
+declare class SyncParsePluginContext {
+  private _p;
+  private depth;
+  constructor(_p: SyncParserContext, depth: number);
+  parse<T>(current: T): SerovalNode;
+}
+interface StreamParserContextOptions extends SyncParserContextOptions {
+  onParse: (node: SerovalNode, initial: boolean) => void;
+  onError?: (error: unknown) => void;
+  onDone?: () => void;
+}
+interface StreamParserContext {
+  type: ParserMode.Stream;
+  base: BaseParserContext;
+  state: StreamParserState;
+}
+declare class StreamParsePluginContext {
+  private _p;
+  private depth;
+  constructor(_p: StreamParserContext, depth: number);
+  parse<T>(current: T): SerovalNode;
+  parseWithError<T>(current: T): SerovalNode | undefined;
+  isAlive(): boolean;
+  pushPendingState(): void;
+  popPendingState(): void;
+  onParse(node: SerovalNode): void;
+  onError(error: unknown): void;
+  addCleanup(callback: () => void): void;
+}
+interface StreamParserState {
+  alive: boolean;
+  pending: number;
+  initial: boolean;
+  buffer: SerovalNode[];
+  onParse: (node: SerovalNode, initial: boolean) => void;
+  onError?: (error: unknown) => void;
+  onDone?: () => void;
+  cleanups: (() => void)[];
+}
+//#endregion
+//#region src/core/plugin.d.ts
+declare const enum SerovalMode {
+  Vanilla = 1,
+  Cross = 2
+}
+interface PluginData {
+  id: number;
+}
+type PluginInfo = {
+  [key: string]: SerovalNode;
+};
+interface Plugin<Value, Info extends PluginInfo> {
+  /**
+   * A unique string that helps idenfity the plugin
+   */
+  tag: string;
+  /**
+   * List of dependency plugins
+   */
+  extends?: Plugin<any, any>[];
+  /**
+   * Method to test if a value is an expected value of the plugin
+   * @param value
+   */
+  test(value: unknown): boolean;
+  /**
+   * Parsing modes
+   */
+  parse: {
+    sync?: (value: Value, ctx: SyncParsePluginContext, data: PluginData) => Info;
+    async?: (value: Value, ctx: AsyncParsePluginContext, data: PluginData) => Promise<Info>;
+    stream?: (value: Value, ctx: StreamParsePluginContext, data: PluginData) => Info;
+  };
+  /**
+   * Convert the parsed node into a JS string
+   */
+  serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;
+  /**
+   * Convert the parsed node into its runtime equivalent.
+   */
+  deserialize(node: Info, ctx: DeserializePluginContext, data: PluginData): Value;
+}
+declare function createPlugin<Value, Info extends PluginInfo>(plugin: Plugin<Value, Info>): Plugin<Value, Info>;
+interface PluginAccessOptions {
+  plugins?: Plugin<any, any>[];
+}
+declare function resolvePlugins(plugins?: Plugin<any, any>[]): Plugin<any, any>[] | undefined;
+//#endregion
+//#region src/core/context/async-parser.d.ts
+type AsyncParserContextOptions = BaseParserContextOptions;
+interface AsyncParserContext {
+  base: BaseParserContext;
+  child: AsyncParsePluginContext | undefined;
+}
+declare class AsyncParsePluginContext {
+  private _p;
+  private depth;
+  constructor(_p: AsyncParserContext, depth: number);
+  parse<T>(current: T): Promise<SerovalNode>;
+}
+//#endregion
+//#region src/core/cross/index.d.ts
+interface CrossSerializeOptions extends SyncParserContextOptions, CrossContextOptions {}
+declare function crossSerialize<T>(source: T, options?: CrossSerializeOptions): string;
+interface CrossSerializeAsyncOptions extends AsyncParserContextOptions, CrossContextOptions {}
+declare function crossSerializeAsync<T>(source: T, options?: CrossSerializeAsyncOptions): Promise<string>;
+type ToCrossJSONOptions = SyncParserContextOptions;
+declare function toCrossJSON<T>(source: T, options?: ToCrossJSONOptions): SerovalNode;
+type ToCrossJSONAsyncOptions = AsyncParserContextOptions;
+declare function toCrossJSONAsync<T>(source: T, options?: ToCrossJSONAsyncOptions): Promise<SerovalNode>;
+interface CrossSerializeStreamOptions extends Omit<StreamParserContextOptions, 'onParse'>, CrossContextOptions {
+  onSerialize: (data: string, initial: boolean) => void;
+}
+declare function crossSerializeStream<T>(source: T, options: CrossSerializeStreamOptions): () => void;
+type ToCrossJSONStreamOptions = StreamParserContextOptions;
+declare function toCrossJSONStream<T>(source: T, options: ToCrossJSONStreamOptions): () => void;
+type FromCrossJSONOptions = CrossDeserializerContextOptions;
+declare function fromCrossJSON<T>(source: SerovalNode, options: FromCrossJSONOptions): T;
+//#endregion
+//#region src/core/errors.d.ts
+declare class SerovalError extends Error {
+  cause: unknown;
+  constructor(type: string, cause: unknown);
+}
+declare class SerovalParserError extends SerovalError {
+  constructor(cause: unknown);
+}
+declare class SerovalSerializationError extends SerovalError {
+  constructor(cause: unknown);
+}
+declare class SerovalDeserializationError extends SerovalError {
+  constructor(cause: unknown);
+}
+declare class SerovalUnsupportedTypeError extends Error {
+  value: unknown;
+  constructor(value: unknown);
+}
+declare class SerovalUnsupportedNodeError extends Error {
+  constructor(node: SerovalNode);
+}
+declare class SerovalMissingPluginError extends Error {
+  constructor(tag: string);
+}
+declare class SerovalMissingInstanceError extends Error {
+  constructor(tag: string);
+}
+declare class SerovalMissingReferenceError extends Error {
+  value: unknown;
+  constructor(value: unknown);
+}
+declare class SerovalMissingReferenceForIdError extends Error {
+  constructor(id: string);
+}
+declare class SerovalUnknownTypedArrayError extends Error {
+  constructor(name: string);
+}
+declare class SerovalMalformedNodeError extends Error {
+  constructor(node: SerovalNode);
+}
+declare class SerovalConflictedNodeIdError extends Error {
+  constructor(node: SerovalNode);
+}
+declare class SerovalDepthLimitError extends Error {
+  constructor(limit: number);
+}
+//#endregion
+//#region src/core/keys.d.ts
+declare function getCrossReferenceHeader(id?: string): string;
+//#endregion
+//#region src/core/opaque-reference.d.ts
+/**
+ * An opaque reference allows hiding values from the serializer.
+ */
+declare class OpaqueReference<V, R = undefined> {
+  readonly value: V;
+  readonly replacement?: R | undefined;
+  constructor(value: V, replacement?: R | undefined);
+}
+//#endregion
+//#region src/core/reference.d.ts
+declare function createReference<T>(id: string, value: T): T;
+//#endregion
+//#region src/core/Serializer.d.ts
+interface SerializerOptions extends PluginAccessOptions {
+  globalIdentifier: string;
+  scopeId?: string;
+  disabledFeatures?: number;
+  onData: (result: string) => void;
+  onError: (error: unknown) => void;
+  onDone?: () => void;
+}
+declare class Serializer {
+  private options;
+  private alive;
+  private flushed;
+  private done;
+  private pending;
+  private cleanups;
+  private refs;
+  private plugins?;
+  constructor(options: SerializerOptions);
+  keys: Set<string>;
+  write(key: string, value: unknown): void;
+  ids: number;
+  private getNextID;
+  push(value: unknown): string;
+  flush(): void;
+  close(): void;
+}
+//#endregion
+//#region src/core/stream.d.ts
+interface StreamListener<T> {
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+interface Stream<T> {
+  __SEROVAL_STREAM__: true;
+  on(listener: StreamListener<T>): () => void;
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+declare function createStream<T>(): Stream<T>;
+//#endregion
+//#region src/core/tree/index.d.ts
+type SyncParserContextOptions$1 = Omit<BaseParserContextOptions, 'refs'>;
+type AsyncParserContextOptions$1 = Omit<BaseParserContextOptions, 'refs'>;
+declare function serialize<T>(source: T, options?: SyncParserContextOptions$1): string;
+declare function serializeAsync<T>(source: T, options?: AsyncParserContextOptions$1): Promise<string>;
+declare function deserialize<T>(source: string): T;
+interface SerovalJSON {
+  t: SerovalNode;
+  f: number;
+  m: number[];
+}
+interface FromJSONOptions extends PluginAccessOptions {
+  disabledFeatures?: number;
+}
+declare function toJSON<T>(source: T, options?: SyncParserContextOptions$1): SerovalJSON;
+declare function toJSONAsync<T>(source: T, options?: AsyncParserContextOptions$1): Promise<SerovalJSON>;
+declare function compileJSON(source: SerovalJSON, options?: PluginAccessOptions): string;
+declare function fromJSON<T>(source: SerovalJSON, options?: FromJSONOptions): T;
+//#endregion
+export { type AsyncParsePluginContext, AsyncParserContextOptions, type BaseDeserializerContextOptions, type BaseParserContextOptions, type BaseSerializerContextOptions, type CrossContextOptions, type CrossDeserializerContextOptions, CrossSerializeAsyncOptions, CrossSerializeOptions, CrossSerializeStreamOptions, type CrossSerializerContextOptions, type DeserializePluginContext, Feature, FromCrossJSONOptions, FromJSONOptions, OpaqueReference, Plugin, PluginAccessOptions, PluginData, PluginInfo, type SerializePluginContext, Serializer, SerovalConflictedNodeIdError, SerovalDepthLimitError, SerovalDeserializationError, SerovalError, SerovalJSON, SerovalMalformedNodeError, SerovalMissingInstanceError, SerovalMissingPluginError, SerovalMissingReferenceError, SerovalMissingReferenceForIdError, SerovalMode, type SerovalNode, SerovalParserError, SerovalSerializationError, SerovalUnknownTypedArrayError, SerovalUnsupportedNodeError, SerovalUnsupportedTypeError, type Stream, type StreamListener, type StreamParsePluginContext, type StreamParserContextOptions, type SyncParsePluginContext, SyncParserContextOptions, ToCrossJSONAsyncOptions, ToCrossJSONOptions, ToCrossJSONStreamOptions, type VanillaDeserializerContextOptions, type VanillaSerializerContextOptions, compileJSON, createPlugin, createReference, createStream, crossSerialize, crossSerializeAsync, crossSerializeStream, deserialize, fromCrossJSON, fromJSON, getCrossReferenceHeader, resolvePlugins, serialize, serializeAsync, toCrossJSON, toCrossJSONAsync, toCrossJSONStream, toJSON, toJSONAsync };

package.json

 {
   "name": "seroval",
   "type": "module",
-  "version": "1.5.6",
+  "version": "1.6.0",
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
@@ -14,3 +13,6 @@ "engines": {
   "keywords": [
-    "pridepack"
+    "pridepack",
+    "solid-js",
+    "tanstack",
+    "serialization"
   ],
@@ -20,6 +22,8 @@ "devDependencies": {
     "@vitest/ui": "^4.0.6",
-    "pridepack": "2.6.4",
+    "esbuild": "^0.28.1",
+    "temporal-polyfill": "^0.3.2",
     "ts-prune": "^0.10.3",
+    "tsdown": "^0.22.14",
     "tslib": "^2.8.1",
-    "typescript": "^5.9.3",
+    "typescript": "^7.0.2",
     "vitest": "^4.0.6"
@@ -42,14 +46,5 @@ },
   "types": "./dist/types/index.d.ts",
-  "main": "./dist/cjs/production/index.cjs",
-  "module": "./dist/esm/production/index.mjs",
   "exports": {
-    ".": {
-      "development": {
-        "require": "./dist/cjs/development/index.cjs",
-        "import": "./dist/esm/development/index.mjs"
-      },
-      "require": "./dist/cjs/production/index.cjs",
-      "import": "./dist/esm/production/index.mjs",
-      "types": "./dist/types/index.d.ts"
-    }
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
   },
@@ -60,8 +55,4 @@ "typesVersions": {
   "scripts": {
-    "build": "pridepack build",
-    "type-check": "pridepack check",
-    "clean": "pridepack clean",
-    "watch": "pridepack watch",
-    "start": "pridepack start",
-    "dev": "pridepack dev",
+    "build": "tsdown",
+    "watch": "tsdown --watch",
     "test": "vitest",
@@ -68,0 +59,0 @@ "test:ui": "vitest --ui",

dist/cjs/production/index.cjs

-"use strict";var gr=Object.defineProperty;var Nn=Object.getOwnPropertyDescriptor;var bn=Object.getOwnPropertyNames;var vn=Object.prototype.hasOwnProperty;var Cn=(e,r)=>{for(var t in r)gr(e,t,{get:r[t],enumerable:!0})},An=(e,r,t,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let a of bn(r))!vn.call(e,a)&&a!==t&&gr(e,a,{get:()=>r[a],enumerable:!(n=Nn(r,a))||n.enumerable});return e};var En=e=>An(gr({},"__esModule",{value:!0}),e);var us={};Cn(us,{Feature:()=>M,OpaqueReference:()=>U,Serializer:()=>Re,SerovalConflictedNodeIdError:()=>Tr,SerovalDepthLimitError:()=>B,SerovalDeserializationError:()=>pe,SerovalError:()=>te,SerovalMalformedNodeError:()=>O,SerovalMissingInstanceError:()=>F,SerovalMissingPluginError:()=>q,SerovalMissingReferenceError:()=>fe,SerovalMissingReferenceForIdError:()=>Se,SerovalMode:()=>G,SerovalParserError:()=>_,SerovalSerializationError:()=>Xe,SerovalUnknownTypedArrayError:()=>de,SerovalUnsupportedNodeError:()=>w,SerovalUnsupportedTypeError:()=>x,compileJSON:()=>ss,createPlugin:()=>$n,createReference:()=>gt,createStream:()=>W,crossSerialize:()=>Ja,crossSerializeAsync:()=>Za,crossSerializeStream:()=>ot,deserialize:()=>ns,fromCrossJSON:()=>es,fromJSON:()=>is,getCrossReferenceHeader:()=>dt,resolvePlugins:()=>A,serialize:()=>rs,serializeAsync:()=>ts,toCrossJSON:()=>$a,toCrossJSONAsync:()=>Xa,toCrossJSONStream:()=>Qa,toJSON:()=>os,toJSONAsync:()=>as});module.exports=En(us);var M=(i=>(i[i.AggregateError=1]="AggregateError",i[i.ArrowFunction=2]="ArrowFunction",i[i.ErrorPrototypeStack=4]="ErrorPrototypeStack",i[i.ObjectAssign=8]="ObjectAssign",i[i.BigIntTypedArray=16]="BigIntTypedArray",i[i.RegExp=32]="RegExp",i))(M||{});var v=Symbol.asyncIterator,yr=Symbol.hasInstance,R=Symbol.isConcatSpreadable,C=Symbol.iterator,Nr=Symbol.match,br=Symbol.matchAll,vr=Symbol.replace,Cr=Symbol.search,Ar=Symbol.species,Er=Symbol.split,Ir=Symbol.toPrimitive,P=Symbol.toStringTag,Rr=Symbol.unscopables;var st={0:"Symbol.asyncIterator",1:"Symbol.hasInstance",2:"Symbol.isConcatSpreadable",3:"Symbol.iterator",4:"Symbol.match",5:"Symbol.matchAll",6:"Symbol.replace",7:"Symbol.search",8:"Symbol.species",9:"Symbol.split",10:"Symbol.toPrimitive",11:"Symbol.toStringTag",12:"Symbol.unscopables"},Pe={[v]:0,[yr]:1,[R]:2,[C]:3,[Nr]:4,[br]:5,[vr]:6,[Cr]:7,[Ar]:8,[Er]:9,[Ir]:10,[P]:11,[Rr]:12},it={0:v,1:yr,2:R,3:C,4:Nr,5:br,6:vr,7:Cr,8:Ar,9:Er,10:Ir,11:P,12:Rr},ut={2:"!0",3:"!1",1:"void 0",0:"null",4:"-0",5:"1/0",6:"-1/0",7:"0/0"},o=void 0,lt={2:!0,3:!1,1:o,0:null,4:-0,5:Number.POSITIVE_INFINITY,6:Number.NEGATIVE_INFINITY,7:Number.NaN};var xe={0:"Error",1:"EvalError",2:"RangeError",3:"ReferenceError",4:"SyntaxError",5:"TypeError",6:"URIError"},ct={0:Error,1:EvalError,2:RangeError,3:ReferenceError,4:SyntaxError,5:TypeError,6:URIError};function c(e,r,t,n,a,s,i,u,l,g,S,d){return{t:e,i:r,s:t,c:n,m:a,p:s,e:i,a:u,f:l,b:g,o:S,l:d}}function L(e){return c(2,o,e,o,o,o,o,o,o,o,o,o)}var X=L(2),Q=L(3),Te=L(1),Oe=L(0),ft=L(4),St=L(5),mt=L(6),pt=L(7);function In(e){switch(e){case'"':return'\\"';case"\\":return"\\\\";case`
-`:return"\\n";case"\r":return"\\r";case"\b":return"\\b";case"	":return"\\t";case"\f":return"\\f";case"<":return"\\x3C";case"\u2028":return"\\u2028";case"\u2029":return"\\u2029";default:return o}}function y(e){let r="",t=0,n;for(let a=0,s=e.length;a<s;a++)n=In(e[a]),n&&(r+=e.slice(t,a)+n,t=a+1);return t===0?r=e:r+=e.slice(t),r}function Rn(e){switch(e){case"\\\\":return"\\";case'\\"':return'"';case"\\n":return`
-`;case"\\r":return"\r";case"\\b":return"\b";case"\\t":return"	";case"\\f":return"\f";case"\\x3C":return"<";case"\\u2028":return"\u2028";case"\\u2029":return"\u2029";default:return e}}function z(e){return e.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,Rn)}var j="__SEROVAL_REFS__",ce="$R",we=`self.${ce}`;function dt(e){return e==null?`${we}=${we}||[]`:`(${we}=${we}||{})["${y(e)}"]=[]`}var Pr=new Map,Y=new Map;function gt(e,r){return Pr.set(r,e),Y.set(e,r),r}function xr(e){return Pr.has(e)}function Pn(e){return Y.has(e)}function yt(e){if(xr(e))return Pr.get(e);throw new fe(e)}function Nt(e){if(Pn(e))return Y.get(e);throw new Se(e)}typeof globalThis!="undefined"?Object.defineProperty(globalThis,j,{value:Y,configurable:!0,writable:!1,enumerable:!1}):typeof window!="undefined"?Object.defineProperty(window,j,{value:Y,configurable:!0,writable:!1,enumerable:!1}):typeof self!="undefined"?Object.defineProperty(self,j,{value:Y,configurable:!0,writable:!1,enumerable:!1}):typeof global!="undefined"&&Object.defineProperty(global,j,{value:Y,configurable:!0,writable:!1,enumerable:!1});function he(e){return e instanceof EvalError?1:e instanceof RangeError?2:e instanceof ReferenceError?3:e instanceof SyntaxError?4:e instanceof TypeError?5:e instanceof URIError?6:0}function xn(e){let r=xe[he(e)];return e.name!==r?{name:e.name}:e.constructor.name!==r?{name:e.constructor.name}:{}}function ee(e,r){let t=xn(e),n=Object.getOwnPropertyNames(e);for(let a=0,s=n.length,i;a<s;a++)i=n[a],i!=="name"&&i!=="message"&&(i==="stack"?r&4&&(t=t||{},t[i]=e[i]):(t=t||{},t[i]=e[i]));return t}function ze(e){return Object.isFrozen(e)?3:Object.isSealed(e)?2:Object.isExtensible(e)?0:1}function _e(e){switch(e){case Number.POSITIVE_INFINITY:return St;case Number.NEGATIVE_INFINITY:return mt}return e!==e?pt:Object.is(e,-0)?ft:c(0,o,e,o,o,o,o,o,o,o,o,o)}function re(e){return c(1,o,y(e),o,o,o,o,o,o,o,o,o)}function ke(e){return c(3,o,""+e,o,o,o,o,o,o,o,o,o)}function vt(e){return c(4,e,o,o,o,o,o,o,o,o,o,o)}function De(e,r){let t=r.valueOf();return c(5,e,t!==t?"":r.toISOString(),o,o,o,o,o,o,o,o,o)}function Fe(e,r){return c(6,e,o,y(r.source),r.flags,o,o,o,o,o,o,o)}function Ct(e,r){return c(17,e,Pe[r],o,o,o,o,o,o,o,o,o)}function At(e,r){return c(18,e,y(yt(r)),o,o,o,o,o,o,o,o,o)}function me(e,r,t){return c(25,e,t,y(r),o,o,o,o,o,o,o,o)}function Be(e,r,t){return c(9,e,o,o,o,o,o,t,o,o,ze(r),o)}function Ve(e,r){return c(21,e,o,o,o,o,o,o,r,o,o,o)}function Me(e,r,t){return c(15,e,o,r.constructor.name,o,o,o,o,t,r.byteOffset,o,r.length)}function Le(e,r,t){return c(16,e,o,r.constructor.name,o,o,o,o,t,r.byteOffset,o,r.length)}function Ue(e,r,t){return c(20,e,o,o,o,o,o,o,t,r.byteOffset,o,r.byteLength)}function je(e,r,t){return c(13,e,he(r),o,y(r.message),t,o,o,o,o,o,o)}function Ye(e,r,t){return c(14,e,he(r),o,y(r.message),t,o,o,o,o,o,o)}function qe(e,r){return c(7,e,o,o,o,o,o,r,o,o,o,o)}function We(e,r){return c(28,o,o,o,o,o,o,[e,r],o,o,o,o)}function Ke(e,r){return c(30,o,o,o,o,o,o,[e,r],o,o,o,o)}function Ge(e,r,t){return c(31,e,o,o,o,o,o,t,r,o,o,o)}function He(e,r){return c(32,e,o,o,o,o,o,o,r,o,o,o)}function Je(e,r){return c(33,e,o,o,o,o,o,o,r,o,o,o)}function Ze(e,r){return c(34,e,o,o,o,o,o,o,r,o,o,o)}function $e(e,r,t,n){return c(35,e,t,o,o,o,o,r,o,o,o,n)}var{toString:js}=Object.prototype;var Tn={parsing:1,serialization:2,deserialization:3};function On(e){return`Seroval Error (step: ${Tn[e]})`}var wn=(e,r)=>On(e),te=class extends Error{constructor(t,n){super(wn(t,n));this.cause=n}},_=class extends te{constructor(r){super("parsing",r)}},Xe=class extends te{constructor(r){super("serialization",r)}},pe=class extends te{constructor(r){super("deserialization",r)}};function k(e){return`Seroval Error (specific: ${e})`}var x=class extends Error{constructor(t){super(k(1));this.value=t}},w=class extends Error{constructor(r){super(k(2))}},q=class extends Error{constructor(r){super(k(3))}},F=class extends Error{constructor(r){super(k(4))}},fe=class extends Error{constructor(t){super(k(5));this.value=t}},Se=class extends Error{constructor(r){super(k(6))}},de=class extends Error{constructor(r){super(k(7))}},O=class extends Error{constructor(r){super(k(8))}},Tr=class extends Error{constructor(r){super(k(9))}},B=class extends Error{constructor(r){super(k(9))}};var U=class{constructor(r,t){this.value=r;this.replacement=t}};var ne=()=>{let e={p:0,s:0,f:0};return e.p=new Promise((r,t)=>{e.s=r,e.f=t}),e},hn=(e,r)=>{e.s(r),e.p.s=1,e.p.v=r},zn=(e,r)=>{e.f(r),e.p.s=2,e.p.v=r},Et=ne.toString(),It=hn.toString(),Rt=zn.toString(),Or=()=>{let e=[],r=[],t=!0,n=!1,a=0,s=(l,g,S)=>{for(S=0;S<a;S++)r[S]&&r[S][g](l)},i=(l,g,S,d)=>{for(g=0,S=e.length;g<S;g++)d=e[g],!t&&g===S-1?l[n?"return":"throw"](d):l.next(d)},u=(l,g)=>(t&&(g=a++,r[g]=l),i(l),()=>{t&&(r[g]=r[a],r[a--]=void 0)});return{__SEROVAL_STREAM__:!0,on:l=>u(l),next:l=>{t&&(e.push(l),s(l,"next"))},throw:l=>{t&&(e.push(l),s(l,"throw"),t=!1,n=!1,r.length=0)},return:l=>{t&&(e.push(l),s(l,"return"),t=!1,n=!0,r.length=0)}}},Pt=Or.toString(),wr=e=>r=>()=>{let t=0,n={[e]:()=>n,next:()=>{if(t>r.d)return{done:!0,value:void 0};let a=t++,s=r.v[a];if(a===r.t)throw s;return{done:a===r.d,value:s}}};return n},xt=wr.toString(),hr=(e,r)=>t=>()=>{let n=0,a=-1,s=!1,i=[],u=[],l=(S=0,d=u.length)=>{for(;S<d;S++)u[S].s({done:!0,value:void 0})};t.on({next:S=>{let d=u.shift();d&&d.s({done:!1,value:S}),i.push(S)},throw:S=>{let d=u.shift();d&&d.f(S),l(),a=i.length,s=!0,i.push(S)},return:S=>{let d=u.shift();d&&d.s({done:!0,value:S}),l(),a=i.length,i.push(S)}});let g={[e]:()=>g,next:()=>{if(a===-1){let Z=n++;if(Z>=i.length){let at=r();return u.push(at),at.p}return{done:!1,value:i[Z]}}if(n>a)return{done:!0,value:void 0};let S=n++,d=i[S];if(S!==a)return{done:!1,value:d};if(s)throw d;return{done:!0,value:d}}};return g},Tt=hr.toString(),zr=e=>{let r=atob(e),t=r.length,n=new Uint8Array(t);for(let a=0;a<t;a++)n[a]=r.charCodeAt(a);return n.buffer},Ot=zr.toString();function Qe(e){return"__SEROVAL_SEQUENCE__"in e}function _r(e,r,t){return{__SEROVAL_SEQUENCE__:!0,v:e,t:r,d:t}}function er(e){let r=[],t=-1,n=-1,a=e[C]();for(;;)try{let s=a.next();if(r.push(s.value),s.done){n=r.length-1;break}}catch(s){t=r.length,r.push(s)}return _r(r,t,n)}var _n=wr(C);function wt(e){return _n(e)}var ht={},zt={};var _t={0:{},1:{},2:{},3:{},4:{},5:{}},kt={0:"[]",1:Et,2:It,3:Rt,4:Pt,5:Ot};function rr(e){return"__SEROVAL_STREAM__"in e}function W(){return Or()}function tr(e){let r=W(),t=e[v]();async function n(){try{let a=await t.next();a.done?r.return(a.value):(r.next(a.value),await n())}catch(a){r.throw(a)}}return n().catch(()=>{}),r}var kn=hr(v,ne);function Dt(e){return kn(e)}async function kr(e){try{return[1,await e]}catch(r){return[0,r]}}function ye(e,r){return{plugins:r.plugins,mode:e,marked:new Set,features:63^(r.disabledFeatures||0),refs:r.refs||new Map,depthLimit:r.depthLimit||1e3}}function Ne(e,r){e.marked.add(r)}function Dr(e,r){let t=e.refs.size;return e.refs.set(r,t),t}function nr(e,r){let t=e.refs.get(r);return t!=null?(Ne(e,t),{type:1,value:vt(t)}):{type:0,value:Dr(e,r)}}function K(e,r){let t=nr(e,r);return t.type===1?t:xr(r)?{type:2,value:At(t.value,r)}:t}function I(e,r){let t=K(e,r);if(t.type!==0)return t.value;if(r in Pe)return Ct(t.value,r);throw new x(r)}function D(e,r){let t=nr(e,_t[r]);return t.type===1?t.value:c(26,t.value,r,o,o,o,o,o,o,o,o,o)}function or(e){let r=nr(e,ht);return r.type===1?r.value:c(27,r.value,o,o,o,o,o,o,I(e,C),o,o,o)}function ar(e){let r=nr(e,zt);return r.type===1?r.value:c(29,r.value,o,o,o,o,o,[D(e,1),I(e,v)],o,o,o,o)}function sr(e,r,t,n){return c(t?11:10,e,o,o,o,n,o,o,o,o,ze(r),o)}function ir(e,r,t,n){return c(8,r,o,o,o,o,{k:t,v:n},o,D(e,0),o,o,o)}function Bt(e,r,t){return c(22,r,t,o,o,o,o,o,D(e,1),o,o,o)}function ur(e,r,t){let n=new Uint8Array(t),a="";for(let s=0,i=n.length;s<i;s++)a+=String.fromCharCode(n[s]);return c(19,r,y(btoa(a)),o,o,o,o,o,D(e,5),o,o,o)}function oe(e,r){return{base:ye(e,r),child:void 0}}var Br=class{constructor(r,t){this._p=r;this.depth=t}parse(r){return N(this._p,this.depth,r)}};async function Fn(e,r,t){let n=[];for(let a=0,s=t.length;a<s;a++)a in t?n[a]=await N(e,r,t[a]):n[a]=0;return n}async function Bn(e,r,t,n){return Be(t,n,await Fn(e,r,n))}async function Vr(e,r,t){let n=Object.entries(t),a=[],s=[];for(let i=0,u=n.length;i<u;i++)a.push(y(n[i][0])),s.push(await N(e,r,n[i][1]));return C in t&&(a.push(I(e.base,C)),s.push(We(or(e.base),await N(e,r,er(t))))),v in t&&(a.push(I(e.base,v)),s.push(Ke(ar(e.base),await N(e,r,tr(t))))),P in t&&(a.push(I(e.base,P)),s.push(re(t[P]))),R in t&&(a.push(I(e.base,R)),s.push(t[R]?X:Q)),{k:a,v:s}}async function Fr(e,r,t,n,a){return sr(t,n,a,await Vr(e,r,n))}async function Vn(e,r,t,n){return Ve(t,await N(e,r,n.valueOf()))}async function Mn(e,r,t,n){return Me(t,n,await N(e,r,n.buffer))}async function Ln(e,r,t,n){return Le(t,n,await N(e,r,n.buffer))}async function Un(e,r,t,n){return Ue(t,n,await N(e,r,n.buffer))}async function Vt(e,r,t,n){let a=ee(n,e.base.features);return je(t,n,a?await Vr(e,r,a):o)}async function jn(e,r,t,n){let a=ee(n,e.base.features);return Ye(t,n,a?await Vr(e,r,a):o)}async function Yn(e,r,t,n){let a=[],s=[];for(let[i,u]of n.entries())a.push(await N(e,r,i)),s.push(await N(e,r,u));return ir(e.base,t,a,s)}async function qn(e,r,t,n){let a=[];for(let s of n.keys())a.push(await N(e,r,s));return qe(t,a)}async function Mt(e,r,t,n){let a=e.base.plugins;if(a)for(let s=0,i=a.length;s<i;s++){let u=a[s];if(u.parse.async&&u.test(n))return me(t,u.tag,await u.parse.async(n,new Br(e,r),{id:t}))}return o}async function Wn(e,r,t,n){let[a,s]=await kr(n);return c(12,t,a,o,o,o,o,o,await N(e,r,s),o,o,o)}function Kn(e,r,t,n,a){let s=[],i=t.on({next:u=>{Ne(this.base,r),N(this,e,u).then(l=>{s.push(He(r,l))},l=>{a(l),i()})},throw:u=>{Ne(this.base,r),N(this,e,u).then(l=>{s.push(Je(r,l)),n(s),i()},l=>{a(l),i()})},return:u=>{Ne(this.base,r),N(this,e,u).then(l=>{s.push(Ze(r,l)),n(s),i()},l=>{a(l),i()})}})}async function Gn(e,r,t,n){return Ge(t,D(e.base,4),await new Promise(Kn.bind(e,r,t,n)))}async function Hn(e,r,t,n){let a=[];for(let s=0,i=n.v.length;s<i;s++)a[s]=await N(e,r,n.v[s]);return $e(t,a,n.t,n.d)}async function Jn(e,r,t,n){if(Array.isArray(n))return Bn(e,r,t,n);if(rr(n))return Gn(e,r,t,n);if(Qe(n))return Hn(e,r,t,n);let a=n.constructor;if(a===U)return N(e,r,n.replacement);let s=await Mt(e,r,t,n);if(s)return s;switch(a){case Object:return Fr(e,r,t,n,!1);case o:return Fr(e,r,t,n,!0);case Date:return De(t,n);case Error:case EvalError:case RangeError:case ReferenceError:case SyntaxError:case TypeError:case URIError:return Vt(e,r,t,n);case Number:case Boolean:case String:case BigInt:return Vn(e,r,t,n);case ArrayBuffer:return ur(e.base,t,n);case Int8Array:case Int16Array:case Int32Array:case Uint8Array:case Uint16Array:case Uint32Array:case Uint8ClampedArray:case Float32Array:case Float64Array:return Mn(e,r,t,n);case DataView:return Un(e,r,t,n);case Map:return Yn(e,r,t,n);case Set:return qn(e,r,t,n);default:break}if(a===Promise||n instanceof Promise)return Wn(e,r,t,n);let i=e.base.features;if(i&32&&a===RegExp)return Fe(t,n);if(i&16)switch(a){case BigInt64Array:case BigUint64Array:return Ln(e,r,t,n);default:break}if(i&1&&typeof AggregateError!="undefined"&&(a===AggregateError||n instanceof AggregateError))return jn(e,r,t,n);if(n instanceof Error)return Vt(e,r,t,n);if(C in n||v in n)return Fr(e,r,t,n,!!a);throw new x(n)}async function Zn(e,r,t){let n=K(e.base,t);if(n.type!==0)return n.value;let a=await Mt(e,r,n.value,t);if(a)return a;throw new x(t)}async function N(e,r,t){if(r>=e.base.depthLimit)throw new B(e.base.depthLimit);switch(typeof t){case"boolean":return t?X:Q;case"undefined":return Te;case"string":return re(t);case"number":return _e(t);case"bigint":return ke(t);case"object":{if(t){let n=K(e.base,t);return n.type===0?await Jn(e,r+1,n.value,t):n.value}return Oe}case"symbol":return I(e.base,t);case"function":return Zn(e,r,t);default:throw new x(t)}}async function ae(e,r){try{return await N(e,0,r)}catch(t){throw t instanceof _?t:new _(t)}}var G=(t=>(t[t.Vanilla=1]="Vanilla",t[t.Cross=2]="Cross",t))(G||{});function $n(e){return e}function Lt(e,r){for(let t=0,n=r.length;t<n;t++){let a=r[t];e.has(a)||(e.add(a),a.extends&&Lt(e,a.extends))}}function A(e){if(e){let r=new Set;return Lt(r,e),[...r]}}function Ut(e){switch(e){case"Int8Array":return Int8Array;case"Int16Array":return Int16Array;case"Int32Array":return Int32Array;case"Uint8Array":return Uint8Array;case"Uint16Array":return Uint16Array;case"Uint32Array":return Uint32Array;case"Uint8ClampedArray":return Uint8ClampedArray;case"Float32Array":return Float32Array;case"Float64Array":return Float64Array;case"BigInt64Array":return BigInt64Array;case"BigUint64Array":return BigUint64Array;default:throw new de(e)}}function be(e){switch(e){case"constructor":case"__proto__":case"prototype":case"__defineGetter__":case"__defineSetter__":case"__lookupGetter__":case"__lookupSetter__":return!1;default:return!0}}function jt(e){switch(e){case v:case R:case P:case C:return!0;default:return!1}}var Xn=1e6,Qn=1e4,eo=2e4;function qt(e,r){switch(r){case 3:return Object.freeze(e);case 1:return Object.preventExtensions(e);case 2:return Object.seal(e);default:return e}}var ro=1e3;function Wt(e,r){var n;let t=r.refs||new Map;return"types"in t||Object.assign(t,{types:new Map}),{mode:e,plugins:r.plugins,refs:t,features:(n=r.features)!=null?n:63^(r.disabledFeatures||0),depthLimit:r.depthLimit||ro}}function Kt(e){return{mode:1,base:Wt(1,e),child:o,state:{marked:new Set(e.markedRefs)}}}function Gt(e){return{mode:2,base:Wt(2,e),child:o}}var Mr=class{constructor(r,t){this._p=r;this.depth=t}deserialize(r){return p(this._p,this.depth,r)}};function Ht(e,r){if(r<0||!Number.isFinite(r)||!Number.isInteger(r))throw new O({t:4,i:r});if(e.refs.has(r))throw new Error("Conflicted ref id: "+r)}function to(e,r,t){return Ht(e.base,r),e.state.marked.has(r)&&e.base.refs.set(r,t),t}function no(e,r,t){return Ht(e.base,r),e.base.refs.set(r,t),t}function b(e,r,t){return e.mode===1?to(e,r,t):no(e,r,t)}function Lr(e,r,t){if(Object.hasOwn(r,t))return r[t];throw new O(e)}function oo(e,r){return b(e,r.i,Nt(z(r.s)))}function ao(e,r,t){let n=t.a,a=n.length,s=b(e,t.i,new Array(a));for(let i=0,u;i<a;i++)u=n[i],u&&(s[i]=p(e,r,u));return qt(s,t.o),s}function Yt(e,r,t){be(r)?e[r]=t:Object.defineProperty(e,r,{value:t,configurable:!0,enumerable:!0,writable:!0})}function so(e,r,t,n,a){if(typeof n=="string")Yt(t,z(n),p(e,r,a));else{let s=p(e,r,n);switch(typeof s){case"string":Yt(t,s,p(e,r,a));break;case"symbol":jt(s)&&(t[s]=p(e,r,a));break;default:throw new O(n)}}}function Jt(e,r,t){e.base.refs.types.set(r,t)}function ve(e,r,t,n){if(e.base.refs.types.get(t)!==n)throw new O(r)}function Zt(e,r,t,n){let a=t.k;if(a.length>0)for(let i=0,u=t.v,l=a.length;i<l;i++)so(e,r,n,a[i],u[i]);return n}function io(e,r,t){let n=b(e,t.i,t.t===10?{}:Object.create(null));return Zt(e,r,t.p,n),qt(n,t.o),n}function uo(e,r){return b(e,r.i,new Date(r.s))}function lo(e,r){if(e.base.features&32){let t=z(r.c);if(t.length>eo)throw new O(r);return b(e,r.i,new RegExp(t,r.m))}throw new w(r)}function co(e,r,t){let n=b(e,t.i,new Set);for(let a=0,s=t.a,i=s.length;a<i;a++)n.add(p(e,r,s[a]));return n}function fo(e,r,t){let n=b(e,t.i,new Map);for(let a=0,s=t.e.k,i=t.e.v,u=s.length;a<u;a++)n.set(p(e,r,s[a]),p(e,r,i[a]));return n}function So(e,r){if(r.s.length>Xn)throw new O(r);return b(e,r.i,zr(z(r.s)))}function mo(e,r,t){var u;let n=Ut(t.c),a=p(e,r,t.f),s=(u=t.b)!=null?u:0;if(s<0||s>a.byteLength)throw new O(t);return b(e,t.i,new n(a,s,t.l))}function po(e,r,t){var i;let n=p(e,r,t.f),a=(i=t.b)!=null?i:0;if(a<0||a>n.byteLength)throw new O(t);return b(e,t.i,new DataView(n,a,t.l))}function $t(e,r,t,n){if(t.p){let a=Zt(e,r,t.p,{});Object.defineProperties(n,Object.getOwnPropertyDescriptors(a))}return n}function go(e,r,t){let n=b(e,t.i,new AggregateError([],z(t.m)));return $t(e,r,t,n)}function yo(e,r,t){let n=Lr(t,ct,t.s),a=b(e,t.i,new n(z(t.m)));return $t(e,r,t,a)}function No(e,r,t){let n=ne(),a=b(e,t.i,n.p),s=p(e,r,t.f);return t.s?n.s(s):n.f(s),a}function bo(e,r,t){return b(e,t.i,Object(p(e,r,t.f)))}function vo(e,r,t){let n=e.base.plugins;if(n){let a=z(t.c);for(let s=0,i=n.length;s<i;s++){let u=n[s];if(u.tag===a)return b(e,t.i,u.deserialize(t.s,new Mr(e,r),{id:t.i}))}}throw new q(t.c)}function Co(e,r){let t=b(e,r.i,b(e,r.s,ne()).p);return Jt(e,r.s,22),t}function Ao(e,r,t){let n=e.base.refs.get(t.i);if(n)return ve(e,t,t.i,22),n.s(p(e,r,t.a[1])),o;throw new F("Promise")}function Eo(e,r,t){let n=e.base.refs.get(t.i);if(n)return ve(e,t,t.i,22),n.f(p(e,r,t.a[1])),o;throw new F("Promise")}function Io(e,r,t){p(e,r,t.a[0]);let n=p(e,r,t.a[1]);return wt(n)}function Ro(e,r,t){p(e,r,t.a[0]);let n=p(e,r,t.a[1]);return Dt(n)}function Po(e,r,t){let n=b(e,t.i,W());Jt(e,t.i,31);let a=t.a,s=a.length;if(s)for(let i=0;i<s;i++)p(e,r,a[i]);return n}function xo(e,r,t){let n=e.base.refs.get(t.i);if(n)return ve(e,t,t.i,31),n.next(p(e,r,t.f)),o;throw new F("Stream")}function To(e,r,t){let n=e.base.refs.get(t.i);if(n)return ve(e,t,t.i,31),n.throw(p(e,r,t.f)),o;throw new F("Stream")}function Oo(e,r,t){let n=e.base.refs.get(t.i);if(n)return ve(e,t,t.i,31),n.return(p(e,r,t.f)),o;throw new F("Stream")}function wo(e,r,t){return p(e,r,t.f),o}function ho(e,r,t){return p(e,r,t.a[1]),o}function zo(e,r,t){let n=b(e,t.i,_r([],t.s,t.l));for(let a=0,s=t.a.length;a<s;a++)n.v[a]=p(e,r,t.a[a]);return n}function p(e,r,t){if(r>e.base.depthLimit)throw new B(e.base.depthLimit);switch(r+=1,t.t){case 2:return Lr(t,lt,t.s);case 0:return Number(t.s);case 1:return z(String(t.s));case 3:if(String(t.s).length>Qn)throw new O(t);return BigInt(t.s);case 4:return e.base.refs.get(t.i);case 18:return oo(e,t);case 9:return ao(e,r,t);case 10:case 11:return io(e,r,t);case 5:return uo(e,t);case 6:return lo(e,t);case 7:return co(e,r,t);case 8:return fo(e,r,t);case 19:return So(e,t);case 16:case 15:return mo(e,r,t);case 20:return po(e,r,t);case 14:return go(e,r,t);case 13:return yo(e,r,t);case 12:return No(e,r,t);case 17:return Lr(t,it,t.s);case 21:return bo(e,r,t);case 25:return vo(e,r,t);case 22:return Co(e,t);case 23:return Ao(e,r,t);case 24:return Eo(e,r,t);case 28:return Io(e,r,t);case 30:return Ro(e,r,t);case 31:return Po(e,r,t);case 32:return xo(e,r,t);case 33:return To(e,r,t);case 34:return Oo(e,r,t);case 27:return wo(e,r,t);case 29:return ho(e,r,t);case 35:return zo(e,r,t);default:throw new w(t)}}function lr(e,r){try{return p(e,0,r)}catch(t){throw new pe(t)}}var _o=()=>T,ko=_o.toString(),Xt=/=>/.test(ko);function cr(e,r){return Xt?(e.length===1?e[0]:"("+e.join(",")+")")+"=>"+(r.startsWith("{")?"("+r+")":r):"function("+e.join(",")+"){return "+r+"}"}function Qt(e,r){return Xt?(e.length===1?e[0]:"("+e.join(",")+")")+"=>{"+r+"}":"function("+e.join(",")+"){"+r+"}"}var tn="hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_",en=tn.length,nn="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_",rn=nn.length;function Ur(e){let r=e%en,t=tn[r];for(e=(e-r)/en;e>0;)r=e%rn,t+=nn[r],e=(e-r)/rn;return t}var Do=/^[$A-Z_][0-9A-Z_$]*$/i;function jr(e){let r=e[0];return(r==="$"||r==="_"||r>="A"&&r<="Z"||r>="a"&&r<="z")&&Do.test(e)}function Ae(e){switch(e.t){case 0:return e.s+"="+e.v;case 2:return e.s+".set("+e.k+","+e.v+")";case 1:return e.s+".add("+e.v+")";case 3:return e.s+".delete("+e.k+")";case 4:return"Object.defineProperty("+e.s+',"__proto__",{value:'+e.k+",configurable:!0,enumerable:!0,writable:!0})"}}function Fo(e){let r=[],t=e[0];for(let n=1,a=e.length,s,i=t;n<a;n++)s=e[n],s.t===0&&s.v===i.v?t={t:0,s:s.s,k:o,v:Ae(t)}:s.t===2&&s.s===i.s?t={t:2,s:Ae(t),k:s.k,v:s.v}:s.t===1&&s.s===i.s?t={t:1,s:Ae(t),k:o,v:s.v}:s.t===3&&s.s===i.s?t={t:3,s:Ae(t),k:s.k,v:o}:(r.push(t),t=s),i=s;return r.push(t),r}function fn(e){if(e.length){let r="",t=Fo(e);for(let n=0,a=t.length;n<a;n++)r+=Ae(t[n])+",";return r}return o}var Bo="Object.create(null)",Vo="new Set",Mo="new Map",Lo="Promise.resolve",Uo="Promise.reject",jo={3:"Object.freeze",2:"Object.seal",1:"Object.preventExtensions",0:o};function Sn(e,r){return{mode:e,plugins:r.plugins,features:r.features,marked:new Set(r.markedRefs),stack:[],flags:[],assignments:[]}}function Yo(){return{valid:new Map,vars:[]}}function fr(e){return{mode:1,base:Sn(1,e),state:Yo(),child:o}}function Sr(e){return{mode:2,base:Sn(2,e),state:e,child:o}}var Yr=class{constructor(r){this._p=r}serialize(r){return f(this._p,r)}};function qo(e,r){let t=e.valid.get(r);t==null&&(t=e.valid.size,e.valid.set(r,t));let n=e.vars[t];return n==null&&(n=Ur(t),e.vars[t]=n),n}function Wo(e){return ce+"["+e+"]"}function m(e,r){return e.mode===1?qo(e.state,r):Wo(r)}function h(e,r){e.marked.add(r)}function qr(e,r){return e.marked.has(r)}function Kr(e,r,t){r!==0&&(h(e.base,t),e.base.flags.push({type:r,value:m(e,t)}))}function Ko(e){let r="";for(let t=0,n=e.flags,a=n.length;t<a;t++){let s=n[t];r+=jo[s.type]+"("+s.value+"),"}return r}function mn(e){let r=fn(e.assignments),t=Ko(e);return r?t?r+t:r:t}function Gr(e,r,t){e.assignments.push({t:0,s:r,k:o,v:t})}function Go(e,r,t){e.base.assignments.push({t:1,s:m(e,r),k:o,v:t})}function Ce(e,r,t,n){e.base.assignments.push({t:2,s:m(e,r),k:t,v:n})}function on(e,r,t){e.base.assignments.push({t:3,s:m(e,r),k:t,v:o})}function Ee(e,r,t,n){Gr(e.base,m(e,r)+"["+t+"]",n)}function Wr(e,r,t,n){if(!be(t)){e.base.assignments.push({t:4,s:m(e,r),k:n,v:o});return}Gr(e.base,m(e,r)+"."+t,n)}function Ho(e,r,t,n){Gr(e.base,m(e,r)+".v["+t+"]",n)}function V(e,r){return r.t===4&&e.stack.includes(r.i)}function se(e,r,t){return e.mode===1&&!qr(e.base,r)?t:m(e,r)+"="+t}function Jo(e){return j+'.get("'+e.s+'")'}function an(e,r,t,n){return t?V(e.base,t)?(h(e.base,r),Ee(e,r,n,m(e,t.i)),""):f(e,t):""}function Zo(e,r){let t=r.i,n=r.a,a=n.length;if(a>0){e.base.stack.push(t);let s=an(e,t,n[0],0),i=s==="";for(let u=1,l;u<a;u++)l=an(e,t,n[u],u),s+=","+l,i=l==="";return e.base.stack.pop(),Kr(e,r.o,r.i),"["+s+(i?",]":"]")}return"[]"}function sn(e,r,t,n){if(typeof t=="string"){let a=Number(t),s=a>=0&&a.toString()===t||jr(t);if(V(e.base,n)){let i=m(e,n.i);return h(e.base,r.i),s&&a!==a?Wr(e,r.i,t,i):Ee(e,r.i,s?t:'"'+t+'"',i),""}return be(t)?(s?t:'"'+t+'"')+":"+f(e,n):'["'+t+'"]:'+f(e,n)}return"["+f(e,t)+"]:"+f(e,n)}function pn(e,r,t){let n=t.k,a=n.length;if(a>0){let s=t.v;e.base.stack.push(r.i);let i=sn(e,r,n[0],s[0]);for(let u=1,l=i;u<a;u++)l=sn(e,r,n[u],s[u]),i+=(l&&i&&",")+l;return e.base.stack.pop(),"{"+i+"}"}return"{}"}function $o(e,r){return Kr(e,r.o,r.i),pn(e,r,r.p)}function Xo(e,r,t,n){let a=pn(e,r,t);return a!=="{}"?"Object.assign("+n+","+a+")":n}function Qo(e,r,t,n,a){let s=e.base,i=f(e,a),u=Number(n),l=u>=0&&u.toString()===n||jr(n);if(V(s,a))l&&u!==u?Wr(e,r.i,n,i):Ee(e,r.i,l?n:'"'+n+'"',i);else{let g=s.assignments;s.assignments=t,l&&u!==u?Wr(e,r.i,n,i):Ee(e,r.i,l?n:'"'+n+'"',i),s.assignments=g}}function ea(e,r,t,n,a){if(typeof n=="string")Qo(e,r,t,n,a);else{let s=e.base,i=s.stack;s.stack=[];let u=f(e,a);s.stack=i;let l=s.assignments;s.assignments=t,Ee(e,r.i,f(e,n),u),s.assignments=l}}function ra(e,r,t){let n=t.k,a=n.length;if(a>0){let s=[],i=t.v;e.base.stack.push(r.i);for(let u=0;u<a;u++)ea(e,r,s,n[u],i[u]);return e.base.stack.pop(),fn(s)}return o}function Hr(e,r,t){if(r.p){let n=e.base;if(n.features&8)t=Xo(e,r,r.p,t);else{h(n,r.i);let a=ra(e,r,r.p);if(a)return"("+se(e,r.i,t)+","+a+m(e,r.i)+")"}}return t}function ta(e,r){return Kr(e,r.o,r.i),Hr(e,r,Bo)}function na(e){return'new Date("'+e.s+'")'}function oa(e,r){if(e.base.features&32)return"/"+z(r.c)+"/"+r.m;throw new w(r)}function un(e,r,t){let n=e.base;return V(n,t)?(h(n,r),Go(e,r,m(e,t.i)),""):f(e,t)}function aa(e,r){let t=Vo,n=r.a,a=n.length,s=r.i;if(a>0){e.base.stack.push(s);let i=un(e,s,n[0]);for(let u=1,l=i;u<a;u++)l=un(e,s,n[u]),i+=(l&&i&&",")+l;e.base.stack.pop(),i&&(t+="(["+i+"])")}return t}function ln(e,r,t,n,a){let s=e.base;if(V(s,t)){let i=m(e,t.i);if(h(s,r),V(s,n)){let l=m(e,n.i);return Ce(e,r,i,l),""}if(n.t!==4&&n.i!=null&&qr(s,n.i)){let l="("+f(e,n)+",["+a+","+a+"])";return Ce(e,r,i,m(e,n.i)),on(e,r,a),l}let u=s.stack;return s.stack=[],Ce(e,r,i,f(e,n)),s.stack=u,""}if(V(s,n)){let i=m(e,n.i);if(h(s,r),t.t!==4&&t.i!=null&&qr(s,t.i)){let l="("+f(e,t)+",["+a+","+a+"])";return Ce(e,r,m(e,t.i),i),on(e,r,a),l}let u=s.stack;return s.stack=[],Ce(e,r,f(e,t),i),s.stack=u,""}return"["+f(e,t)+","+f(e,n)+"]"}function sa(e,r){let t=Mo,n=r.e.k,a=n.length,s=r.i,i=r.f,u=m(e,i.i),l=e.base;if(a>0){let g=r.e.v;l.stack.push(s);let S=ln(e,s,n[0],g[0],u);for(let d=1,Z=S;d<a;d++)Z=ln(e,s,n[d],g[d],u),S+=(Z&&S&&",")+Z;l.stack.pop(),S&&(t+="(["+S+"])")}return i.t===26&&(h(l,i.i),t="("+f(e,i)+","+t+")"),t}function ia(e,r){return H(e,r.f)+'("'+r.s+'")'}function ua(e,r){return"new "+r.c+"("+f(e,r.f)+","+r.b+","+r.l+")"}function la(e,r){return"new DataView("+f(e,r.f)+","+r.b+","+r.l+")"}function ca(e,r){let t=r.i;e.base.stack.push(t);let n=Hr(e,r,'new AggregateError([],"'+r.m+'")');return e.base.stack.pop(),n}function fa(e,r){return Hr(e,r,"new "+xe[r.s]+'("'+r.m+'")')}function Sa(e,r){let t,n=r.f,a=r.i,s=r.s?Lo:Uo,i=e.base;if(V(i,n)){let u=m(e,n.i);t=s+(r.s?"().then("+cr([],u)+")":"().catch("+Qt([],"throw "+u)+")")}else{i.stack.push(a);let u=f(e,n);i.stack.pop(),t=s+"("+u+")"}return t}function ma(e,r){return"Object("+f(e,r.f)+")"}function H(e,r){let t=f(e,r);return r.t===4?t:"("+t+")"}function pa(e,r){if(e.mode===1)throw new w(r);return"("+se(e,r.s,H(e,r.f)+"()")+").p"}function da(e,r){if(e.mode===1)throw new w(r);return H(e,r.a[0])+"("+m(e,r.i)+","+f(e,r.a[1])+")"}function ga(e,r){if(e.mode===1)throw new w(r);return H(e,r.a[0])+"("+m(e,r.i)+","+f(e,r.a[1])+")"}function ya(e,r){let t=e.base.plugins;if(t)for(let n=0,a=t.length;n<a;n++){let s=t[n];if(s.tag===r.c)return e.child==null&&(e.child=new Yr(e)),s.serialize(r.s,e.child,{id:r.i})}throw new q(r.c)}function Na(e,r){let t="",n=!1;return r.f.t!==4&&(h(e.base,r.f.i),t="("+f(e,r.f)+",",n=!0),t+=se(e,r.i,"("+xt+")("+m(e,r.f.i)+")"),n&&(t+=")"),t}function ba(e,r){return H(e,r.a[0])+"("+f(e,r.a[1])+")"}function va(e,r){let t=r.a[0],n=r.a[1],a=e.base,s="";t.t!==4&&(h(a,t.i),s+="("+f(e,t)),n.t!==4&&(h(a,n.i),s+=(s?",":"(")+f(e,n)),s&&(s+=",");let i=se(e,r.i,"("+Tt+")("+m(e,n.i)+","+m(e,t.i)+")");return s?s+i+")":i}function Ca(e,r){return H(e,r.a[0])+"("+f(e,r.a[1])+")"}function Aa(e,r){let t=se(e,r.i,H(e,r.f)+"()"),n=r.a.length;if(n){let a=f(e,r.a[0]);for(let s=1;s<n;s++)a+=","+f(e,r.a[s]);return"("+t+","+a+","+m(e,r.i)+")"}return t}function Ea(e,r){return m(e,r.i)+".next("+f(e,r.f)+")"}function Ia(e,r){return m(e,r.i)+".throw("+f(e,r.f)+")"}function Ra(e,r){return m(e,r.i)+".return("+f(e,r.f)+")"}function cn(e,r,t,n){let a=e.base;return V(a,n)?(h(a,r),Ho(e,r,t,m(e,n.i)),""):f(e,n)}function Pa(e,r){let t=r.a,n=t.length,a=r.i;if(n>0){e.base.stack.push(a);let s=cn(e,a,0,t[0]);for(let i=1,u=s;i<n;i++)u=cn(e,a,i,t[i]),s+=(u&&s&&",")+u;if(e.base.stack.pop(),s)return"{__SEROVAL_SEQUENCE__:!0,v:["+s+"],t:"+r.s+",d:"+r.l+"}"}return"{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}"}function xa(e,r){switch(r.t){case 17:return st[r.s];case 18:return Jo(r);case 9:return Zo(e,r);case 10:return $o(e,r);case 11:return ta(e,r);case 5:return na(r);case 6:return oa(e,r);case 7:return aa(e,r);case 8:return sa(e,r);case 19:return ia(e,r);case 16:case 15:return ua(e,r);case 20:return la(e,r);case 14:return ca(e,r);case 13:return fa(e,r);case 12:return Sa(e,r);case 21:return ma(e,r);case 22:return pa(e,r);case 25:return ya(e,r);case 26:return kt[r.s];case 35:return Pa(e,r);default:throw new w(r)}}function f(e,r){switch(r.t){case 2:return ut[r.s];case 0:return""+r.s;case 1:return'"'+r.s+'"';case 3:return r.s+"n";case 4:return m(e,r.i);case 23:return da(e,r);case 24:return ga(e,r);case 27:return Na(e,r);case 28:return ba(e,r);case 29:return va(e,r);case 30:return Ca(e,r);case 31:return Aa(e,r);case 32:return Ea(e,r);case 33:return Ia(e,r);case 34:return Ra(e,r);default:return se(e,r.i,xa(e,r))}}function mr(e,r){let t=f(e,r);if(r.i!=null&&e.state.vars.length){let n=mn(e.base),a=t;if(n){let s=m(e,r.i);a=t+","+n+s,t.startsWith(s+"=")||(a=s+"="+a),a="("+a+")"}return"("+cr(e.state.vars,a)+")()"}return r.t===10?"("+t+")":t}function pr(e,r){let t=f(e,r),n=r.i;if(n==null)return t;let a=mn(e.base),s=m(e,n),i=e.state.scopeId,u=i==null?"":ce,l=a?"("+t+","+a+s+")":t;if(u==="")return r.t===10&&!a?"("+l+")":l;let g=i==null?"()":"("+ce+'["'+y(i)+'"])';return"("+cr([u],l)+")"+g}function ue(e,r){return{type:1,base:ye(e,r),child:o}}var Zr=class{constructor(r,t){this._p=r;this.depth=t}parse(r){return E(this._p,this.depth,r)}},$r=class{constructor(r,t){this._p=r;this.depth=t}parse(r){return E(this._p,this.depth,r)}parseWithError(r){return J(this._p,this.depth,r)}isAlive(){return this._p.state.alive}pushPendingState(){tt(this._p)}popPendingState(){Ie(this._p)}onParse(r){ie(this._p,r)}onError(r){et(this._p,r)}addCleanup(r){this._p.state.cleanups.push(r)}};function Ta(e){return{alive:!0,pending:0,initial:!0,buffer:[],onParse:e.onParse,onError:e.onError,onDone:e.onDone,cleanups:[]}}function Xr(e){return{type:2,base:ye(2,e),state:Ta(e)}}function Oa(e,r,t){let n=[];for(let a=0,s=t.length;a<s;a++)a in t?n[a]=E(e,r,t[a]):n[a]=0;return n}function wa(e,r,t,n){return Be(t,n,Oa(e,r,n))}function Qr(e,r,t){let n=Object.entries(t),a=[],s=[];for(let i=0,u=n.length;i<u;i++)a.push(y(n[i][0])),s.push(E(e,r,n[i][1]));return C in t&&(a.push(I(e.base,C)),s.push(We(or(e.base),E(e,r,er(t))))),v in t&&(a.push(I(e.base,v)),s.push(Ke(ar(e.base),E(e,r,e.type===1?W():tr(t))))),P in t&&(a.push(I(e.base,P)),s.push(re(t[P]))),R in t&&(a.push(I(e.base,R)),s.push(t[R]?X:Q)),{k:a,v:s}}function Jr(e,r,t,n,a){return sr(t,n,a,Qr(e,r,n))}function ha(e,r,t,n){return Ve(t,E(e,r,n.valueOf()))}function za(e,r,t,n){return Me(t,n,E(e,r,n.buffer))}function _a(e,r,t,n){return Le(t,n,E(e,r,n.buffer))}function ka(e,r,t,n){return Ue(t,n,E(e,r,n.buffer))}function dn(e,r,t,n){let a=ee(n,e.base.features);return je(t,n,a?Qr(e,r,a):o)}function Da(e,r,t,n){let a=ee(n,e.base.features);return Ye(t,n,a?Qr(e,r,a):o)}function Fa(e,r,t,n){let a=[],s=[];for(let[i,u]of n.entries())a.push(E(e,r,i)),s.push(E(e,r,u));return ir(e.base,t,a,s)}function Ba(e,r,t,n){let a=[];for(let s of n.keys())a.push(E(e,r,s));return qe(t,a)}function Va(e,r,t,n){let a=Ge(t,D(e.base,4),[]);return e.type===1||(tt(e),n.on({next:s=>{if(e.state.alive){let i=J(e,r,s);i&&ie(e,He(t,i))}},throw:s=>{if(e.state.alive){let i=J(e,r,s);i&&ie(e,Je(t,i))}Ie(e)},return:s=>{if(e.state.alive){let i=J(e,r,s);i&&ie(e,Ze(t,i))}Ie(e)}})),a}function Ma(e,r,t){if(this.state.alive){let n=J(this,r,t);n&&ie(this,c(23,e,o,o,o,o,o,[D(this.base,2),n],o,o,o,o)),Ie(this)}}function La(e,r,t){if(this.state.alive){let n=J(this,r,t);n&&ie(this,c(24,e,o,o,o,o,o,[D(this.base,3),n],o,o,o,o))}Ie(this)}function Ua(e,r,t,n){let a=Dr(e.base,{});return e.type===2&&(tt(e),n.then(Ma.bind(e,a,r),La.bind(e,a,r))),Bt(e.base,t,a)}function ja(e,r,t,n,a){for(let s=0,i=a.length;s<i;s++){let u=a[s];if(u.parse.sync&&u.test(n))return me(t,u.tag,u.parse.sync(n,new Zr(e,r),{id:t}))}return o}function Ya(e,r,t,n,a){for(let s=0,i=a.length;s<i;s++){let u=a[s];if(u.parse.stream&&u.test(n))return me(t,u.tag,u.parse.stream(n,new $r(e,r),{id:t}))}return o}function gn(e,r,t,n){let a=e.base.plugins;return a?e.type===1?ja(e,r,t,n,a):Ya(e,r,t,n,a):o}function qa(e,r,t,n){let a=[];for(let s=0,i=n.v.length;s<i;s++)a[s]=E(e,r,n.v[s]);return $e(t,a,n.t,n.d)}function Wa(e,r,t,n,a){switch(a){case Object:return Jr(e,r,t,n,!1);case o:return Jr(e,r,t,n,!0);case Date:return De(t,n);case Error:case EvalError:case RangeError:case ReferenceError:case SyntaxError:case TypeError:case URIError:return dn(e,r,t,n);case Number:case Boolean:case String:case BigInt:return ha(e,r,t,n);case ArrayBuffer:return ur(e.base,t,n);case Int8Array:case Int16Array:case Int32Array:case Uint8Array:case Uint16Array:case Uint32Array:case Uint8ClampedArray:case Float32Array:case Float64Array:return za(e,r,t,n);case DataView:return ka(e,r,t,n);case Map:return Fa(e,r,t,n);case Set:return Ba(e,r,t,n);default:break}if(a===Promise||n instanceof Promise)return Ua(e,r,t,n);let s=e.base.features;if(s&32&&a===RegExp)return Fe(t,n);if(s&16)switch(a){case BigInt64Array:case BigUint64Array:return _a(e,r,t,n);default:break}if(s&1&&typeof AggregateError!="undefined"&&(a===AggregateError||n instanceof AggregateError))return Da(e,r,t,n);if(n instanceof Error)return dn(e,r,t,n);if(C in n||v in n)return Jr(e,r,t,n,!!a);throw new x(n)}function Ka(e,r,t,n){if(Array.isArray(n))return wa(e,r,t,n);if(rr(n))return Va(e,r,t,n);if(Qe(n))return qa(e,r,t,n);let a=n.constructor;if(a===U)return E(e,r,n.replacement);let s=gn(e,r,t,n);return s||Wa(e,r,t,n,a)}function Ga(e,r,t){let n=K(e.base,t);if(n.type!==0)return n.value;let a=gn(e,r,n.value,t);if(a)return a;throw new x(t)}function E(e,r,t){if(r>=e.base.depthLimit)throw new B(e.base.depthLimit);switch(typeof t){case"boolean":return t?X:Q;case"undefined":return Te;case"string":return re(t);case"number":return _e(t);case"bigint":return ke(t);case"object":{if(t){let n=K(e.base,t);return n.type===0?Ka(e,r+1,n.value,t):n.value}return Oe}case"symbol":return I(e.base,t);case"function":return Ga(e,r,t);default:throw new x(t)}}function le(e,r){try{return E(e,0,r)}catch(t){throw t instanceof _?t:new _(t)}}function ie(e,r){e.state.initial?e.state.buffer.push(r):rt(e,r,!1)}function et(e,r){if(e.state.onError)e.state.onError(r);else throw r instanceof _?r:new _(r)}function yn(e){e.state.onDone&&e.state.onDone();for(let r=0,t=e.state.cleanups.length;r<t;r++)e.state.cleanups[r]()}function rt(e,r,t){try{e.state.onParse(r,t)}catch(n){et(e,n)}}function tt(e){e.state.pending++}function Ie(e){--e.state.pending<=0&&yn(e)}function J(e,r,t){try{return E(e,r,t)}catch(n){return et(e,n),o}}function nt(e,r){let t=J(e,0,r);t&&(rt(e,t,!0),e.state.initial=!1,Ha(e,e.state),e.state.pending<=0&&dr(e))}function Ha(e,r){for(let t=0,n=r.buffer.length;t<n;t++)rt(e,r.buffer[t],!1)}function dr(e){e.state.alive&&(yn(e),e.state.alive=!1)}function Ja(e,r={}){let t=A(r.plugins),n=ue(2,{plugins:t,disabledFeatures:r.disabledFeatures,refs:r.refs}),a=le(n,e),s=Sr({plugins:t,features:n.base.features,scopeId:r.scopeId,markedRefs:n.base.marked});return pr(s,a)}async function Za(e,r={}){let t=A(r.plugins),n=oe(2,{plugins:t,disabledFeatures:r.disabledFeatures,refs:r.refs}),a=await ae(n,e),s=Sr({plugins:t,features:n.base.features,scopeId:r.scopeId,markedRefs:n.base.marked});return pr(s,a)}function $a(e,r={}){let t=A(r.plugins),n=ue(2,{plugins:t,disabledFeatures:r.disabledFeatures,refs:r.refs});return le(n,e)}async function Xa(e,r={}){let t=A(r.plugins),n=oe(2,{plugins:t,disabledFeatures:r.disabledFeatures,refs:r.refs});return await ae(n,e)}function ot(e,r){let t=A(r.plugins),n=Xr({plugins:t,refs:r.refs,disabledFeatures:r.disabledFeatures,onParse(a,s){let i=Sr({plugins:t,features:n.base.features,scopeId:r.scopeId,markedRefs:n.base.marked}),u;try{u=pr(i,a)}catch(l){r.onError&&r.onError(l);return}r.onSerialize(u,s)},onError:r.onError,onDone:r.onDone});return nt(n,e),dr.bind(null,n)}function Qa(e,r){let t=A(r.plugins),n=Xr({plugins:t,refs:r.refs,disabledFeatures:r.disabledFeatures,depthLimit:r.depthLimit,onParse:r.onParse,onError:r.onError,onDone:r.onDone});return nt(n,e),dr.bind(null,n)}function es(e,r){let t=A(r.plugins),n=Gt({plugins:t,refs:r.refs,features:r.features,disabledFeatures:r.disabledFeatures,depthLimit:r.depthLimit});return lr(n,e)}var Re=class{constructor(r){this.options=r;this.alive=!0;this.flushed=!1;this.done=!1;this.pending=0;this.cleanups=[];this.refs=new Map;this.keys=new Set;this.ids=0;this.plugins=A(r.plugins)}write(r,t){this.alive&&!this.flushed&&(this.pending++,this.keys.add(r),this.cleanups.push(ot(t,{plugins:this.plugins,scopeId:this.options.scopeId,refs:this.refs,disabledFeatures:this.options.disabledFeatures,onError:this.options.onError,onSerialize:(n,a)=>{this.alive&&this.options.onData(a?this.options.globalIdentifier+'["'+y(r)+'"]='+n:n)},onDone:()=>{this.alive&&(this.pending--,this.pending<=0&&this.flushed&&!this.done&&this.options.onDone&&(this.options.onDone(),this.done=!0))}})))}getNextID(){for(;this.keys.has(""+this.ids);)this.ids++;return""+this.ids}push(r){let t=this.getNextID();return this.write(t,r),t}flush(){this.alive&&(this.flushed=!0,this.pending<=0&&!this.done&&this.options.onDone&&(this.options.onDone(),this.done=!0))}close(){if(this.alive){for(let r=0,t=this.cleanups.length;r<t;r++)this.cleanups[r]();!this.done&&this.options.onDone&&(this.options.onDone(),this.done=!0),this.alive=!1}}};function rs(e,r={}){let t=A(r.plugins),n=ue(1,{plugins:t,disabledFeatures:r.disabledFeatures}),a=le(n,e),s=fr({plugins:t,features:n.base.features,markedRefs:n.base.marked});return mr(s,a)}async function ts(e,r={}){let t=A(r.plugins),n=oe(1,{plugins:t,disabledFeatures:r.disabledFeatures}),a=await ae(n,e),s=fr({plugins:t,features:n.base.features,markedRefs:n.base.marked});return mr(s,a)}function ns(e){return(0,eval)(e)}function os(e,r={}){let t=A(r.plugins),n=ue(1,{plugins:t,disabledFeatures:r.disabledFeatures});return{t:le(n,e),f:n.base.features,m:Array.from(n.base.marked)}}async function as(e,r={}){let t=A(r.plugins),n=oe(1,{plugins:t,disabledFeatures:r.disabledFeatures});return{t:await ae(n,e),f:n.base.features,m:Array.from(n.base.marked)}}function ss(e,r={}){let t=A(r.plugins),n=fr({plugins:t,features:e.f,markedRefs:e.m});return mr(n,e.t)}function is(e,r={}){var i;let t=A(r.plugins),n=r.disabledFeatures||0,a=(i=e.f)!=null?i:63,s=Kt({plugins:t,markedRefs:e.m,features:a&~n,disabledFeatures:n});return lr(s,e.t)}

dist/esm/production/index.mjs

-var L=(i=>(i[i.AggregateError=1]="AggregateError",i[i.ArrowFunction=2]="ArrowFunction",i[i.ErrorPrototypeStack=4]="ErrorPrototypeStack",i[i.ObjectAssign=8]="ObjectAssign",i[i.BigIntTypedArray=16]="BigIntTypedArray",i[i.RegExp=32]="RegExp",i))(L||{});var v=Symbol.asyncIterator,dr=Symbol.hasInstance,R=Symbol.isConcatSpreadable,C=Symbol.iterator,gr=Symbol.match,yr=Symbol.matchAll,Nr=Symbol.replace,br=Symbol.search,vr=Symbol.species,Cr=Symbol.split,Ar=Symbol.toPrimitive,P=Symbol.toStringTag,Er=Symbol.unscopables;var nt={0:"Symbol.asyncIterator",1:"Symbol.hasInstance",2:"Symbol.isConcatSpreadable",3:"Symbol.iterator",4:"Symbol.match",5:"Symbol.matchAll",6:"Symbol.replace",7:"Symbol.search",8:"Symbol.species",9:"Symbol.split",10:"Symbol.toPrimitive",11:"Symbol.toStringTag",12:"Symbol.unscopables"},Ce={[v]:0,[dr]:1,[R]:2,[C]:3,[gr]:4,[yr]:5,[Nr]:6,[br]:7,[vr]:8,[Cr]:9,[Ar]:10,[P]:11,[Er]:12},ot={0:v,1:dr,2:R,3:C,4:gr,5:yr,6:Nr,7:br,8:vr,9:Cr,10:Ar,11:P,12:Er},at={2:"!0",3:"!1",1:"void 0",0:"null",4:"-0",5:"1/0",6:"-1/0",7:"0/0"},o=void 0,st={2:!0,3:!1,1:o,0:null,4:-0,5:Number.POSITIVE_INFINITY,6:Number.NEGATIVE_INFINITY,7:Number.NaN};var Ae={0:"Error",1:"EvalError",2:"RangeError",3:"ReferenceError",4:"SyntaxError",5:"TypeError",6:"URIError"},it={0:Error,1:EvalError,2:RangeError,3:ReferenceError,4:SyntaxError,5:TypeError,6:URIError};function c(e,r,t,n,a,s,i,u,l,g,S,d){return{t:e,i:r,s:t,c:n,m:a,p:s,e:i,a:u,f:l,b:g,o:S,l:d}}function B(e){return c(2,o,e,o,o,o,o,o,o,o,o,o)}var J=B(2),Z=B(3),Ee=B(1),Ie=B(0),ut=B(4),lt=B(5),ct=B(6),ft=B(7);function dn(e){switch(e){case'"':return'\\"';case"\\":return"\\\\";case`
-`:return"\\n";case"\r":return"\\r";case"\b":return"\\b";case"	":return"\\t";case"\f":return"\\f";case"<":return"\\x3C";case"\u2028":return"\\u2028";case"\u2029":return"\\u2029";default:return o}}function y(e){let r="",t=0,n;for(let a=0,s=e.length;a<s;a++)n=dn(e[a]),n&&(r+=e.slice(t,a)+n,t=a+1);return t===0?r=e:r+=e.slice(t),r}function gn(e){switch(e){case"\\\\":return"\\";case'\\"':return'"';case"\\n":return`
-`;case"\\r":return"\r";case"\\b":return"\b";case"\\t":return"	";case"\\f":return"\f";case"\\x3C":return"<";case"\\u2028":return"\u2028";case"\\u2029":return"\u2029";default:return e}}function h(e){return e.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,gn)}var U="__SEROVAL_REFS__",le="$R",Re=`self.${le}`;function yn(e){return e==null?`${Re}=${Re}||[]`:`(${Re}=${Re}||{})["${y(e)}"]=[]`}var Ir=new Map,j=new Map;function Nn(e,r){return Ir.set(r,e),j.set(e,r),r}function Rr(e){return Ir.has(e)}function bn(e){return j.has(e)}function St(e){if(Rr(e))return Ir.get(e);throw new Pe(e)}function mt(e){if(bn(e))return j.get(e);throw new xe(e)}typeof globalThis!="undefined"?Object.defineProperty(globalThis,U,{value:j,configurable:!0,writable:!1,enumerable:!1}):typeof window!="undefined"?Object.defineProperty(window,U,{value:j,configurable:!0,writable:!1,enumerable:!1}):typeof self!="undefined"?Object.defineProperty(self,U,{value:j,configurable:!0,writable:!1,enumerable:!1}):typeof global!="undefined"&&Object.defineProperty(global,U,{value:j,configurable:!0,writable:!1,enumerable:!1});function Te(e){return e instanceof EvalError?1:e instanceof RangeError?2:e instanceof ReferenceError?3:e instanceof SyntaxError?4:e instanceof TypeError?5:e instanceof URIError?6:0}function vn(e){let r=Ae[Te(e)];return e.name!==r?{name:e.name}:e.constructor.name!==r?{name:e.constructor.name}:{}}function $(e,r){let t=vn(e),n=Object.getOwnPropertyNames(e);for(let a=0,s=n.length,i;a<s;a++)i=n[a],i!=="name"&&i!=="message"&&(i==="stack"?r&4&&(t=t||{},t[i]=e[i]):(t=t||{},t[i]=e[i]));return t}function Oe(e){return Object.isFrozen(e)?3:Object.isSealed(e)?2:Object.isExtensible(e)?0:1}function we(e){switch(e){case Number.POSITIVE_INFINITY:return lt;case Number.NEGATIVE_INFINITY:return ct}return e!==e?ft:Object.is(e,-0)?ut:c(0,o,e,o,o,o,o,o,o,o,o,o)}function X(e){return c(1,o,y(e),o,o,o,o,o,o,o,o,o)}function he(e){return c(3,o,""+e,o,o,o,o,o,o,o,o,o)}function dt(e){return c(4,e,o,o,o,o,o,o,o,o,o,o)}function ze(e,r){let t=r.valueOf();return c(5,e,t!==t?"":r.toISOString(),o,o,o,o,o,o,o,o,o)}function _e(e,r){return c(6,e,o,y(r.source),r.flags,o,o,o,o,o,o,o)}function gt(e,r){return c(17,e,Ce[r],o,o,o,o,o,o,o,o,o)}function yt(e,r){return c(18,e,y(St(r)),o,o,o,o,o,o,o,o,o)}function ce(e,r,t){return c(25,e,t,y(r),o,o,o,o,o,o,o,o)}function ke(e,r,t){return c(9,e,o,o,o,o,o,t,o,o,Oe(r),o)}function De(e,r){return c(21,e,o,o,o,o,o,o,r,o,o,o)}function Fe(e,r,t){return c(15,e,o,r.constructor.name,o,o,o,o,t,r.byteOffset,o,r.length)}function Be(e,r,t){return c(16,e,o,r.constructor.name,o,o,o,o,t,r.byteOffset,o,r.length)}function Ve(e,r,t){return c(20,e,o,o,o,o,o,o,t,r.byteOffset,o,r.byteLength)}function Me(e,r,t){return c(13,e,Te(r),o,y(r.message),t,o,o,o,o,o,o)}function Le(e,r,t){return c(14,e,Te(r),o,y(r.message),t,o,o,o,o,o,o)}function Ue(e,r){return c(7,e,o,o,o,o,o,r,o,o,o,o)}function je(e,r){return c(28,o,o,o,o,o,o,[e,r],o,o,o,o)}function Ye(e,r){return c(30,o,o,o,o,o,o,[e,r],o,o,o,o)}function qe(e,r,t){return c(31,e,o,o,o,o,o,t,r,o,o,o)}function We(e,r){return c(32,e,o,o,o,o,o,o,r,o,o,o)}function Ke(e,r){return c(33,e,o,o,o,o,o,o,r,o,o,o)}function Ge(e,r){return c(34,e,o,o,o,o,o,o,r,o,o,o)}function He(e,r,t,n){return c(35,e,t,o,o,o,o,r,o,o,o,n)}var{toString:bs}=Object.prototype;var Cn={parsing:1,serialization:2,deserialization:3};function An(e){return`Seroval Error (step: ${Cn[e]})`}var En=(e,r)=>An(e),fe=class extends Error{constructor(t,n){super(En(t,n));this.cause=n}},_=class extends fe{constructor(r){super("parsing",r)}},Pr=class extends fe{constructor(r){super("serialization",r)}},Je=class extends fe{constructor(r){super("deserialization",r)}};function k(e){return`Seroval Error (specific: ${e})`}var x=class extends Error{constructor(t){super(k(1));this.value=t}},z=class extends Error{constructor(r){super(k(2))}},Q=class extends Error{constructor(r){super(k(3))}},V=class extends Error{constructor(r){super(k(4))}},Pe=class extends Error{constructor(t){super(k(5));this.value=t}},xe=class extends Error{constructor(r){super(k(6))}},Ze=class extends Error{constructor(r){super(k(7))}},O=class extends Error{constructor(r){super(k(8))}},Nt=class extends Error{constructor(r){super(k(9))}},M=class extends Error{constructor(r){super(k(9))}};var Y=class{constructor(r,t){this.value=r;this.replacement=t}};var ee=()=>{let e={p:0,s:0,f:0};return e.p=new Promise((r,t)=>{e.s=r,e.f=t}),e},In=(e,r)=>{e.s(r),e.p.s=1,e.p.v=r},Rn=(e,r)=>{e.f(r),e.p.s=2,e.p.v=r},bt=ee.toString(),vt=In.toString(),Ct=Rn.toString(),xr=()=>{let e=[],r=[],t=!0,n=!1,a=0,s=(l,g,S)=>{for(S=0;S<a;S++)r[S]&&r[S][g](l)},i=(l,g,S,d)=>{for(g=0,S=e.length;g<S;g++)d=e[g],!t&&g===S-1?l[n?"return":"throw"](d):l.next(d)},u=(l,g)=>(t&&(g=a++,r[g]=l),i(l),()=>{t&&(r[g]=r[a],r[a--]=void 0)});return{__SEROVAL_STREAM__:!0,on:l=>u(l),next:l=>{t&&(e.push(l),s(l,"next"))},throw:l=>{t&&(e.push(l),s(l,"throw"),t=!1,n=!1,r.length=0)},return:l=>{t&&(e.push(l),s(l,"return"),t=!1,n=!0,r.length=0)}}},At=xr.toString(),Tr=e=>r=>()=>{let t=0,n={[e]:()=>n,next:()=>{if(t>r.d)return{done:!0,value:void 0};let a=t++,s=r.v[a];if(a===r.t)throw s;return{done:a===r.d,value:s}}};return n},Et=Tr.toString(),Or=(e,r)=>t=>()=>{let n=0,a=-1,s=!1,i=[],u=[],l=(S=0,d=u.length)=>{for(;S<d;S++)u[S].s({done:!0,value:void 0})};t.on({next:S=>{let d=u.shift();d&&d.s({done:!1,value:S}),i.push(S)},throw:S=>{let d=u.shift();d&&d.f(S),l(),a=i.length,s=!0,i.push(S)},return:S=>{let d=u.shift();d&&d.s({done:!0,value:S}),l(),a=i.length,i.push(S)}});let g={[e]:()=>g,next:()=>{if(a===-1){let G=n++;if(G>=i.length){let tt=r();return u.push(tt),tt.p}return{done:!1,value:i[G]}}if(n>a)return{done:!0,value:void 0};let S=n++,d=i[S];if(S!==a)return{done:!1,value:d};if(s)throw d;return{done:!0,value:d}}};return g},It=Or.toString(),wr=e=>{let r=atob(e),t=r.length,n=new Uint8Array(t);for(let a=0;a<t;a++)n[a]=r.charCodeAt(a);return n.buffer},Rt=wr.toString();function $e(e){return"__SEROVAL_SEQUENCE__"in e}function hr(e,r,t){return{__SEROVAL_SEQUENCE__:!0,v:e,t:r,d:t}}function Xe(e){let r=[],t=-1,n=-1,a=e[C]();for(;;)try{let s=a.next();if(r.push(s.value),s.done){n=r.length-1;break}}catch(s){t=r.length,r.push(s)}return hr(r,t,n)}var Pn=Tr(C);function Pt(e){return Pn(e)}var xt={},Tt={};var Ot={0:{},1:{},2:{},3:{},4:{},5:{}},wt={0:"[]",1:bt,2:vt,3:Ct,4:At,5:Rt};function Qe(e){return"__SEROVAL_STREAM__"in e}function re(){return xr()}function er(e){let r=re(),t=e[v]();async function n(){try{let a=await t.next();a.done?r.return(a.value):(r.next(a.value),await n())}catch(a){r.throw(a)}}return n().catch(()=>{}),r}var xn=Or(v,ee);function ht(e){return xn(e)}async function zr(e){try{return[1,await e]}catch(r){return[0,r]}}function me(e,r){return{plugins:r.plugins,mode:e,marked:new Set,features:63^(r.disabledFeatures||0),refs:r.refs||new Map,depthLimit:r.depthLimit||1e3}}function pe(e,r){e.marked.add(r)}function _r(e,r){let t=e.refs.size;return e.refs.set(r,t),t}function rr(e,r){let t=e.refs.get(r);return t!=null?(pe(e,t),{type:1,value:dt(t)}):{type:0,value:_r(e,r)}}function q(e,r){let t=rr(e,r);return t.type===1?t:Rr(r)?{type:2,value:yt(t.value,r)}:t}function I(e,r){let t=q(e,r);if(t.type!==0)return t.value;if(r in Ce)return gt(t.value,r);throw new x(r)}function D(e,r){let t=rr(e,Ot[r]);return t.type===1?t.value:c(26,t.value,r,o,o,o,o,o,o,o,o,o)}function tr(e){let r=rr(e,xt);return r.type===1?r.value:c(27,r.value,o,o,o,o,o,o,I(e,C),o,o,o)}function nr(e){let r=rr(e,Tt);return r.type===1?r.value:c(29,r.value,o,o,o,o,o,[D(e,1),I(e,v)],o,o,o,o)}function or(e,r,t,n){return c(t?11:10,e,o,o,o,n,o,o,o,o,Oe(r),o)}function ar(e,r,t,n){return c(8,r,o,o,o,o,{k:t,v:n},o,D(e,0),o,o,o)}function _t(e,r,t){return c(22,r,t,o,o,o,o,o,D(e,1),o,o,o)}function sr(e,r,t){let n=new Uint8Array(t),a="";for(let s=0,i=n.length;s<i;s++)a+=String.fromCharCode(n[s]);return c(19,r,y(btoa(a)),o,o,o,o,o,D(e,5),o,o,o)}function te(e,r){return{base:me(e,r),child:void 0}}var Dr=class{constructor(r,t){this._p=r;this.depth=t}parse(r){return N(this._p,this.depth,r)}};async function On(e,r,t){let n=[];for(let a=0,s=t.length;a<s;a++)a in t?n[a]=await N(e,r,t[a]):n[a]=0;return n}async function wn(e,r,t,n){return ke(t,n,await On(e,r,n))}async function Fr(e,r,t){let n=Object.entries(t),a=[],s=[];for(let i=0,u=n.length;i<u;i++)a.push(y(n[i][0])),s.push(await N(e,r,n[i][1]));return C in t&&(a.push(I(e.base,C)),s.push(je(tr(e.base),await N(e,r,Xe(t))))),v in t&&(a.push(I(e.base,v)),s.push(Ye(nr(e.base),await N(e,r,er(t))))),P in t&&(a.push(I(e.base,P)),s.push(X(t[P]))),R in t&&(a.push(I(e.base,R)),s.push(t[R]?J:Z)),{k:a,v:s}}async function kr(e,r,t,n,a){return or(t,n,a,await Fr(e,r,n))}async function hn(e,r,t,n){return De(t,await N(e,r,n.valueOf()))}async function zn(e,r,t,n){return Fe(t,n,await N(e,r,n.buffer))}async function _n(e,r,t,n){return Be(t,n,await N(e,r,n.buffer))}async function kn(e,r,t,n){return Ve(t,n,await N(e,r,n.buffer))}async function kt(e,r,t,n){let a=$(n,e.base.features);return Me(t,n,a?await Fr(e,r,a):o)}async function Dn(e,r,t,n){let a=$(n,e.base.features);return Le(t,n,a?await Fr(e,r,a):o)}async function Fn(e,r,t,n){let a=[],s=[];for(let[i,u]of n.entries())a.push(await N(e,r,i)),s.push(await N(e,r,u));return ar(e.base,t,a,s)}async function Bn(e,r,t,n){let a=[];for(let s of n.keys())a.push(await N(e,r,s));return Ue(t,a)}async function Dt(e,r,t,n){let a=e.base.plugins;if(a)for(let s=0,i=a.length;s<i;s++){let u=a[s];if(u.parse.async&&u.test(n))return ce(t,u.tag,await u.parse.async(n,new Dr(e,r),{id:t}))}return o}async function Vn(e,r,t,n){let[a,s]=await zr(n);return c(12,t,a,o,o,o,o,o,await N(e,r,s),o,o,o)}function Mn(e,r,t,n,a){let s=[],i=t.on({next:u=>{pe(this.base,r),N(this,e,u).then(l=>{s.push(We(r,l))},l=>{a(l),i()})},throw:u=>{pe(this.base,r),N(this,e,u).then(l=>{s.push(Ke(r,l)),n(s),i()},l=>{a(l),i()})},return:u=>{pe(this.base,r),N(this,e,u).then(l=>{s.push(Ge(r,l)),n(s),i()},l=>{a(l),i()})}})}async function Ln(e,r,t,n){return qe(t,D(e.base,4),await new Promise(Mn.bind(e,r,t,n)))}async function Un(e,r,t,n){let a=[];for(let s=0,i=n.v.length;s<i;s++)a[s]=await N(e,r,n.v[s]);return He(t,a,n.t,n.d)}async function jn(e,r,t,n){if(Array.isArray(n))return wn(e,r,t,n);if(Qe(n))return Ln(e,r,t,n);if($e(n))return Un(e,r,t,n);let a=n.constructor;if(a===Y)return N(e,r,n.replacement);let s=await Dt(e,r,t,n);if(s)return s;switch(a){case Object:return kr(e,r,t,n,!1);case o:return kr(e,r,t,n,!0);case Date:return ze(t,n);case Error:case EvalError:case RangeError:case ReferenceError:case SyntaxError:case TypeError:case URIError:return kt(e,r,t,n);case Number:case Boolean:case String:case BigInt:return hn(e,r,t,n);case ArrayBuffer:return sr(e.base,t,n);case Int8Array:case Int16Array:case Int32Array:case Uint8Array:case Uint16Array:case Uint32Array:case Uint8ClampedArray:case Float32Array:case Float64Array:return zn(e,r,t,n);case DataView:return kn(e,r,t,n);case Map:return Fn(e,r,t,n);case Set:return Bn(e,r,t,n);default:break}if(a===Promise||n instanceof Promise)return Vn(e,r,t,n);let i=e.base.features;if(i&32&&a===RegExp)return _e(t,n);if(i&16)switch(a){case BigInt64Array:case BigUint64Array:return _n(e,r,t,n);default:break}if(i&1&&typeof AggregateError!="undefined"&&(a===AggregateError||n instanceof AggregateError))return Dn(e,r,t,n);if(n instanceof Error)return kt(e,r,t,n);if(C in n||v in n)return kr(e,r,t,n,!!a);throw new x(n)}async function Yn(e,r,t){let n=q(e.base,t);if(n.type!==0)return n.value;let a=await Dt(e,r,n.value,t);if(a)return a;throw new x(t)}async function N(e,r,t){if(r>=e.base.depthLimit)throw new M(e.base.depthLimit);switch(typeof t){case"boolean":return t?J:Z;case"undefined":return Ee;case"string":return X(t);case"number":return we(t);case"bigint":return he(t);case"object":{if(t){let n=q(e.base,t);return n.type===0?await jn(e,r+1,n.value,t):n.value}return Ie}case"symbol":return I(e.base,t);case"function":return Yn(e,r,t);default:throw new x(t)}}async function ne(e,r){try{return await N(e,0,r)}catch(t){throw t instanceof _?t:new _(t)}}var oe=(t=>(t[t.Vanilla=1]="Vanilla",t[t.Cross=2]="Cross",t))(oe||{});function ai(e){return e}function Ft(e,r){for(let t=0,n=r.length;t<n;t++){let a=r[t];e.has(a)||(e.add(a),a.extends&&Ft(e,a.extends))}}function A(e){if(e){let r=new Set;return Ft(r,e),[...r]}}function Bt(e){switch(e){case"Int8Array":return Int8Array;case"Int16Array":return Int16Array;case"Int32Array":return Int32Array;case"Uint8Array":return Uint8Array;case"Uint16Array":return Uint16Array;case"Uint32Array":return Uint32Array;case"Uint8ClampedArray":return Uint8ClampedArray;case"Float32Array":return Float32Array;case"Float64Array":return Float64Array;case"BigInt64Array":return BigInt64Array;case"BigUint64Array":return BigUint64Array;default:throw new Ze(e)}}function de(e){switch(e){case"constructor":case"__proto__":case"prototype":case"__defineGetter__":case"__defineSetter__":case"__lookupGetter__":case"__lookupSetter__":return!1;default:return!0}}function Vt(e){switch(e){case v:case R:case P:case C:return!0;default:return!1}}var qn=1e6,Wn=1e4,Kn=2e4;function Lt(e,r){switch(r){case 3:return Object.freeze(e);case 1:return Object.preventExtensions(e);case 2:return Object.seal(e);default:return e}}var Gn=1e3;function Ut(e,r){var n;let t=r.refs||new Map;return"types"in t||Object.assign(t,{types:new Map}),{mode:e,plugins:r.plugins,refs:t,features:(n=r.features)!=null?n:63^(r.disabledFeatures||0),depthLimit:r.depthLimit||Gn}}function jt(e){return{mode:1,base:Ut(1,e),child:o,state:{marked:new Set(e.markedRefs)}}}function Yt(e){return{mode:2,base:Ut(2,e),child:o}}var Br=class{constructor(r,t){this._p=r;this.depth=t}deserialize(r){return p(this._p,this.depth,r)}};function qt(e,r){if(r<0||!Number.isFinite(r)||!Number.isInteger(r))throw new O({t:4,i:r});if(e.refs.has(r))throw new Error("Conflicted ref id: "+r)}function Hn(e,r,t){return qt(e.base,r),e.state.marked.has(r)&&e.base.refs.set(r,t),t}function Jn(e,r,t){return qt(e.base,r),e.base.refs.set(r,t),t}function b(e,r,t){return e.mode===1?Hn(e,r,t):Jn(e,r,t)}function Vr(e,r,t){if(Object.hasOwn(r,t))return r[t];throw new O(e)}function Zn(e,r){return b(e,r.i,mt(h(r.s)))}function $n(e,r,t){let n=t.a,a=n.length,s=b(e,t.i,new Array(a));for(let i=0,u;i<a;i++)u=n[i],u&&(s[i]=p(e,r,u));return Lt(s,t.o),s}function Mt(e,r,t){de(r)?e[r]=t:Object.defineProperty(e,r,{value:t,configurable:!0,enumerable:!0,writable:!0})}function Xn(e,r,t,n,a){if(typeof n=="string")Mt(t,h(n),p(e,r,a));else{let s=p(e,r,n);switch(typeof s){case"string":Mt(t,s,p(e,r,a));break;case"symbol":Vt(s)&&(t[s]=p(e,r,a));break;default:throw new O(n)}}}function Wt(e,r,t){e.base.refs.types.set(r,t)}function ge(e,r,t,n){if(e.base.refs.types.get(t)!==n)throw new O(r)}function Kt(e,r,t,n){let a=t.k;if(a.length>0)for(let i=0,u=t.v,l=a.length;i<l;i++)Xn(e,r,n,a[i],u[i]);return n}function Qn(e,r,t){let n=b(e,t.i,t.t===10?{}:Object.create(null));return Kt(e,r,t.p,n),Lt(n,t.o),n}function eo(e,r){return b(e,r.i,new Date(r.s))}function ro(e,r){if(e.base.features&32){let t=h(r.c);if(t.length>Kn)throw new O(r);return b(e,r.i,new RegExp(t,r.m))}throw new z(r)}function to(e,r,t){let n=b(e,t.i,new Set);for(let a=0,s=t.a,i=s.length;a<i;a++)n.add(p(e,r,s[a]));return n}function no(e,r,t){let n=b(e,t.i,new Map);for(let a=0,s=t.e.k,i=t.e.v,u=s.length;a<u;a++)n.set(p(e,r,s[a]),p(e,r,i[a]));return n}function oo(e,r){if(r.s.length>qn)throw new O(r);return b(e,r.i,wr(h(r.s)))}function ao(e,r,t){var u;let n=Bt(t.c),a=p(e,r,t.f),s=(u=t.b)!=null?u:0;if(s<0||s>a.byteLength)throw new O(t);return b(e,t.i,new n(a,s,t.l))}function so(e,r,t){var i;let n=p(e,r,t.f),a=(i=t.b)!=null?i:0;if(a<0||a>n.byteLength)throw new O(t);return b(e,t.i,new DataView(n,a,t.l))}function Gt(e,r,t,n){if(t.p){let a=Kt(e,r,t.p,{});Object.defineProperties(n,Object.getOwnPropertyDescriptors(a))}return n}function io(e,r,t){let n=b(e,t.i,new AggregateError([],h(t.m)));return Gt(e,r,t,n)}function uo(e,r,t){let n=Vr(t,it,t.s),a=b(e,t.i,new n(h(t.m)));return Gt(e,r,t,a)}function lo(e,r,t){let n=ee(),a=b(e,t.i,n.p),s=p(e,r,t.f);return t.s?n.s(s):n.f(s),a}function co(e,r,t){return b(e,t.i,Object(p(e,r,t.f)))}function fo(e,r,t){let n=e.base.plugins;if(n){let a=h(t.c);for(let s=0,i=n.length;s<i;s++){let u=n[s];if(u.tag===a)return b(e,t.i,u.deserialize(t.s,new Br(e,r),{id:t.i}))}}throw new Q(t.c)}function So(e,r){let t=b(e,r.i,b(e,r.s,ee()).p);return Wt(e,r.s,22),t}function mo(e,r,t){let n=e.base.refs.get(t.i);if(n)return ge(e,t,t.i,22),n.s(p(e,r,t.a[1])),o;throw new V("Promise")}function po(e,r,t){let n=e.base.refs.get(t.i);if(n)return ge(e,t,t.i,22),n.f(p(e,r,t.a[1])),o;throw new V("Promise")}function go(e,r,t){p(e,r,t.a[0]);let n=p(e,r,t.a[1]);return Pt(n)}function yo(e,r,t){p(e,r,t.a[0]);let n=p(e,r,t.a[1]);return ht(n)}function No(e,r,t){let n=b(e,t.i,re());Wt(e,t.i,31);let a=t.a,s=a.length;if(s)for(let i=0;i<s;i++)p(e,r,a[i]);return n}function bo(e,r,t){let n=e.base.refs.get(t.i);if(n)return ge(e,t,t.i,31),n.next(p(e,r,t.f)),o;throw new V("Stream")}function vo(e,r,t){let n=e.base.refs.get(t.i);if(n)return ge(e,t,t.i,31),n.throw(p(e,r,t.f)),o;throw new V("Stream")}function Co(e,r,t){let n=e.base.refs.get(t.i);if(n)return ge(e,t,t.i,31),n.return(p(e,r,t.f)),o;throw new V("Stream")}function Ao(e,r,t){return p(e,r,t.f),o}function Eo(e,r,t){return p(e,r,t.a[1]),o}function Io(e,r,t){let n=b(e,t.i,hr([],t.s,t.l));for(let a=0,s=t.a.length;a<s;a++)n.v[a]=p(e,r,t.a[a]);return n}function p(e,r,t){if(r>e.base.depthLimit)throw new M(e.base.depthLimit);switch(r+=1,t.t){case 2:return Vr(t,st,t.s);case 0:return Number(t.s);case 1:return h(String(t.s));case 3:if(String(t.s).length>Wn)throw new O(t);return BigInt(t.s);case 4:return e.base.refs.get(t.i);case 18:return Zn(e,t);case 9:return $n(e,r,t);case 10:case 11:return Qn(e,r,t);case 5:return eo(e,t);case 6:return ro(e,t);case 7:return to(e,r,t);case 8:return no(e,r,t);case 19:return oo(e,t);case 16:case 15:return ao(e,r,t);case 20:return so(e,r,t);case 14:return io(e,r,t);case 13:return uo(e,r,t);case 12:return lo(e,r,t);case 17:return Vr(t,ot,t.s);case 21:return co(e,r,t);case 25:return fo(e,r,t);case 22:return So(e,t);case 23:return mo(e,r,t);case 24:return po(e,r,t);case 28:return go(e,r,t);case 30:return yo(e,r,t);case 31:return No(e,r,t);case 32:return bo(e,r,t);case 33:return vo(e,r,t);case 34:return Co(e,r,t);case 27:return Ao(e,r,t);case 29:return Eo(e,r,t);case 35:return Io(e,r,t);default:throw new z(t)}}function ir(e,r){try{return p(e,0,r)}catch(t){throw new Je(t)}}var Ro=()=>T,Po=Ro.toString(),Ht=/=>/.test(Po);function ur(e,r){return Ht?(e.length===1?e[0]:"("+e.join(",")+")")+"=>"+(r.startsWith("{")?"("+r+")":r):"function("+e.join(",")+"){return "+r+"}"}function Jt(e,r){return Ht?(e.length===1?e[0]:"("+e.join(",")+")")+"=>{"+r+"}":"function("+e.join(",")+"){"+r+"}"}var Xt="hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_",Zt=Xt.length,Qt="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_",$t=Qt.length;function Mr(e){let r=e%Zt,t=Xt[r];for(e=(e-r)/Zt;e>0;)r=e%$t,t+=Qt[r],e=(e-r)/$t;return t}var xo=/^[$A-Z_][0-9A-Z_$]*$/i;function Lr(e){let r=e[0];return(r==="$"||r==="_"||r>="A"&&r<="Z"||r>="a"&&r<="z")&&xo.test(e)}function Ne(e){switch(e.t){case 0:return e.s+"="+e.v;case 2:return e.s+".set("+e.k+","+e.v+")";case 1:return e.s+".add("+e.v+")";case 3:return e.s+".delete("+e.k+")";case 4:return"Object.defineProperty("+e.s+',"__proto__",{value:'+e.k+",configurable:!0,enumerable:!0,writable:!0})"}}function To(e){let r=[],t=e[0];for(let n=1,a=e.length,s,i=t;n<a;n++)s=e[n],s.t===0&&s.v===i.v?t={t:0,s:s.s,k:o,v:Ne(t)}:s.t===2&&s.s===i.s?t={t:2,s:Ne(t),k:s.k,v:s.v}:s.t===1&&s.s===i.s?t={t:1,s:Ne(t),k:o,v:s.v}:s.t===3&&s.s===i.s?t={t:3,s:Ne(t),k:s.k,v:o}:(r.push(t),t=s),i=s;return r.push(t),r}function sn(e){if(e.length){let r="",t=To(e);for(let n=0,a=t.length;n<a;n++)r+=Ne(t[n])+",";return r}return o}var Oo="Object.create(null)",wo="new Set",ho="new Map",zo="Promise.resolve",_o="Promise.reject",ko={3:"Object.freeze",2:"Object.seal",1:"Object.preventExtensions",0:o};function un(e,r){return{mode:e,plugins:r.plugins,features:r.features,marked:new Set(r.markedRefs),stack:[],flags:[],assignments:[]}}function Do(){return{valid:new Map,vars:[]}}function lr(e){return{mode:1,base:un(1,e),state:Do(),child:o}}function cr(e){return{mode:2,base:un(2,e),state:e,child:o}}var Ur=class{constructor(r){this._p=r}serialize(r){return f(this._p,r)}};function Fo(e,r){let t=e.valid.get(r);t==null&&(t=e.valid.size,e.valid.set(r,t));let n=e.vars[t];return n==null&&(n=Mr(t),e.vars[t]=n),n}function Bo(e){return le+"["+e+"]"}function m(e,r){return e.mode===1?Fo(e.state,r):Bo(r)}function w(e,r){e.marked.add(r)}function jr(e,r){return e.marked.has(r)}function qr(e,r,t){r!==0&&(w(e.base,t),e.base.flags.push({type:r,value:m(e,t)}))}function Vo(e){let r="";for(let t=0,n=e.flags,a=n.length;t<a;t++){let s=n[t];r+=ko[s.type]+"("+s.value+"),"}return r}function ln(e){let r=sn(e.assignments),t=Vo(e);return r?t?r+t:r:t}function Wr(e,r,t){e.assignments.push({t:0,s:r,k:o,v:t})}function Mo(e,r,t){e.base.assignments.push({t:1,s:m(e,r),k:o,v:t})}function ye(e,r,t,n){e.base.assignments.push({t:2,s:m(e,r),k:t,v:n})}function en(e,r,t){e.base.assignments.push({t:3,s:m(e,r),k:t,v:o})}function be(e,r,t,n){Wr(e.base,m(e,r)+"["+t+"]",n)}function Yr(e,r,t,n){if(!de(t)){e.base.assignments.push({t:4,s:m(e,r),k:n,v:o});return}Wr(e.base,m(e,r)+"."+t,n)}function Lo(e,r,t,n){Wr(e.base,m(e,r)+".v["+t+"]",n)}function F(e,r){return r.t===4&&e.stack.includes(r.i)}function ae(e,r,t){return e.mode===1&&!jr(e.base,r)?t:m(e,r)+"="+t}function Uo(e){return U+'.get("'+e.s+'")'}function rn(e,r,t,n){return t?F(e.base,t)?(w(e.base,r),be(e,r,n,m(e,t.i)),""):f(e,t):""}function jo(e,r){let t=r.i,n=r.a,a=n.length;if(a>0){e.base.stack.push(t);let s=rn(e,t,n[0],0),i=s==="";for(let u=1,l;u<a;u++)l=rn(e,t,n[u],u),s+=","+l,i=l==="";return e.base.stack.pop(),qr(e,r.o,r.i),"["+s+(i?",]":"]")}return"[]"}function tn(e,r,t,n){if(typeof t=="string"){let a=Number(t),s=a>=0&&a.toString()===t||Lr(t);if(F(e.base,n)){let i=m(e,n.i);return w(e.base,r.i),s&&a!==a?Yr(e,r.i,t,i):be(e,r.i,s?t:'"'+t+'"',i),""}return de(t)?(s?t:'"'+t+'"')+":"+f(e,n):'["'+t+'"]:'+f(e,n)}return"["+f(e,t)+"]:"+f(e,n)}function cn(e,r,t){let n=t.k,a=n.length;if(a>0){let s=t.v;e.base.stack.push(r.i);let i=tn(e,r,n[0],s[0]);for(let u=1,l=i;u<a;u++)l=tn(e,r,n[u],s[u]),i+=(l&&i&&",")+l;return e.base.stack.pop(),"{"+i+"}"}return"{}"}function Yo(e,r){return qr(e,r.o,r.i),cn(e,r,r.p)}function qo(e,r,t,n){let a=cn(e,r,t);return a!=="{}"?"Object.assign("+n+","+a+")":n}function Wo(e,r,t,n,a){let s=e.base,i=f(e,a),u=Number(n),l=u>=0&&u.toString()===n||Lr(n);if(F(s,a))l&&u!==u?Yr(e,r.i,n,i):be(e,r.i,l?n:'"'+n+'"',i);else{let g=s.assignments;s.assignments=t,l&&u!==u?Yr(e,r.i,n,i):be(e,r.i,l?n:'"'+n+'"',i),s.assignments=g}}function Ko(e,r,t,n,a){if(typeof n=="string")Wo(e,r,t,n,a);else{let s=e.base,i=s.stack;s.stack=[];let u=f(e,a);s.stack=i;let l=s.assignments;s.assignments=t,be(e,r.i,f(e,n),u),s.assignments=l}}function Go(e,r,t){let n=t.k,a=n.length;if(a>0){let s=[],i=t.v;e.base.stack.push(r.i);for(let u=0;u<a;u++)Ko(e,r,s,n[u],i[u]);return e.base.stack.pop(),sn(s)}return o}function Kr(e,r,t){if(r.p){let n=e.base;if(n.features&8)t=qo(e,r,r.p,t);else{w(n,r.i);let a=Go(e,r,r.p);if(a)return"("+ae(e,r.i,t)+","+a+m(e,r.i)+")"}}return t}function Ho(e,r){return qr(e,r.o,r.i),Kr(e,r,Oo)}function Jo(e){return'new Date("'+e.s+'")'}function Zo(e,r){if(e.base.features&32)return"/"+h(r.c)+"/"+r.m;throw new z(r)}function nn(e,r,t){let n=e.base;return F(n,t)?(w(n,r),Mo(e,r,m(e,t.i)),""):f(e,t)}function $o(e,r){let t=wo,n=r.a,a=n.length,s=r.i;if(a>0){e.base.stack.push(s);let i=nn(e,s,n[0]);for(let u=1,l=i;u<a;u++)l=nn(e,s,n[u]),i+=(l&&i&&",")+l;e.base.stack.pop(),i&&(t+="(["+i+"])")}return t}function on(e,r,t,n,a){let s=e.base;if(F(s,t)){let i=m(e,t.i);if(w(s,r),F(s,n)){let l=m(e,n.i);return ye(e,r,i,l),""}if(n.t!==4&&n.i!=null&&jr(s,n.i)){let l="("+f(e,n)+",["+a+","+a+"])";return ye(e,r,i,m(e,n.i)),en(e,r,a),l}let u=s.stack;return s.stack=[],ye(e,r,i,f(e,n)),s.stack=u,""}if(F(s,n)){let i=m(e,n.i);if(w(s,r),t.t!==4&&t.i!=null&&jr(s,t.i)){let l="("+f(e,t)+",["+a+","+a+"])";return ye(e,r,m(e,t.i),i),en(e,r,a),l}let u=s.stack;return s.stack=[],ye(e,r,f(e,t),i),s.stack=u,""}return"["+f(e,t)+","+f(e,n)+"]"}function Xo(e,r){let t=ho,n=r.e.k,a=n.length,s=r.i,i=r.f,u=m(e,i.i),l=e.base;if(a>0){let g=r.e.v;l.stack.push(s);let S=on(e,s,n[0],g[0],u);for(let d=1,G=S;d<a;d++)G=on(e,s,n[d],g[d],u),S+=(G&&S&&",")+G;l.stack.pop(),S&&(t+="(["+S+"])")}return i.t===26&&(w(l,i.i),t="("+f(e,i)+","+t+")"),t}function Qo(e,r){return W(e,r.f)+'("'+r.s+'")'}function ea(e,r){return"new "+r.c+"("+f(e,r.f)+","+r.b+","+r.l+")"}function ra(e,r){return"new DataView("+f(e,r.f)+","+r.b+","+r.l+")"}function ta(e,r){let t=r.i;e.base.stack.push(t);let n=Kr(e,r,'new AggregateError([],"'+r.m+'")');return e.base.stack.pop(),n}function na(e,r){return Kr(e,r,"new "+Ae[r.s]+'("'+r.m+'")')}function oa(e,r){let t,n=r.f,a=r.i,s=r.s?zo:_o,i=e.base;if(F(i,n)){let u=m(e,n.i);t=s+(r.s?"().then("+ur([],u)+")":"().catch("+Jt([],"throw "+u)+")")}else{i.stack.push(a);let u=f(e,n);i.stack.pop(),t=s+"("+u+")"}return t}function aa(e,r){return"Object("+f(e,r.f)+")"}function W(e,r){let t=f(e,r);return r.t===4?t:"("+t+")"}function sa(e,r){if(e.mode===1)throw new z(r);return"("+ae(e,r.s,W(e,r.f)+"()")+").p"}function ia(e,r){if(e.mode===1)throw new z(r);return W(e,r.a[0])+"("+m(e,r.i)+","+f(e,r.a[1])+")"}function ua(e,r){if(e.mode===1)throw new z(r);return W(e,r.a[0])+"("+m(e,r.i)+","+f(e,r.a[1])+")"}function la(e,r){let t=e.base.plugins;if(t)for(let n=0,a=t.length;n<a;n++){let s=t[n];if(s.tag===r.c)return e.child==null&&(e.child=new Ur(e)),s.serialize(r.s,e.child,{id:r.i})}throw new Q(r.c)}function ca(e,r){let t="",n=!1;return r.f.t!==4&&(w(e.base,r.f.i),t="("+f(e,r.f)+",",n=!0),t+=ae(e,r.i,"("+Et+")("+m(e,r.f.i)+")"),n&&(t+=")"),t}function fa(e,r){return W(e,r.a[0])+"("+f(e,r.a[1])+")"}function Sa(e,r){let t=r.a[0],n=r.a[1],a=e.base,s="";t.t!==4&&(w(a,t.i),s+="("+f(e,t)),n.t!==4&&(w(a,n.i),s+=(s?",":"(")+f(e,n)),s&&(s+=",");let i=ae(e,r.i,"("+It+")("+m(e,n.i)+","+m(e,t.i)+")");return s?s+i+")":i}function ma(e,r){return W(e,r.a[0])+"("+f(e,r.a[1])+")"}function pa(e,r){let t=ae(e,r.i,W(e,r.f)+"()"),n=r.a.length;if(n){let a=f(e,r.a[0]);for(let s=1;s<n;s++)a+=","+f(e,r.a[s]);return"("+t+","+a+","+m(e,r.i)+")"}return t}function da(e,r){return m(e,r.i)+".next("+f(e,r.f)+")"}function ga(e,r){return m(e,r.i)+".throw("+f(e,r.f)+")"}function ya(e,r){return m(e,r.i)+".return("+f(e,r.f)+")"}function an(e,r,t,n){let a=e.base;return F(a,n)?(w(a,r),Lo(e,r,t,m(e,n.i)),""):f(e,n)}function Na(e,r){let t=r.a,n=t.length,a=r.i;if(n>0){e.base.stack.push(a);let s=an(e,a,0,t[0]);for(let i=1,u=s;i<n;i++)u=an(e,a,i,t[i]),s+=(u&&s&&",")+u;if(e.base.stack.pop(),s)return"{__SEROVAL_SEQUENCE__:!0,v:["+s+"],t:"+r.s+",d:"+r.l+"}"}return"{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}"}function ba(e,r){switch(r.t){case 17:return nt[r.s];case 18:return Uo(r);case 9:return jo(e,r);case 10:return Yo(e,r);case 11:return Ho(e,r);case 5:return Jo(r);case 6:return Zo(e,r);case 7:return $o(e,r);case 8:return Xo(e,r);case 19:return Qo(e,r);case 16:case 15:return ea(e,r);case 20:return ra(e,r);case 14:return ta(e,r);case 13:return na(e,r);case 12:return oa(e,r);case 21:return aa(e,r);case 22:return sa(e,r);case 25:return la(e,r);case 26:return wt[r.s];case 35:return Na(e,r);default:throw new z(r)}}function f(e,r){switch(r.t){case 2:return at[r.s];case 0:return""+r.s;case 1:return'"'+r.s+'"';case 3:return r.s+"n";case 4:return m(e,r.i);case 23:return ia(e,r);case 24:return ua(e,r);case 27:return ca(e,r);case 28:return fa(e,r);case 29:return Sa(e,r);case 30:return ma(e,r);case 31:return pa(e,r);case 32:return da(e,r);case 33:return ga(e,r);case 34:return ya(e,r);default:return ae(e,r.i,ba(e,r))}}function fr(e,r){let t=f(e,r);if(r.i!=null&&e.state.vars.length){let n=ln(e.base),a=t;if(n){let s=m(e,r.i);a=t+","+n+s,t.startsWith(s+"=")||(a=s+"="+a),a="("+a+")"}return"("+ur(e.state.vars,a)+")()"}return r.t===10?"("+t+")":t}function Sr(e,r){let t=f(e,r),n=r.i;if(n==null)return t;let a=ln(e.base),s=m(e,n),i=e.state.scopeId,u=i==null?"":le,l=a?"("+t+","+a+s+")":t;if(u==="")return r.t===10&&!a?"("+l+")":l;let g=i==null?"()":"("+le+'["'+y(i)+'"])';return"("+ur([u],l)+")"+g}function ie(e,r){return{type:1,base:me(e,r),child:o}}var Hr=class{constructor(r,t){this._p=r;this.depth=t}parse(r){return E(this._p,this.depth,r)}},Jr=class{constructor(r,t){this._p=r;this.depth=t}parse(r){return E(this._p,this.depth,r)}parseWithError(r){return K(this._p,this.depth,r)}isAlive(){return this._p.state.alive}pushPendingState(){et(this._p)}popPendingState(){ve(this._p)}onParse(r){se(this._p,r)}onError(r){Xr(this._p,r)}addCleanup(r){this._p.state.cleanups.push(r)}};function va(e){return{alive:!0,pending:0,initial:!0,buffer:[],onParse:e.onParse,onError:e.onError,onDone:e.onDone,cleanups:[]}}function Zr(e){return{type:2,base:me(2,e),state:va(e)}}function Ca(e,r,t){let n=[];for(let a=0,s=t.length;a<s;a++)a in t?n[a]=E(e,r,t[a]):n[a]=0;return n}function Aa(e,r,t,n){return ke(t,n,Ca(e,r,n))}function $r(e,r,t){let n=Object.entries(t),a=[],s=[];for(let i=0,u=n.length;i<u;i++)a.push(y(n[i][0])),s.push(E(e,r,n[i][1]));return C in t&&(a.push(I(e.base,C)),s.push(je(tr(e.base),E(e,r,Xe(t))))),v in t&&(a.push(I(e.base,v)),s.push(Ye(nr(e.base),E(e,r,e.type===1?re():er(t))))),P in t&&(a.push(I(e.base,P)),s.push(X(t[P]))),R in t&&(a.push(I(e.base,R)),s.push(t[R]?J:Z)),{k:a,v:s}}function Gr(e,r,t,n,a){return or(t,n,a,$r(e,r,n))}function Ea(e,r,t,n){return De(t,E(e,r,n.valueOf()))}function Ia(e,r,t,n){return Fe(t,n,E(e,r,n.buffer))}function Ra(e,r,t,n){return Be(t,n,E(e,r,n.buffer))}function Pa(e,r,t,n){return Ve(t,n,E(e,r,n.buffer))}function fn(e,r,t,n){let a=$(n,e.base.features);return Me(t,n,a?$r(e,r,a):o)}function xa(e,r,t,n){let a=$(n,e.base.features);return Le(t,n,a?$r(e,r,a):o)}function Ta(e,r,t,n){let a=[],s=[];for(let[i,u]of n.entries())a.push(E(e,r,i)),s.push(E(e,r,u));return ar(e.base,t,a,s)}function Oa(e,r,t,n){let a=[];for(let s of n.keys())a.push(E(e,r,s));return Ue(t,a)}function wa(e,r,t,n){let a=qe(t,D(e.base,4),[]);return e.type===1||(et(e),n.on({next:s=>{if(e.state.alive){let i=K(e,r,s);i&&se(e,We(t,i))}},throw:s=>{if(e.state.alive){let i=K(e,r,s);i&&se(e,Ke(t,i))}ve(e)},return:s=>{if(e.state.alive){let i=K(e,r,s);i&&se(e,Ge(t,i))}ve(e)}})),a}function ha(e,r,t){if(this.state.alive){let n=K(this,r,t);n&&se(this,c(23,e,o,o,o,o,o,[D(this.base,2),n],o,o,o,o)),ve(this)}}function za(e,r,t){if(this.state.alive){let n=K(this,r,t);n&&se(this,c(24,e,o,o,o,o,o,[D(this.base,3),n],o,o,o,o))}ve(this)}function _a(e,r,t,n){let a=_r(e.base,{});return e.type===2&&(et(e),n.then(ha.bind(e,a,r),za.bind(e,a,r))),_t(e.base,t,a)}function ka(e,r,t,n,a){for(let s=0,i=a.length;s<i;s++){let u=a[s];if(u.parse.sync&&u.test(n))return ce(t,u.tag,u.parse.sync(n,new Hr(e,r),{id:t}))}return o}function Da(e,r,t,n,a){for(let s=0,i=a.length;s<i;s++){let u=a[s];if(u.parse.stream&&u.test(n))return ce(t,u.tag,u.parse.stream(n,new Jr(e,r),{id:t}))}return o}function Sn(e,r,t,n){let a=e.base.plugins;return a?e.type===1?ka(e,r,t,n,a):Da(e,r,t,n,a):o}function Fa(e,r,t,n){let a=[];for(let s=0,i=n.v.length;s<i;s++)a[s]=E(e,r,n.v[s]);return He(t,a,n.t,n.d)}function Ba(e,r,t,n,a){switch(a){case Object:return Gr(e,r,t,n,!1);case o:return Gr(e,r,t,n,!0);case Date:return ze(t,n);case Error:case EvalError:case RangeError:case ReferenceError:case SyntaxError:case TypeError:case URIError:return fn(e,r,t,n);case Number:case Boolean:case String:case BigInt:return Ea(e,r,t,n);case ArrayBuffer:return sr(e.base,t,n);case Int8Array:case Int16Array:case Int32Array:case Uint8Array:case Uint16Array:case Uint32Array:case Uint8ClampedArray:case Float32Array:case Float64Array:return Ia(e,r,t,n);case DataView:return Pa(e,r,t,n);case Map:return Ta(e,r,t,n);case Set:return Oa(e,r,t,n);default:break}if(a===Promise||n instanceof Promise)return _a(e,r,t,n);let s=e.base.features;if(s&32&&a===RegExp)return _e(t,n);if(s&16)switch(a){case BigInt64Array:case BigUint64Array:return Ra(e,r,t,n);default:break}if(s&1&&typeof AggregateError!="undefined"&&(a===AggregateError||n instanceof AggregateError))return xa(e,r,t,n);if(n instanceof Error)return fn(e,r,t,n);if(C in n||v in n)return Gr(e,r,t,n,!!a);throw new x(n)}function Va(e,r,t,n){if(Array.isArray(n))return Aa(e,r,t,n);if(Qe(n))return wa(e,r,t,n);if($e(n))return Fa(e,r,t,n);let a=n.constructor;if(a===Y)return E(e,r,n.replacement);let s=Sn(e,r,t,n);return s||Ba(e,r,t,n,a)}function Ma(e,r,t){let n=q(e.base,t);if(n.type!==0)return n.value;let a=Sn(e,r,n.value,t);if(a)return a;throw new x(t)}function E(e,r,t){if(r>=e.base.depthLimit)throw new M(e.base.depthLimit);switch(typeof t){case"boolean":return t?J:Z;case"undefined":return Ee;case"string":return X(t);case"number":return we(t);case"bigint":return he(t);case"object":{if(t){let n=q(e.base,t);return n.type===0?Va(e,r+1,n.value,t):n.value}return Ie}case"symbol":return I(e.base,t);case"function":return Ma(e,r,t);default:throw new x(t)}}function ue(e,r){try{return E(e,0,r)}catch(t){throw t instanceof _?t:new _(t)}}function se(e,r){e.state.initial?e.state.buffer.push(r):Qr(e,r,!1)}function Xr(e,r){if(e.state.onError)e.state.onError(r);else throw r instanceof _?r:new _(r)}function mn(e){e.state.onDone&&e.state.onDone();for(let r=0,t=e.state.cleanups.length;r<t;r++)e.state.cleanups[r]()}function Qr(e,r,t){try{e.state.onParse(r,t)}catch(n){Xr(e,n)}}function et(e){e.state.pending++}function ve(e){--e.state.pending<=0&&mn(e)}function K(e,r,t){try{return E(e,r,t)}catch(n){return Xr(e,n),o}}function rt(e,r){let t=K(e,0,r);t&&(Qr(e,t,!0),e.state.initial=!1,La(e,e.state),e.state.pending<=0&&mr(e))}function La(e,r){for(let t=0,n=r.buffer.length;t<n;t++)Qr(e,r.buffer[t],!1)}function mr(e){e.state.alive&&(mn(e),e.state.alive=!1)}function su(e,r={}){let t=A(r.plugins),n=ie(2,{plugins:t,disabledFeatures:r.disabledFeatures,refs:r.refs}),a=ue(n,e),s=cr({plugins:t,features:n.base.features,scopeId:r.scopeId,markedRefs:n.base.marked});return Sr(s,a)}async function iu(e,r={}){let t=A(r.plugins),n=te(2,{plugins:t,disabledFeatures:r.disabledFeatures,refs:r.refs}),a=await ne(n,e),s=cr({plugins:t,features:n.base.features,scopeId:r.scopeId,markedRefs:n.base.marked});return Sr(s,a)}function uu(e,r={}){let t=A(r.plugins),n=ie(2,{plugins:t,disabledFeatures:r.disabledFeatures,refs:r.refs});return ue(n,e)}async function lu(e,r={}){let t=A(r.plugins),n=te(2,{plugins:t,disabledFeatures:r.disabledFeatures,refs:r.refs});return await ne(n,e)}function pn(e,r){let t=A(r.plugins),n=Zr({plugins:t,refs:r.refs,disabledFeatures:r.disabledFeatures,onParse(a,s){let i=cr({plugins:t,features:n.base.features,scopeId:r.scopeId,markedRefs:n.base.marked}),u;try{u=Sr(i,a)}catch(l){r.onError&&r.onError(l);return}r.onSerialize(u,s)},onError:r.onError,onDone:r.onDone});return rt(n,e),mr.bind(null,n)}function cu(e,r){let t=A(r.plugins),n=Zr({plugins:t,refs:r.refs,disabledFeatures:r.disabledFeatures,depthLimit:r.depthLimit,onParse:r.onParse,onError:r.onError,onDone:r.onDone});return rt(n,e),mr.bind(null,n)}function fu(e,r){let t=A(r.plugins),n=Yt({plugins:t,refs:r.refs,features:r.features,disabledFeatures:r.disabledFeatures,depthLimit:r.depthLimit});return ir(n,e)}var pr=class{constructor(r){this.options=r;this.alive=!0;this.flushed=!1;this.done=!1;this.pending=0;this.cleanups=[];this.refs=new Map;this.keys=new Set;this.ids=0;this.plugins=A(r.plugins)}write(r,t){this.alive&&!this.flushed&&(this.pending++,this.keys.add(r),this.cleanups.push(pn(t,{plugins:this.plugins,scopeId:this.options.scopeId,refs:this.refs,disabledFeatures:this.options.disabledFeatures,onError:this.options.onError,onSerialize:(n,a)=>{this.alive&&this.options.onData(a?this.options.globalIdentifier+'["'+y(r)+'"]='+n:n)},onDone:()=>{this.alive&&(this.pending--,this.pending<=0&&this.flushed&&!this.done&&this.options.onDone&&(this.options.onDone(),this.done=!0))}})))}getNextID(){for(;this.keys.has(""+this.ids);)this.ids++;return""+this.ids}push(r){let t=this.getNextID();return this.write(t,r),t}flush(){this.alive&&(this.flushed=!0,this.pending<=0&&!this.done&&this.options.onDone&&(this.options.onDone(),this.done=!0))}close(){if(this.alive){for(let r=0,t=this.cleanups.length;r<t;r++)this.cleanups[r]();!this.done&&this.options.onDone&&(this.options.onDone(),this.done=!0),this.alive=!1}}};function Eu(e,r={}){let t=A(r.plugins),n=ie(1,{plugins:t,disabledFeatures:r.disabledFeatures}),a=ue(n,e),s=lr({plugins:t,features:n.base.features,markedRefs:n.base.marked});return fr(s,a)}async function Iu(e,r={}){let t=A(r.plugins),n=te(1,{plugins:t,disabledFeatures:r.disabledFeatures}),a=await ne(n,e),s=lr({plugins:t,features:n.base.features,markedRefs:n.base.marked});return fr(s,a)}function Ru(e){return(0,eval)(e)}function Pu(e,r={}){let t=A(r.plugins),n=ie(1,{plugins:t,disabledFeatures:r.disabledFeatures});return{t:ue(n,e),f:n.base.features,m:Array.from(n.base.marked)}}async function xu(e,r={}){let t=A(r.plugins),n=te(1,{plugins:t,disabledFeatures:r.disabledFeatures});return{t:await ne(n,e),f:n.base.features,m:Array.from(n.base.marked)}}function Tu(e,r={}){let t=A(r.plugins),n=lr({plugins:t,features:e.f,markedRefs:e.m});return fr(n,e.t)}function Ou(e,r={}){var i;let t=A(r.plugins),n=r.disabledFeatures||0,a=(i=e.f)!=null?i:63,s=jt({plugins:t,markedRefs:e.m,features:a&~n,disabledFeatures:n});return ir(s,e.t)}export{L as Feature,Y as OpaqueReference,pr as Serializer,Nt as SerovalConflictedNodeIdError,M as SerovalDepthLimitError,Je as SerovalDeserializationError,fe as SerovalError,O as SerovalMalformedNodeError,V as SerovalMissingInstanceError,Q as SerovalMissingPluginError,Pe as SerovalMissingReferenceError,xe as SerovalMissingReferenceForIdError,oe as SerovalMode,_ as SerovalParserError,Pr as SerovalSerializationError,Ze as SerovalUnknownTypedArrayError,z as SerovalUnsupportedNodeError,x as SerovalUnsupportedTypeError,Tu as compileJSON,ai as createPlugin,Nn as createReference,re as createStream,su as crossSerialize,iu as crossSerializeAsync,pn as crossSerializeStream,Ru as deserialize,fu as fromCrossJSON,Ou as fromJSON,yn as getCrossReferenceHeader,A as resolvePlugins,Eu as serialize,Iu as serializeAsync,uu as toCrossJSON,lu as toCrossJSONAsync,cu as toCrossJSONStream,Pu as toJSON,xu as toJSONAsync};

dist/types/core/base-primitives.d.ts

-import type { WellKnownSymbols } from './constants';
-import type { SerovalAggregateErrorNode, SerovalArrayNode, SerovalAsyncIteratorFactoryInstanceNode, SerovalBigIntNode, SerovalBigIntTypedArrayNode, SerovalBoxedNode, SerovalConstantNode, SerovalDataViewNode, SerovalDateNode, SerovalErrorNode, SerovalIndexedValueNode, SerovalIteratorFactoryInstanceNode, SerovalNode, SerovalNodeWithID, SerovalNumberNode, SerovalObjectRecordNode, SerovalPluginNode, SerovalReferenceNode, SerovalRegExpNode, SerovalSequenceNode, SerovalSetNode, SerovalStreamConstructorNode, SerovalStreamNextNode, SerovalStreamReturnNode, SerovalStreamThrowNode, SerovalStringNode, SerovalTypedArrayNode, SerovalWKSymbolNode } from './types';
-import type { BigIntTypedArrayValue, TypedArrayValue } from './utils/typed-array';
-export declare function createNumberNode(value: number): SerovalConstantNode | SerovalNumberNode;
-export declare function createStringNode(value: string): SerovalStringNode;
-export declare function createBigIntNode(current: bigint): SerovalBigIntNode;
-export declare function createIndexedValueNode(id: number): SerovalIndexedValueNode;
-export declare function createDateNode(id: number, current: Date): SerovalDateNode;
-export declare function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode;
-export declare function createWKSymbolNode(id: number, current: WellKnownSymbols): SerovalWKSymbolNode;
-export declare function createReferenceNode<T>(id: number, ref: T): SerovalReferenceNode;
-export declare function createPluginNode(id: number, tag: string, value: Record<string, SerovalNode>): SerovalPluginNode;
-export declare function createArrayNode(id: number, current: unknown[], parsedItems: SerovalArrayNode['a']): SerovalArrayNode;
-export declare function createBoxedNode(id: number, boxed: SerovalNode): SerovalBoxedNode;
-export declare function createTypedArrayNode(id: number, current: TypedArrayValue, buffer: SerovalNode): SerovalTypedArrayNode;
-export declare function createBigIntTypedArrayNode(id: number, current: BigIntTypedArrayValue, buffer: SerovalNode): SerovalBigIntTypedArrayNode;
-export declare function createDataViewNode(id: number, current: DataView, buffer: SerovalNode): SerovalDataViewNode;
-export declare function createErrorNode(id: number, current: Error, options: SerovalObjectRecordNode | undefined): SerovalErrorNode;
-export declare function createAggregateErrorNode(id: number, current: AggregateError, options: SerovalObjectRecordNode | undefined): SerovalAggregateErrorNode;
-export declare function createSetNode(id: number, items: SerovalNode[]): SerovalSetNode;
-export declare function createIteratorFactoryInstanceNode(factory: SerovalNodeWithID, items: SerovalNodeWithID): SerovalIteratorFactoryInstanceNode;
-export declare function createAsyncIteratorFactoryInstanceNode(factory: SerovalNodeWithID, items: SerovalNodeWithID): SerovalAsyncIteratorFactoryInstanceNode;
-export declare function createStreamConstructorNode(id: number, factory: SerovalNodeWithID, sequence: SerovalNode[]): SerovalStreamConstructorNode;
-export declare function createStreamNextNode(id: number, parsed: SerovalNode): SerovalStreamNextNode;
-export declare function createStreamThrowNode(id: number, parsed: SerovalNode): SerovalStreamThrowNode;
-export declare function createStreamReturnNode(id: number, parsed: SerovalNode): SerovalStreamReturnNode;
-export declare function createSequenceNode(id: number, sequence: SerovalNode[], throwAt: number, doneAt: number): SerovalSequenceNode;
-//# sourceMappingURL=base-primitives.d.ts.map

dist/types/core/base-primitives.d.ts.map

-{"version":3,"file":"base-primitives.d.ts","sourceRoot":"","sources":["../../../src/core/base-primitives.ts"],"names":[],"mappings":"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"}

dist/types/core/compat.d.ts

-/**
- * References
- * - https://compat-table.github.io/compat-table/es6/
- * - MDN
- */
-export declare enum Feature {
-    AggregateError = 1,
-    ArrowFunction = 2,
-    ErrorPrototypeStack = 4,
-    ObjectAssign = 8,
-    BigIntTypedArray = 16,
-    RegExp = 32
-}
-export declare const ALL_ENABLED: number;
-//# sourceMappingURL=compat.d.ts.map

dist/types/core/compat.d.ts.map

-{"version":3,"file":"compat.d.ts","sourceRoot":"","sources":["../../../src/core/compat.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,oBAAY,OAAO;IACjB,cAAc,IAAO;IAErB,aAAa,IAAO;IACpB,mBAAmB,IAAO;IAC1B,YAAY,IAAO;IACnB,gBAAgB,KAAO;IACvB,MAAM,KAAO;CACd;AAED,eAAO,MAAM,WAAW,QAMR,CAAC"}

dist/types/core/constants.d.ts

-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 declare const enum SerovalConstant {
-    Null = 0,
-    Undefined = 1,
-    True = 2,
-    False = 3,
-    NegZero = 4,
-    Inf = 5,
-    NegInf = 6,
-    Nan = 7
-}
-export declare 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,
-    Sequence = 35
-}
-export declare const enum SerovalObjectFlags {
-    None = 0,
-    NonExtensible = 1,
-    Sealed = 2,
-    Frozen = 3
-}
-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>;
-export declare const CONSTANT_STRING: Record<SerovalConstant, string>;
-export declare const NIL: undefined;
-export declare const CONSTANT_VAL: Record<SerovalConstant, unknown>;
-export declare const enum ErrorConstructorTag {
-    Error = 0,
-    EvalError = 1,
-    RangeError = 2,
-    ReferenceError = 3,
-    SyntaxError = 4,
-    TypeError = 5,
-    URIError = 6
-}
-export declare const ERROR_CONSTRUCTOR_STRING: Record<ErrorConstructorTag, string>;
-type ErrorConstructors = ErrorConstructor | EvalErrorConstructor | RangeErrorConstructor | ReferenceErrorConstructor | SyntaxErrorConstructor | TypeErrorConstructor | URIErrorConstructor;
-export declare const ERROR_CONSTRUCTOR: Record<ErrorConstructorTag, ErrorConstructors>;
-export {};
-//# sourceMappingURL=constants.d.ts.map

dist/types/core/constants.d.ts.map

-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/core/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,SAAS,EACT,aAAa,EACb,WAAW,EACX,UAAU,EACV,WAAW,EACX,SAAS,EACT,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EAChB,MAAM,WAAW,CAAC;AAEnB,0BAAkB,eAAe;IAC/B,IAAI,IAAI;IACR,SAAS,IAAI;IACb,IAAI,IAAI;IACR,KAAK,IAAI;IACT,OAAO,IAAI;IACX,GAAG,IAAI;IACP,MAAM,IAAI;IACV,GAAG,IAAI;CACR;AAED,0BAAkB,eAAe;IAC/B,MAAM,IAAI;IACV,MAAM,IAAI;IACV,QAAQ,IAAI;IACZ,MAAM,IAAI;IACV,YAAY,IAAI;IAChB,IAAI,IAAI;IACR,MAAM,IAAI;IACV,GAAG,IAAI;IACP,GAAG,IAAI;IACP,KAAK,IAAI;IACT,MAAM,KAAK;IACX,eAAe,KAAK;IACpB,OAAO,KAAK;IACZ,KAAK,KAAK;IACV,cAAc,KAAK;IACnB,UAAU,KAAK;IACf,gBAAgB,KAAK;IACrB,QAAQ,KAAK;IACb,SAAS,KAAK;IACd,WAAW,KAAK;IAChB,QAAQ,KAAK;IACb,KAAK,KAAK;IACV,kBAAkB,KAAK;IACvB,cAAc,KAAK;IACnB,cAAc,KAAK;IACnB,MAAM,KAAK;IACX,gBAAgB,KAAK;IACrB,eAAe,KAAK;IACpB,uBAAuB,KAAK;IAC5B,oBAAoB,KAAK;IACzB,4BAA4B,KAAK;IACjC,iBAAiB,KAAK;IACtB,UAAU,KAAK;IACf,WAAW,KAAK;IAChB,YAAY,KAAK;IACjB,QAAQ,KAAK;CACd;AAED,0BAAkB,kBAAkB;IAClC,IAAI,IAAI;IACR,aAAa,IAAI;IACjB,MAAM,IAAI;IACV,MAAM,IAAI;CACX;AAED,0BAAkB,OAAO;IACvB,aAAa,IAAI;IACjB,WAAW,IAAI;IACf,kBAAkB,IAAI;IACtB,QAAQ,IAAI;IACZ,KAAK,IAAI;IACT,QAAQ,IAAI;IACZ,OAAO,IAAI;IACX,MAAM,IAAI;IACV,OAAO,IAAI;IACX,KAAK,IAAI;IACT,WAAW,KAAK;IAChB,WAAW,KAAK;IAChB,WAAW,KAAK;CACjB;AAED,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAcjD,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;CAc1B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,cAAc,CAAC;AAE3D,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,CAcxD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAS3D,CAAC;AAEF,eAAO,MAAM,GAAG,WAAS,CAAC;AAE1B,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,eAAe,EAAE,OAAO,CASzD,CAAC;AAEF,0BAAkB,mBAAmB;IACnC,KAAK,IAAI;IACT,SAAS,IAAI;IACb,UAAU,IAAI;IACd,cAAc,IAAI;IAClB,WAAW,IAAI;IACf,SAAS,IAAI;IACb,QAAQ,IAAI;CACb;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAQxE,CAAC;AAEF,KAAK,iBAAiB,GAClB,gBAAgB,GAChB,oBAAoB,GACpB,qBAAqB,GACrB,yBAAyB,GACzB,sBAAsB,GACtB,oBAAoB,GACpB,mBAAmB,CAAC;AAExB,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,mBAAmB,EAAE,iBAAiB,CAS1E,CAAC"}

dist/types/core/constructors.d.ts

-import type { Sequence } from './sequence';
-import type { Stream } from './stream';
-type SpecialPromise = Promise<unknown> & {
-    s?: 1 | 2;
-    v?: unknown;
-};
-export interface PromiseConstructorResolver {
-    p: SpecialPromise;
-    s: (value: unknown) => void;
-    f: (value: unknown) => void;
-}
-export declare const PROMISE_CONSTRUCTOR: () => PromiseConstructorResolver;
-export declare const PROMISE_SUCCESS: (resolver: PromiseConstructorResolver, data: unknown) => void;
-export declare const PROMISE_FAILURE: (resolver: PromiseConstructorResolver, data: unknown) => void;
-export declare const SERIALIZED_PROMISE_CONSTRUCTOR: string;
-export declare const SERIALIZED_PROMISE_SUCCESS: string;
-export declare const SERIALIZED_PROMISE_FAILURE: string;
-interface StreamListener<T> {
-    next(value: T): void;
-    throw(value: unknown): void;
-    return(value: T): void;
-}
-export declare const STREAM_CONSTRUCTOR: () => {
-    __SEROVAL_STREAM__: boolean;
-    on: (listener: StreamListener<unknown>) => () => void;
-    next: (value: unknown) => void;
-    throw: (value: unknown) => void;
-    return: (value: unknown) => void;
-};
-export declare const SERIALIZED_STREAM_CONSTRUCTOR: string;
-export declare const ITERATOR_CONSTRUCTOR: (symbol: symbol) => (sequence: Sequence) => () => {
-    [x: symbol]: () => any;
-    next: () => {
-        done: boolean;
-        value: unknown;
-    };
-};
-export declare const SERIALIZED_ITERATOR_CONSTRUCTOR: string;
-export declare const ASYNC_ITERATOR_CONSTRUCTOR: (symbol: symbol, createPromise: typeof PROMISE_CONSTRUCTOR) => (stream: Stream<unknown>) => () => {
-    [x: symbol]: () => any;
-    next: () => SpecialPromise | {
-        done: boolean;
-        value: unknown;
-    };
-};
-export declare const SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR: string;
-export declare const ARRAY_BUFFER_CONSTRUCTOR: (b64: string) => ArrayBufferLike;
-export declare const SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR: string;
-export {};
-//# sourceMappingURL=constructors.d.ts.map

dist/types/core/constructors.d.ts.map

-{"version":3,"file":"constructors.d.ts","sourceRoot":"","sources":["../../../src/core/constructors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,KAAK,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG;IAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAAC,CAAC,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEpE,MAAM,WAAW,0BAA0B;IACzC,CAAC,EAAE,cAAc,CAAC;IAClB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC5B,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7B;AAED,eAAO,MAAM,mBAAmB,QAAO,0BAWtC,CAAC;AAEF,eAAO,MAAM,eAAe,aAChB,0BAA0B,QAC9B,OAAO,KACZ,IAIF,CAAC;AAEF,eAAO,MAAM,eAAe,aAChB,0BAA0B,QAC9B,OAAO,KACZ,IAIF,CAAC;AAEF,eAAO,MAAM,8BAA8B,QACK,CAAC;AACjD,eAAO,MAAM,0BAA0B,QACK,CAAC;AAC7C,eAAO,MAAM,0BAA0B,QACK,CAAC;AAE7C,UAAU,cAAc,CAAC,CAAC;IACxB,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACxB;AAED,eAAO,MAAM,kBAAkB;;mBA+CZ,eAAe,OAAO,CAAC;kBACxB,OAAO;mBAMN,OAAO;oBASN,OAAO;CAU1B,CAAC;AAEF,eAAO,MAAM,6BAA6B,QACK,CAAC;AAEhD,eAAO,MAAM,oBAAoB,WACtB,MAAM,gBAAgB,QAAQ;;;;;;CAuBtC,CAAC;AAEJ,eAAO,MAAM,+BAA+B,QACK,CAAC;AAElD,eAAO,MAAM,0BAA0B,WAC5B,MAAM,iBAAiB,0BAA0B,cACjD,OAAO,OAAO,CAAC;;;;;;CAoFvB,CAAC;AAEJ,eAAO,MAAM,qCAAqC,QACK,CAAC;AAExD,eAAO,MAAM,wBAAwB,QAAS,MAAM,oBAQnD,CAAC;AAEF,eAAO,MAAM,mCAAmC,QACK,CAAC"}

dist/types/core/context/async-parser.d.ts

-import type { SerovalMode } from '../plugin';
-import type { SerovalNode } from '../types';
-import type { BaseParserContext, BaseParserContextOptions } from './parser';
-export type AsyncParserContextOptions = BaseParserContextOptions;
-export interface AsyncParserContext {
-    base: BaseParserContext;
-    child: AsyncParsePluginContext | undefined;
-}
-export declare function createAsyncParserContext(mode: SerovalMode, options: AsyncParserContextOptions): AsyncParserContext;
-export declare class AsyncParsePluginContext {
-    private _p;
-    private depth;
-    constructor(_p: AsyncParserContext, depth: number);
-    parse<T>(current: T): Promise<SerovalNode>;
-}
-export declare function parseObjectAsync(ctx: AsyncParserContext, depth: number, id: number, current: object): Promise<SerovalNode>;
-export declare function parseFunctionAsync(ctx: AsyncParserContext, depth: number, current: unknown): Promise<SerovalNode>;
-export declare function parseAsync<T>(ctx: AsyncParserContext, depth: number, current: T): Promise<SerovalNode>;
-export declare function parseTopAsync<T>(ctx: AsyncParserContext, current: T): Promise<SerovalNode>;
-//# sourceMappingURL=async-parser.d.ts.map

dist/types/core/context/async-parser.d.ts.map

-{"version":3,"file":"async-parser.d.ts","sourceRoot":"","sources":["../../../../src/core/context/async-parser.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAgB7C,OAAO,KAAK,EAQV,WAAW,EAYZ,MAAM,UAAU,CAAC;AAOlB,OAAO,KAAK,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAoB5E,MAAM,MAAM,yBAAyB,GAAG,wBAAwB,CAAC;AAEjE,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,iBAAiB,CAAC;IACxB,KAAK,EAAE,uBAAuB,GAAG,SAAS,CAAC;CAC5C;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,yBAAyB,GACjC,kBAAkB,CAKpB;AAED,qBAAa,uBAAuB;IAEhC,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,KAAK;gBADL,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,MAAM;IAGvB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;CAG3C;AAqVD,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,kBAAkB,EACvB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,CAuItB;AAED,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,kBAAkB,EACvB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,WAAW,CAAC,CAUtB;AAED,wBAAsB,UAAU,CAAC,CAAC,EAChC,GAAG,EAAE,kBAAkB,EACvB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,WAAW,CAAC,CA+BtB;AAED,wBAAsB,aAAa,CAAC,CAAC,EACnC,GAAG,EAAE,kBAAkB,EACvB,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,WAAW,CAAC,CAQtB"}

dist/types/core/context/deserializer.d.ts

-import { SerovalNodeType } from '../constants';
-import type { PluginAccessOptions } from '../plugin';
-import { SerovalMode } from '../plugin';
-import type { SerovalNode } from '../types';
-export interface BaseDeserializerContextOptions extends PluginAccessOptions {
-    refs?: Map<number, unknown>;
-    features?: number;
-    disabledFeatures?: number;
-    depthLimit?: number;
-}
-export interface BaseDeserializerContext extends PluginAccessOptions {
-    readonly mode: SerovalMode;
-    /**
-     * Mapping ids to values
-     */
-    refs: Map<number, unknown> & {
-        types: Map<number, SerovalNodeType>;
-    };
-    features: number;
-    depthLimit: number;
-}
-export declare function createBaseDeserializerContext(mode: SerovalMode, options: BaseDeserializerContextOptions): BaseDeserializerContext;
-export interface VanillaDeserializerContextOptions extends Omit<BaseDeserializerContextOptions, 'refs'> {
-    markedRefs: number[] | Set<number>;
-}
-export interface VanillaDeserializerState {
-    marked: Set<number>;
-}
-export interface VanillaDeserializerContext {
-    mode: SerovalMode.Vanilla;
-    base: BaseDeserializerContext;
-    child: DeserializePluginContext | undefined;
-    state: VanillaDeserializerState;
-}
-export declare function createVanillaDeserializerContext(options: VanillaDeserializerContextOptions): VanillaDeserializerContext;
-export interface CrossDeserializerContext {
-    mode: SerovalMode.Cross;
-    base: BaseDeserializerContext;
-    child: DeserializePluginContext | undefined;
-}
-export type CrossDeserializerContextOptions = BaseDeserializerContextOptions;
-export declare function createCrossDeserializerContext(options: CrossDeserializerContextOptions): CrossDeserializerContext;
-type DeserializerContext = VanillaDeserializerContext | CrossDeserializerContext;
-export declare class DeserializePluginContext {
-    private _p;
-    private depth;
-    constructor(_p: DeserializerContext, depth: number);
-    deserialize<T>(node: SerovalNode): T;
-}
-export declare function deserializeTop(ctx: DeserializerContext, node: SerovalNode): unknown;
-export {};
-//# sourceMappingURL=deserializer.d.ts.map

dist/types/core/context/deserializer.d.ts.map

-{"version":3,"file":"deserializer.d.ts","sourceRoot":"","sources":["../../../../src/core/context/deserializer.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,eAAe,EAGhB,MAAM,cAAc,CAAC;AActB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAMxC,OAAO,KAAK,EAcV,WAAW,EAkBZ,MAAM,UAAU,CAAC;AA4BlB,MAAM,WAAW,8BAA+B,SAAQ,mBAAmB;IACzE,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,uBAAwB,SAAQ,mBAAmB;IAClE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B;;OAEG;IACH,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;KAAE,CAAC;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAID,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,8BAA8B,GACtC,uBAAuB,CAczB;AAED,MAAM,WAAW,iCACf,SAAQ,IAAI,CAAC,8BAA8B,EAAE,MAAM,CAAC;IACpD,UAAU,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACrB;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC;IAC1B,IAAI,EAAE,uBAAuB,CAAC;IAC9B,KAAK,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC5C,KAAK,EAAE,wBAAwB,CAAC;CACjC;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,iCAAiC,GACzC,0BAA0B,CAS5B;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,WAAW,CAAC,KAAK,CAAC;IACxB,IAAI,EAAE,uBAAuB,CAAC;IAC9B,KAAK,EAAE,wBAAwB,GAAG,SAAS,CAAC;CAC7C;AAED,MAAM,MAAM,+BAA+B,GAAG,8BAA8B,CAAC;AAE7E,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,+BAA+B,GACvC,wBAAwB,CAM1B;AAED,KAAK,mBAAmB,GACpB,0BAA0B,GAC1B,wBAAwB,CAAC;AAE7B,qBAAa,wBAAwB;IAEjC,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,KAAK;gBADL,EAAE,EAAE,mBAAmB,EACvB,KAAK,EAAE,MAAM;IAGvB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,GAAG,CAAC;CAGrC;AA2nBD,wBAAgB,cAAc,CAC5B,GAAG,EAAE,mBAAmB,EACxB,IAAI,EAAE,WAAW,GAChB,OAAO,CAMT"}

dist/types/core/context/parser.d.ts

-import type { PluginAccessOptions, SerovalMode } from '../plugin';
-import { SpecialReference } from '../special-reference';
-import type { SerovalArrayBufferNode, SerovalAsyncIteratorFactoryNode, SerovalIndexedValueNode, SerovalIteratorFactoryNode, SerovalMapNode, SerovalNode, SerovalNullConstructorNode, SerovalObjectNode, SerovalObjectRecordNode, SerovalPromiseConstructorNode, SerovalReferenceNode, SerovalSpecialReferenceNode, SerovalWKSymbolNode } from '../types';
-export interface BaseParserContextOptions extends PluginAccessOptions {
-    disabledFeatures?: number;
-    refs?: Map<unknown, number>;
-    depthLimit?: number;
-}
-export declare const enum ParserNodeType {
-    Fresh = 0,
-    Indexed = 1,
-    Referenced = 2
-}
-export interface FreshNode {
-    type: ParserNodeType.Fresh;
-    value: number;
-}
-export interface IndexedNode {
-    type: ParserNodeType.Indexed;
-    value: SerovalIndexedValueNode;
-}
-export interface ReferencedNode {
-    type: ParserNodeType.Referenced;
-    value: SerovalReferenceNode;
-}
-type ObjectNode = FreshNode | IndexedNode | ReferencedNode;
-export interface BaseParserContext extends PluginAccessOptions {
-    readonly mode: SerovalMode;
-    marked: Set<number>;
-    refs: Map<unknown, number>;
-    features: number;
-    depthLimit: number;
-}
-export declare function createBaseParserContext(mode: SerovalMode, options: BaseParserContextOptions): BaseParserContext;
-/**
- * Ensures that the value (based on an identifier) has been visited by the parser.
- * @param ctx
- * @param id
- */
-export declare function markParserRef(ctx: BaseParserContext, id: number): void;
-export declare function isParserRefMarked(ctx: BaseParserContext, id: number): boolean;
-/**
- * Creates an identifier for a value
- * @param ctx
- * @param current
- */
-export declare function createIndexForValue<T>(ctx: BaseParserContext, current: T): number;
-export declare function getNodeForIndexedValue<T>(ctx: BaseParserContext, current: T): FreshNode | IndexedNode;
-export declare function getReferenceNode<T>(ctx: BaseParserContext, current: T): ObjectNode;
-/**
- * Parsing methods
- */
-export declare function parseWellKnownSymbol(ctx: BaseParserContext, current: symbol): SerovalIndexedValueNode | SerovalWKSymbolNode | SerovalReferenceNode;
-export declare function parseSpecialReference(ctx: BaseParserContext, ref: SpecialReference): SerovalIndexedValueNode | SerovalSpecialReferenceNode;
-export declare function parseIteratorFactory(ctx: BaseParserContext): SerovalIndexedValueNode | SerovalIteratorFactoryNode;
-export declare function parseAsyncIteratorFactory(ctx: BaseParserContext): SerovalIndexedValueNode | SerovalAsyncIteratorFactoryNode;
-export declare function createObjectNode(id: number, current: Record<string, unknown>, empty: boolean, record: SerovalObjectRecordNode): SerovalObjectNode | SerovalNullConstructorNode;
-export declare function createMapNode(ctx: BaseParserContext, id: number, k: SerovalNode[], v: SerovalNode[]): SerovalMapNode;
-export declare function createPromiseConstructorNode(ctx: BaseParserContext, id: number, resolver: number): SerovalPromiseConstructorNode;
-export declare function createArrayBufferNode(ctx: BaseParserContext, id: number, current: ArrayBuffer): SerovalArrayBufferNode;
-export {};
-//# sourceMappingURL=parser.d.ts.map

dist/types/core/context/parser.d.ts.map

-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/core/context/parser.ts"],"names":[],"mappings":"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"}

dist/types/core/context/serializer.d.ts

-import { SerovalObjectFlags } from '../constants';
-import type { PluginAccessOptions } from '../plugin';
-import { SerovalMode } from '../plugin';
-import type { SerovalNode } from '../types';
-declare const enum AssignmentType {
-    Index = 0,
-    Add = 1,
-    Set = 2,
-    Delete = 3,
-    Define = 4
-}
-interface IndexAssignment {
-    t: AssignmentType.Index;
-    s: string;
-    k: undefined;
-    v: string;
-}
-interface SetAssignment {
-    t: AssignmentType.Set;
-    s: string;
-    k: string;
-    v: string;
-}
-interface AddAssignment {
-    t: AssignmentType.Add;
-    s: string;
-    k: undefined;
-    v: string;
-}
-interface DeleteAssignment {
-    t: AssignmentType.Delete;
-    s: string;
-    k: string;
-    v: undefined;
-}
-interface DefineAssignment {
-    t: AssignmentType.Define;
-    s: string;
-    k: string;
-    v: undefined;
-}
-type Assignment = IndexAssignment | AddAssignment | SetAssignment | DeleteAssignment | DefineAssignment;
-export interface FlaggedObject {
-    type: SerovalObjectFlags;
-    value: string;
-}
-export interface BaseSerializerContextOptions extends PluginAccessOptions {
-    features: number;
-    markedRefs: number[] | Set<number>;
-}
-export interface BaseSerializerContext extends PluginAccessOptions {
-    readonly mode: SerovalMode;
-    features: number;
-    stack: number[];
-    /**
-     * Array of object mutations
-     */
-    flags: FlaggedObject[];
-    /**
-     * Array of assignments to be done (used for recursion)
-     */
-    assignments: Assignment[];
-    /**
-     * Refs that are...referenced
-     */
-    marked: Set<number>;
-}
-export interface CrossContextOptions {
-    scopeId?: string;
-}
-export declare function createBaseSerializerContext(mode: SerovalMode, options: BaseSerializerContextOptions): BaseSerializerContext;
-export interface VanillaSerializerState {
-    valid: Map<number, number>;
-    vars: string[];
-}
-export interface VanillaSerializerContext {
-    mode: SerovalMode.Vanilla;
-    base: BaseSerializerContext;
-    state: VanillaSerializerState;
-    child: SerializePluginContext | undefined;
-}
-export type VanillaSerializerContextOptions = BaseSerializerContextOptions;
-export declare function createVanillaSerializerContext(options: VanillaSerializerContextOptions): VanillaSerializerContext;
-export interface CrossSerializerContext {
-    mode: SerovalMode.Cross;
-    base: BaseSerializerContext;
-    state: CrossContextOptions;
-    child: SerializePluginContext | undefined;
-}
-export interface CrossSerializerContextOptions extends BaseSerializerContextOptions, CrossContextOptions {
-}
-export declare function createCrossSerializerContext(options: CrossSerializerContextOptions): CrossSerializerContext;
-type SerializerContext = VanillaSerializerContext | CrossSerializerContext;
-export declare class SerializePluginContext {
-    private _p;
-    constructor(_p: SerializerContext);
-    serialize(node: SerovalNode): string;
-}
-export declare function serializeRoot(ctx: SerializerContext, node: SerovalNode): string;
-export declare function serializeTopVanilla(ctx: VanillaSerializerContext, tree: SerovalNode): string;
-export declare function serializeTopCross(ctx: CrossSerializerContext, tree: SerovalNode): string;
-export {};
-//# sourceMappingURL=serializer.d.ts.map

dist/types/core/context/serializer.d.ts.map

-{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../../src/core/context/serializer.ts"],"names":[],"mappings":"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"}

dist/types/core/context/sync-parser.d.ts

-import { SerovalMode } from '../plugin';
-import type { SerovalNode } from '../types';
-import type { BaseParserContext, BaseParserContextOptions } from './parser';
-export type SyncParserContextOptions = BaseParserContextOptions;
-declare const enum ParserMode {
-    Sync = 1,
-    Stream = 2
-}
-export interface SyncParserContext {
-    type: ParserMode.Sync;
-    base: BaseParserContext;
-    child: SyncParsePluginContext | undefined;
-}
-export declare function createSyncParserContext(mode: SerovalMode, options: SyncParserContextOptions): SyncParserContext;
-export declare class SyncParsePluginContext {
-    private _p;
-    private depth;
-    constructor(_p: SyncParserContext, depth: number);
-    parse<T>(current: T): SerovalNode;
-}
-export interface StreamParserContextOptions extends SyncParserContextOptions {
-    onParse: (node: SerovalNode, initial: boolean) => void;
-    onError?: (error: unknown) => void;
-    onDone?: () => void;
-}
-export interface StreamParserContext {
-    type: ParserMode.Stream;
-    base: BaseParserContext;
-    state: StreamParserState;
-}
-export declare class StreamParsePluginContext {
-    private _p;
-    private depth;
-    constructor(_p: StreamParserContext, depth: number);
-    parse<T>(current: T): SerovalNode;
-    parseWithError<T>(current: T): SerovalNode | undefined;
-    isAlive(): boolean;
-    pushPendingState(): void;
-    popPendingState(): void;
-    onParse(node: SerovalNode): void;
-    onError(error: unknown): void;
-    addCleanup(callback: () => void): void;
-}
-interface StreamParserState {
-    alive: boolean;
-    pending: number;
-    initial: boolean;
-    buffer: SerovalNode[];
-    onParse: (node: SerovalNode, initial: boolean) => void;
-    onError?: (error: unknown) => void;
-    onDone?: () => void;
-    cleanups: (() => void)[];
-}
-export declare function createStreamParserContext(options: StreamParserContextOptions): StreamParserContext;
-type SOSParserContext = SyncParserContext | StreamParserContext;
-export declare function parseSOS<T>(ctx: SOSParserContext, depth: number, current: T): SerovalNode;
-export declare function parseTop<T>(ctx: SyncParserContext, current: T): SerovalNode;
-export declare function startStreamParse<T>(ctx: StreamParserContext, current: T): void;
-export declare function destroyStreamParse(ctx: StreamParserContext): void;
-export {};
-//# sourceMappingURL=sync-parser.d.ts.map

dist/types/core/context/sync-parser.d.ts.map

-{"version":3,"file":"sync-parser.d.ts","sourceRoot":"","sources":["../../../../src/core/context/sync-parser.ts"],"names":[],"mappings":"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"}

dist/types/core/cross/index.d.ts

-import type { AsyncParserContextOptions } from '../context/async-parser';
-import type { CrossDeserializerContextOptions } from '../context/deserializer';
-import type { CrossContextOptions } from '../context/serializer';
-import type { StreamParserContextOptions, SyncParserContextOptions } from '../context/sync-parser';
-import type { SerovalNode } from '../types';
-export interface CrossSerializeOptions extends SyncParserContextOptions, CrossContextOptions {
-}
-export declare function crossSerialize<T>(source: T, options?: CrossSerializeOptions): string;
-export interface CrossSerializeAsyncOptions extends AsyncParserContextOptions, CrossContextOptions {
-}
-export declare function crossSerializeAsync<T>(source: T, options?: CrossSerializeAsyncOptions): Promise<string>;
-export type ToCrossJSONOptions = SyncParserContextOptions;
-export declare function toCrossJSON<T>(source: T, options?: ToCrossJSONOptions): SerovalNode;
-export type ToCrossJSONAsyncOptions = AsyncParserContextOptions;
-export declare function toCrossJSONAsync<T>(source: T, options?: ToCrossJSONAsyncOptions): Promise<SerovalNode>;
-export interface CrossSerializeStreamOptions extends Omit<StreamParserContextOptions, 'onParse'>, CrossContextOptions {
-    onSerialize: (data: string, initial: boolean) => void;
-}
-export declare function crossSerializeStream<T>(source: T, options: CrossSerializeStreamOptions): () => void;
-export type ToCrossJSONStreamOptions = StreamParserContextOptions;
-export declare function toCrossJSONStream<T>(source: T, options: ToCrossJSONStreamOptions): () => void;
-export type FromCrossJSONOptions = CrossDeserializerContextOptions;
-export declare function fromCrossJSON<T>(source: SerovalNode, options: FromCrossJSONOptions): T;
-//# sourceMappingURL=index.d.ts.map

dist/types/core/cross/index.d.ts.map

-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/cross/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAKzE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAK/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAKjE,OAAO,KAAK,EACV,0BAA0B,EAC1B,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAShC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,WAAW,qBACf,SAAQ,wBAAwB,EAC9B,mBAAmB;CAAG;AAE1B,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,qBAA0B,GAClC,MAAM,CAeR;AAED,MAAM,WAAW,0BACf,SAAQ,yBAAyB,EAC/B,mBAAmB;CAAG;AAE1B,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;AAE1D,wBAAgB,WAAW,CAAC,CAAC,EAC3B,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,kBAAuB,GAC/B,WAAW,CAQb;AAED,MAAM,MAAM,uBAAuB,GAAG,yBAAyB,CAAC;AAEhE,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,WAAW,CAAC,CAQtB;AAED,MAAM,WAAW,2BACf,SAAQ,IAAI,CAAC,0BAA0B,EAAE,SAAS,CAAC,EACjD,mBAAmB;IACrB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CACvD;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,2BAA2B,GACnC,MAAM,IAAI,CAkCZ;AAED,MAAM,MAAM,wBAAwB,GAAG,0BAA0B,CAAC;AAElE,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,wBAAwB,GAChC,MAAM,IAAI,CAeZ;AAED,MAAM,MAAM,oBAAoB,GAAG,+BAA+B,CAAC;AAEnE,wBAAgB,aAAa,CAAC,CAAC,EAC7B,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,oBAAoB,GAC5B,CAAC,CAUH"}

dist/types/core/errors.d.ts

-import type { SerovalNode } from './types';
-export declare class SerovalError extends Error {
-    cause: unknown;
-    constructor(type: string, cause: unknown);
-}
-export declare class SerovalParserError extends SerovalError {
-    constructor(cause: unknown);
-}
-export declare class SerovalSerializationError extends SerovalError {
-    constructor(cause: unknown);
-}
-export declare class SerovalDeserializationError extends SerovalError {
-    constructor(cause: unknown);
-}
-export declare class SerovalUnsupportedTypeError extends Error {
-    value: unknown;
-    constructor(value: unknown);
-}
-export declare class SerovalUnsupportedNodeError extends Error {
-    constructor(node: SerovalNode);
-}
-export declare class SerovalMissingPluginError extends Error {
-    constructor(tag: string);
-}
-export declare class SerovalMissingInstanceError extends Error {
-    constructor(tag: string);
-}
-export declare class SerovalMissingReferenceError extends Error {
-    value: unknown;
-    constructor(value: unknown);
-}
-export declare class SerovalMissingReferenceForIdError extends Error {
-    constructor(id: string);
-}
-export declare class SerovalUnknownTypedArrayError extends Error {
-    constructor(name: string);
-}
-export declare class SerovalMalformedNodeError extends Error {
-    constructor(node: SerovalNode);
-}
-export declare class SerovalConflictedNodeIdError extends Error {
-    constructor(node: SerovalNode);
-}
-export declare class SerovalDepthLimitError extends Error {
-    constructor(limit: number);
-}
-//# sourceMappingURL=errors.d.ts.map

dist/types/core/errors.d.ts.map

-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/core/errors.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA0C3C,qBAAa,YAAa,SAAQ,KAAK;IAG5B,KAAK,EAAE,OAAO;gBADrB,IAAI,EAAE,MAAM,EACL,KAAK,EAAE,OAAO;CAIxB;AAED,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,KAAK,EAAE,OAAO;CAG3B;AAED,qBAAa,yBAA0B,SAAQ,YAAY;gBAC7C,KAAK,EAAE,OAAO;CAG3B;AAED,qBAAa,2BAA4B,SAAQ,YAAY;gBAC/C,KAAK,EAAE,OAAO;CAG3B;AAmBD,qBAAa,2BAA4B,SAAQ,KAAK;IACjC,KAAK,EAAE,OAAO;gBAAd,KAAK,EAAE,OAAO;CAWlC;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,IAAI,EAAE,WAAW;CAO9B;AAED,qBAAa,yBAA0B,SAAQ,KAAK;gBACtC,GAAG,EAAE,MAAM;CAOxB;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,GAAG,EAAE,MAAM;CAOxB;AAED,qBAAa,4BAA6B,SAAQ,KAAK;IAClC,KAAK,EAAE,OAAO;gBAAd,KAAK,EAAE,OAAO;CAWlC;AAED,qBAAa,iCAAkC,SAAQ,KAAK;gBAC9C,EAAE,EAAE,MAAM;CAOvB;AAED,qBAAa,6BAA8B,SAAQ,KAAK;gBAC1C,IAAI,EAAE,MAAM;CAOzB;AAED,qBAAa,yBAA0B,SAAQ,KAAK;gBACtC,IAAI,EAAE,WAAW;CAO9B;AAED,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,IAAI,EAAE,WAAW;CAO9B;AAED,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,KAAK,EAAE,MAAM;CAO1B"}

dist/types/core/function-string.d.ts

-export declare function createFunction(parameters: string[], body: string): string;
-export declare function createEffectfulFunction(parameters: string[], body: string): string;
-//# sourceMappingURL=function-string.d.ts.map

dist/types/core/function-string.d.ts.map

-{"version":3,"file":"function-string.d.ts","sourceRoot":"","sources":["../../../src/core/function-string.ts"],"names":[],"mappings":"AAOA,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CASzE;AAED,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAAE,EACpB,IAAI,EAAE,MAAM,GACX,MAAM,CASR"}

dist/types/core/keys.d.ts

-export declare const REFERENCES_KEY = "__SEROVAL_REFS__";
-export declare const GLOBAL_CONTEXT_REFERENCES = "$R";
-export declare function getCrossReferenceHeader(id?: string): string;
-//# sourceMappingURL=keys.d.ts.map

dist/types/core/keys.d.ts.map

-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../src/core/keys.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,qBAAqB,CAAC;AAEjD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAI9C,wBAAgB,uBAAuB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAO3D"}

dist/types/core/literals.d.ts

-import type { SerovalConstantNode } from './types';
-export declare const TRUE_NODE: SerovalConstantNode;
-export declare const FALSE_NODE: SerovalConstantNode;
-export declare const UNDEFINED_NODE: SerovalConstantNode;
-export declare const NULL_NODE: SerovalConstantNode;
-export declare const NEG_ZERO_NODE: SerovalConstantNode;
-export declare const INFINITY_NODE: SerovalConstantNode;
-export declare const NEG_INFINITY_NODE: SerovalConstantNode;
-export declare const NAN_NODE: SerovalConstantNode;
-//# sourceMappingURL=literals.d.ts.map

dist/types/core/literals.d.ts.map

-{"version":3,"file":"literals.d.ts","sourceRoot":"","sources":["../../../src/core/literals.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAmBnD,eAAO,MAAM,SAAS,qBAErB,CAAC;AACF,eAAO,MAAM,UAAU,qBAEtB,CAAC;AACF,eAAO,MAAM,cAAc,qBAE1B,CAAC;AACF,eAAO,MAAM,SAAS,qBAErB,CAAC;AACF,eAAO,MAAM,aAAa,qBAEzB,CAAC;AACF,eAAO,MAAM,aAAa,qBAEzB,CAAC;AACF,eAAO,MAAM,iBAAiB,qBAE7B,CAAC;AACF,eAAO,MAAM,QAAQ,qBAA0D,CAAC"}

dist/types/core/node.d.ts

-import type { SerovalNodeType } from './constants';
-import type { SerovalNode } from './types';
-type ExtractedNodeType<T extends SerovalNodeType> = Extract<SerovalNode, {
-    t: T;
-}>;
-export declare function createSerovalNode<T extends SerovalNodeType, N extends ExtractedNodeType<T>>(t: T, i: N['i'], s: N['s'], c: N['c'], m: N['m'], p: N['p'], e: N['e'], a: N['a'], f: N['f'], b: N['b'], o: N['o'], l: N['l']): N;
-export {};
-//# sourceMappingURL=node.d.ts.map

dist/types/core/node.d.ts.map

-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/core/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,KAAK,iBAAiB,CAAC,CAAC,SAAS,eAAe,IAAI,OAAO,CACzD,WAAW,EACX;IAAE,CAAC,EAAE,CAAC,CAAA;CAAE,CACT,CAAC;AAEF,wBAAgB,iBAAiB,CAC/B,CAAC,SAAS,eAAe,EACzB,CAAC,SAAS,iBAAiB,CAAC,CAAC,CAAC,EAE9B,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EACT,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GACR,CAAC,CAeH"}

dist/types/core/opaque-reference.d.ts

-/**
- * An opaque reference allows hiding values from the serializer.
- */
-export declare class OpaqueReference<V, R = undefined> {
-    readonly value: V;
-    readonly replacement?: R | undefined;
-    constructor(value: V, replacement?: R | undefined);
-}
-//# sourceMappingURL=opaque-reference.d.ts.map

dist/types/core/opaque-reference.d.ts.map

-{"version":3,"file":"opaque-reference.d.ts","sourceRoot":"","sources":["../../../src/core/opaque-reference.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS;aAEzB,KAAK,EAAE,CAAC;aACR,WAAW,CAAC;gBADZ,KAAK,EAAE,CAAC,EACR,WAAW,CAAC,eAAG;CAElC"}

dist/types/core/plugin.d.ts

-import type { AsyncParsePluginContext } from './context/async-parser';
-import type { DeserializePluginContext } from './context/deserializer';
-import type { SerializePluginContext } from './context/serializer';
-import type { StreamParsePluginContext, SyncParsePluginContext } from './context/sync-parser';
-import type { SerovalNode } from './types';
-export declare const enum SerovalMode {
-    Vanilla = 1,
-    Cross = 2
-}
-export interface PluginData {
-    id: number;
-}
-export type PluginInfo = {
-    [key: string]: SerovalNode;
-};
-export interface Plugin<Value, Info extends PluginInfo> {
-    /**
-     * A unique string that helps idenfity the plugin
-     */
-    tag: string;
-    /**
-     * List of dependency plugins
-     */
-    extends?: Plugin<any, any>[];
-    /**
-     * Method to test if a value is an expected value of the plugin
-     * @param value
-     */
-    test(value: unknown): boolean;
-    /**
-     * Parsing modes
-     */
-    parse: {
-        sync?: (value: Value, ctx: SyncParsePluginContext, data: PluginData) => Info;
-        async?: (value: Value, ctx: AsyncParsePluginContext, data: PluginData) => Promise<Info>;
-        stream?: (value: Value, ctx: StreamParsePluginContext, data: PluginData) => Info;
-    };
-    /**
-     * Convert the parsed node into a JS string
-     */
-    serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;
-    /**
-     * Convert the parsed node into its runtime equivalent.
-     */
-    deserialize(node: Info, ctx: DeserializePluginContext, data: PluginData): Value;
-}
-export declare function createPlugin<Value, Info extends PluginInfo>(plugin: Plugin<Value, Info>): Plugin<Value, Info>;
-export interface PluginAccessOptions {
-    plugins?: Plugin<any, any>[];
-}
-export declare function resolvePlugins(plugins?: Plugin<any, any>[]): Plugin<any, any>[] | undefined;
-//# sourceMappingURL=plugin.d.ts.map

dist/types/core/plugin.d.ts.map

-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/core/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EACV,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,0BAAkB,WAAW;IAC3B,OAAO,IAAI;IACX,KAAK,IAAI;CACV;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,MAAM,CAAC,KAAK,EAAE,IAAI,SAAS,UAAU;IACpD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IAC7B;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAC9B;;OAEG;IACH,KAAK,EAAE;QACL,IAAI,CAAC,EAAE,CACL,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,UAAU,KACb,IAAI,CAAC;QACV,KAAK,CAAC,EAAE,CACN,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,uBAAuB,EAC5B,IAAI,EAAE,UAAU,KACb,OAAO,CAAC,IAAI,CAAC,CAAC;QACnB,MAAM,CAAC,EAAE,CACP,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,wBAAwB,EAC7B,IAAI,EAAE,UAAU,KACb,IAAI,CAAC;KACX,CAAC;IACF;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,sBAAsB,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAC7E;;OAEG;IACH,WAAW,CACT,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,wBAAwB,EAC7B,IAAI,EAAE,UAAU,GACf,KAAK,CAAC;CACV;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,IAAI,SAAS,UAAU,EACzD,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,GAC1B,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAErB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;CAC9B;AAiBD,wBAAgB,cAAc,CAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAC3B,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,SAAS,CAOhC"}

dist/types/core/reference.d.ts

-export declare function createReference<T>(id: string, value: T): T;
-export declare function hasReferenceID<T>(value: T): boolean;
-export declare function hasReference(id: string): boolean;
-export declare function getReferenceID<T>(value: T): string;
-export declare function getReference<T>(id: string): T;
-//# sourceMappingURL=reference.d.ts.map

dist/types/core/reference.d.ts.map

-{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../src/core/reference.ts"],"names":[],"mappings":"AASA,wBAAgB,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAI1D;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAEnD;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAKlD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,CAAC,CAK7C"}

dist/types/core/sequence.d.ts

-export interface Sequence {
-    __SEROVAL_SEQUENCE__: true;
-    v: unknown[];
-    t: number;
-    d: number;
-}
-export declare function isSequence(value: object): value is Sequence;
-export declare function createSequence(values: unknown[], throwAt: number, doneAt: number): Sequence;
-export declare function createSequenceFromIterable<T>(source: Iterable<T>): Sequence;
-export declare function sequenceToIterator<T>(sequence: Sequence): () => IterableIterator<T>;
-//# sourceMappingURL=sequence.d.ts.map

dist/types/core/sequence.d.ts.map

-{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../../../src/core/sequence.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,QAAQ;IACvB,oBAAoB,EAAE,IAAI,CAAC;IAE3B,CAAC,EAAE,OAAO,EAAE,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,QAAQ,CAE3D;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,OAAO,EAAE,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,QAAQ,CAQV;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAqB3E;AAID,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,QAAQ,EAAE,QAAQ,GACjB,MAAM,gBAAgB,CAAC,CAAC,CAAC,CAE3B"}

dist/types/core/Serializer.d.ts

-import { type PluginAccessOptions } from './plugin';
-export interface SerializerOptions extends PluginAccessOptions {
-    globalIdentifier: string;
-    scopeId?: string;
-    disabledFeatures?: number;
-    onData: (result: string) => void;
-    onError: (error: unknown) => void;
-    onDone?: () => void;
-}
-export default class Serializer {
-    private options;
-    private alive;
-    private flushed;
-    private done;
-    private pending;
-    private cleanups;
-    private refs;
-    private plugins?;
-    constructor(options: SerializerOptions);
-    keys: Set<string>;
-    write(key: string, value: unknown): void;
-    ids: number;
-    private getNextID;
-    push(value: unknown): string;
-    flush(): void;
-    close(): void;
-}
-//# sourceMappingURL=Serializer.d.ts.map

dist/types/core/Serializer.d.ts.map

-{"version":3,"file":"Serializer.d.ts","sourceRoot":"","sources":["../../../src/core/Serializer.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,UAAU,CAAC;AAGlB,MAAM,WAAW,iBAAkB,SAAQ,mBAAmB;IAC5D,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,CAAC,OAAO,OAAO,UAAU;IAejB,OAAO,CAAC,OAAO;IAd3B,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO,CAAC,OAAO,CAAK;IAEpB,OAAO,CAAC,QAAQ,CAAsB;IAEtC,OAAO,CAAC,IAAI,CAA8B;IAE1C,OAAO,CAAC,OAAO,CAAC,CAAqB;gBAEjB,OAAO,EAAE,iBAAiB;IAI9C,IAAI,cAAqB;IAEzB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IA2CxC,GAAG,SAAK;IAER,OAAO,CAAC,SAAS;IAOjB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAM5B,KAAK,IAAI,IAAI;IAUb,KAAK,IAAI,IAAI;CAYd"}

dist/types/core/special-reference.d.ts

-export declare const ITERATOR: {};
-export declare const ASYNC_ITERATOR: {};
-export declare const enum SpecialReference {
-    MapSentinel = 0,
-    PromiseConstructor = 1,
-    PromiseSuccess = 2,
-    PromiseFailure = 3,
-    StreamConstructor = 4,
-    ArrayBufferConstructor = 5
-}
-/**
- * Placeholder references
- */
-export declare const SPECIAL_REFS: Record<SpecialReference, unknown>;
-export declare const SPECIAL_REF_STRING: Record<SpecialReference, string>;
-//# sourceMappingURL=special-reference.d.ts.map

dist/types/core/special-reference.d.ts.map

-{"version":3,"file":"special-reference.d.ts","sourceRoot":"","sources":["../../../src/core/special-reference.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,QAAQ,IAAK,CAAC;AAE3B,eAAO,MAAM,cAAc,IAAK,CAAC;AAEjC,0BAAkB,gBAAgB;IAChC,WAAW,IAAI;IACf,kBAAkB,IAAI;IACtB,cAAc,IAAI;IAClB,cAAc,IAAI;IAClB,iBAAiB,IAAI;IACrB,sBAAsB,IAAI;CAC3B;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,gBAAgB,EAAE,OAAO,CAO1D,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAQ/D,CAAC"}

dist/types/core/stream.d.ts

-export interface StreamListener<T> {
-    next(value: T): void;
-    throw(value: unknown): void;
-    return(value: T): void;
-}
-export interface Stream<T> {
-    __SEROVAL_STREAM__: true;
-    on(listener: StreamListener<T>): () => void;
-    next(value: T): void;
-    throw(value: unknown): void;
-    return(value: T): void;
-}
-export declare function isStream<T>(value: object): value is Stream<T>;
-export declare function createStream<T>(): Stream<T>;
-export declare function createStreamFromAsyncIterable<T>(iterable: AsyncIterable<T>): Stream<T>;
-export declare function streamToAsyncIterable<T>(stream: Stream<T>): () => AsyncIterableIterator<T>;
-//# sourceMappingURL=stream.d.ts.map

dist/types/core/stream.d.ts.map

-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/core/stream.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,kBAAkB,EAAE,IAAI,CAAC;IAEzB,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC;IAE5C,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACxB;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,CAE7D;AAED,wBAAgB,YAAY,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,CAE3C;AAED,wBAAgB,6BAA6B,CAAC,CAAC,EAC7C,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GACzB,MAAM,CAAC,CAAC,CAAC,CAwBX;AAOD,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAChB,MAAM,qBAAqB,CAAC,CAAC,CAAC,CAIhC"}

dist/types/core/string.d.ts

-export declare function serializeChar(str: string): string | undefined;
-export declare function serializeString(str: string): string;
-export declare function deserializeString(str: string): string;
-//# sourceMappingURL=string.d.ts.map

dist/types/core/string.d.ts.map

-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/core/string.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAyB7D;AAOD,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAiBnD;AA6BD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKrD"}

dist/types/core/symbols.d.ts

-export declare const SYM_ASYNC_ITERATOR: typeof Symbol.asyncIterator;
-export declare const SYM_HAS_INSTANCE: typeof Symbol.hasInstance;
-export declare const SYM_IS_CONCAT_SPREADABLE: typeof Symbol.isConcatSpreadable;
-export declare const SYM_ITERATOR: typeof Symbol.iterator;
-export declare const SYM_MATCH: typeof Symbol.match;
-export declare const SYM_MATCH_ALL: typeof Symbol.matchAll;
-export declare const SYM_REPLACE: typeof Symbol.replace;
-export declare const SYM_SEARCH: typeof Symbol.search;
-export declare const SYM_SPECIES: typeof Symbol.species;
-export declare const SYM_SPLIT: typeof Symbol.split;
-export declare const SYM_TO_PRIMITIVE: typeof Symbol.toPrimitive;
-export declare const SYM_TO_STRING_TAG: typeof Symbol.toStringTag;
-export declare const SYM_UNSCOPABLES: typeof Symbol.unscopables;
-//# sourceMappingURL=symbols.d.ts.map

dist/types/core/symbols.d.ts.map

-{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../../../src/core/symbols.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC,aACzB,CAAC;AACvB,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC,WAAgC,CAAC;AAC9E,eAAO,MAAM,wBAAwB,EAAE,OAAO,MAAM,CAAC,kBAC1B,CAAC;AAC5B,eAAO,MAAM,YAAY,EAAE,OAAO,MAAM,CAAC,QAA0B,CAAC;AACpE,eAAO,MAAM,SAAS,EAAE,OAAO,MAAM,CAAC,KAAoB,CAAC;AAC3D,eAAO,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC,QAA0B,CAAC;AACrE,eAAO,MAAM,WAAW,EAAE,OAAO,MAAM,CAAC,OAAwB,CAAC;AACjE,eAAO,MAAM,UAAU,EAAE,OAAO,MAAM,CAAC,MAAsB,CAAC;AAC9D,eAAO,MAAM,WAAW,EAAE,OAAO,MAAM,CAAC,OAAwB,CAAC;AACjE,eAAO,MAAM,SAAS,EAAE,OAAO,MAAM,CAAC,KAAoB,CAAC;AAC3D,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC,WAAgC,CAAC;AAC9E,eAAO,MAAM,iBAAiB,EAAE,OAAO,MAAM,CAAC,WAAgC,CAAC;AAC/E,eAAO,MAAM,eAAe,EAAE,OAAO,MAAM,CAAC,WAAgC,CAAC"}

dist/types/core/tree/index.d.ts

-import type { BaseParserContextOptions } from '../context/parser';
-import { type PluginAccessOptions } from '../plugin';
-import type { SerovalNode } from '../types';
-export type SyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
-export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
-export declare function serialize<T>(source: T, options?: SyncParserContextOptions): string;
-export declare function serializeAsync<T>(source: T, options?: AsyncParserContextOptions): Promise<string>;
-export declare function deserialize<T>(source: string): T;
-export interface SerovalJSON {
-    t: SerovalNode;
-    f: number;
-    m: number[];
-}
-export interface FromJSONOptions extends PluginAccessOptions {
-    disabledFeatures?: number;
-}
-export declare function toJSON<T>(source: T, options?: SyncParserContextOptions): SerovalJSON;
-export declare function toJSONAsync<T>(source: T, options?: AsyncParserContextOptions): Promise<SerovalJSON>;
-export declare function compileJSON(source: SerovalJSON, options?: PluginAccessOptions): string;
-export declare function fromJSON<T>(source: SerovalJSON, options?: FromJSONOptions): T;
-//# sourceMappingURL=index.d.ts.map

dist/types/core/tree/index.d.ts.map

-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/tree/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAMlE,OAAO,EACL,KAAK,mBAAmB,EAGzB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC;AAC9E,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC;AAE/E,wBAAgB,SAAS,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAaR;AAED,wBAAsB,cAAc,CAAC,CAAC,EACpC,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,MAAM,CAAC,CAajB;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAEhD;AAED,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,WAAW,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,EAAE,CAAC;CACb;AAED,MAAM,WAAW,eAAgB,SAAQ,mBAAmB;IAC1D,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,MAAM,CAAC,CAAC,EACtB,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,wBAA6B,GACrC,WAAW,CAWb;AAED,wBAAsB,WAAW,CAAC,CAAC,EACjC,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,WAAW,CAAC,CAWtB;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAQR;AAED,wBAAgB,QAAQ,CAAC,CAAC,EACxB,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,eAAoB,GAC5B,CAAC,CAWH"}

dist/types/core/types.d.ts

-import type { ErrorConstructorTag, SerovalConstant, SerovalNodeType, SerovalObjectFlags, Symbols } from './constants';
-import type { SpecialReference } from './special-reference';
-export interface SerovalBaseNode {
-    t: SerovalNodeType;
-    i: number | undefined;
-    s: unknown;
-    c: string | undefined;
-    m: string | undefined;
-    p: SerovalObjectRecordNode | undefined;
-    e: SerovalMapRecordNode | undefined;
-    a: (SerovalNode | 0)[] | undefined;
-    f: SerovalNode | undefined;
-    b: number | undefined;
-    o: SerovalObjectFlags | undefined;
-    l: number | undefined;
-}
-export type SerovalObjectRecordKey = string | SerovalNode;
-export interface SerovalObjectRecordNode {
-    k: SerovalObjectRecordKey[];
-    v: SerovalNode[];
-}
-export interface SerovalMapRecordNode {
-    k: SerovalNode[];
-    v: SerovalNode[];
-}
-export interface SerovalNumberNode extends SerovalBaseNode {
-    t: SerovalNodeType.Number;
-    s: number;
-}
-export interface SerovalStringNode extends SerovalBaseNode {
-    t: SerovalNodeType.String;
-    s: string;
-}
-export interface SerovalConstantNode extends SerovalBaseNode {
-    t: SerovalNodeType.Constant;
-    s: SerovalConstant;
-}
-export type SerovalPrimitiveNode = SerovalNumberNode | SerovalStringNode | SerovalConstantNode;
-export interface SerovalIndexedValueNode extends SerovalBaseNode {
-    t: SerovalNodeType.IndexedValue;
-    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;
-    c: string;
-    m: string;
-}
-export interface SerovalArrayBufferNode extends SerovalBaseNode {
-    t: SerovalNodeType.ArrayBuffer;
-    i: number;
-    s: string;
-    f: SerovalNodeWithID;
-}
-export interface SerovalTypedArrayNode extends SerovalBaseNode {
-    t: SerovalNodeType.TypedArray;
-    i: number;
-    c: string;
-    f: SerovalNode;
-    b: number;
-    l: number;
-}
-export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
-    t: SerovalNodeType.BigIntTypedArray;
-    i: number;
-    c: string;
-    f: SerovalNode;
-    b: number;
-    l: number;
-}
-export type SerovalSemiPrimitiveNode = SerovalBigIntNode | SerovalDateNode | SerovalRegExpNode | SerovalTypedArrayNode | SerovalBigIntTypedArrayNode;
-export interface SerovalSetNode extends SerovalBaseNode {
-    t: SerovalNodeType.Set;
-    i: number;
-    a: SerovalNode[];
-}
-export interface SerovalMapNode extends SerovalBaseNode {
-    t: SerovalNodeType.Map;
-    i: number;
-    e: SerovalMapRecordNode;
-    f: SerovalNodeWithID;
-}
-export interface SerovalArrayNode extends SerovalBaseNode {
-    t: SerovalNodeType.Array;
-    a: (SerovalNode | 0)[];
-    i: number;
-    o: SerovalObjectFlags;
-}
-export interface SerovalObjectNode extends SerovalBaseNode {
-    t: SerovalNodeType.Object;
-    p: SerovalObjectRecordNode;
-    i: number;
-    o: SerovalObjectFlags;
-}
-export interface SerovalNullConstructorNode extends SerovalBaseNode {
-    t: SerovalNodeType.NullConstructor;
-    p: SerovalObjectRecordNode;
-    i: number;
-    o: SerovalObjectFlags;
-}
-export interface SerovalPromiseNode extends SerovalBaseNode {
-    t: SerovalNodeType.Promise;
-    s: 0 | 1;
-    f: SerovalNode;
-    i: number;
-}
-export interface SerovalErrorNode extends SerovalBaseNode {
-    t: SerovalNodeType.Error;
-    s: ErrorConstructorTag;
-    m: string;
-    p: SerovalObjectRecordNode | undefined;
-    i: number;
-}
-export interface SerovalAggregateErrorNode extends SerovalBaseNode {
-    t: SerovalNodeType.AggregateError;
-    i: number;
-    m: string;
-    p: SerovalObjectRecordNode | undefined;
-}
-export interface SerovalWKSymbolNode extends SerovalBaseNode {
-    t: SerovalNodeType.WKSymbol;
-    i: number;
-    s: Symbols;
-}
-export interface SerovalReferenceNode extends SerovalBaseNode {
-    t: SerovalNodeType.Reference;
-    i: number;
-    s: string;
-}
-export interface SerovalDataViewNode extends SerovalBaseNode {
-    t: SerovalNodeType.DataView;
-    i: number;
-    f: SerovalNode;
-    b: number;
-    l: number;
-}
-export interface SerovalBoxedNode extends SerovalBaseNode {
-    t: SerovalNodeType.Boxed;
-    i: number;
-    f: SerovalNode;
-}
-export interface SerovalPromiseConstructorNode extends SerovalBaseNode {
-    t: SerovalNodeType.PromiseConstructor;
-    i: number;
-    s: number;
-    f: SerovalNodeWithID;
-}
-export interface SerovalPromiseResolveNode extends SerovalBaseNode {
-    t: SerovalNodeType.PromiseSuccess;
-    i: number;
-    a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
-}
-export interface SerovalPromiseRejectNode extends SerovalBaseNode {
-    t: SerovalNodeType.PromiseFailure;
-    i: number;
-    a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
-}
-export interface SerovalPluginNode extends SerovalBaseNode {
-    t: SerovalNodeType.Plugin;
-    i: number;
-    s: Record<string, SerovalNode>;
-    c: string;
-}
-/**
- * Represents special values as placeholders
- */
-export interface SerovalSpecialReferenceNode extends SerovalBaseNode {
-    t: SerovalNodeType.SpecialReference;
-    i: number;
-    s: SpecialReference;
-}
-export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
-    t: SerovalNodeType.IteratorFactory;
-    i: number;
-    f: SerovalNodeWithID;
-}
-export interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
-    t: SerovalNodeType.IteratorFactoryInstance;
-    a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
-}
-export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
-    t: SerovalNodeType.AsyncIteratorFactory;
-    i: number;
-    a: [promise: SerovalNodeWithID, symbol: SerovalNodeWithID];
-}
-export interface SerovalAsyncIteratorFactoryInstanceNode extends SerovalBaseNode {
-    t: SerovalNodeType.AsyncIteratorFactoryInstance;
-    a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
-}
-export interface SerovalStreamConstructorNode extends SerovalBaseNode {
-    t: SerovalNodeType.StreamConstructor;
-    i: number;
-    a: SerovalNode[];
-    f: SerovalNodeWithID;
-}
-export interface SerovalStreamNextNode extends SerovalBaseNode {
-    t: SerovalNodeType.StreamNext;
-    i: number;
-    f: SerovalNode;
-}
-export interface SerovalStreamThrowNode extends SerovalBaseNode {
-    t: SerovalNodeType.StreamThrow;
-    i: number;
-    f: SerovalNode;
-}
-export interface SerovalStreamReturnNode extends SerovalBaseNode {
-    t: SerovalNodeType.StreamReturn;
-    i: number;
-    f: SerovalNode;
-}
-export interface SerovalSequenceNode extends SerovalBaseNode {
-    t: SerovalNodeType.Sequence;
-    i: number;
-    s: number;
-    a: SerovalNode[];
-    l: number;
-}
-export type SerovalSyncNode = SerovalPrimitiveNode | SerovalIndexedValueNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalWKSymbolNode | SerovalReferenceNode | SerovalArrayBufferNode | SerovalDataViewNode | SerovalBoxedNode | SerovalPluginNode | SerovalSpecialReferenceNode | SerovalIteratorFactoryNode | SerovalIteratorFactoryInstanceNode | SerovalAsyncIteratorFactoryNode | SerovalAsyncIteratorFactoryInstanceNode | SerovalSequenceNode;
-export type SerovalAsyncNode = SerovalPromiseNode | SerovalPromiseConstructorNode | SerovalPromiseResolveNode | SerovalPromiseRejectNode | SerovalStreamConstructorNode | SerovalStreamNextNode | SerovalStreamThrowNode | SerovalStreamReturnNode;
-export type SerovalNode = SerovalSyncNode | SerovalAsyncNode;
-export type SerovalNodeWithID = Extract<SerovalNode, {
-    i: number;
-}>;
-//# sourceMappingURL=types.d.ts.map

dist/types/core/types.d.ts.map

-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/types.ts"],"names":[],"mappings":"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"}

dist/types/core/utils/error.d.ts

-import { ErrorConstructorTag } from '../constants';
-type ErrorValue = Error | AggregateError | EvalError | RangeError | ReferenceError | TypeError | SyntaxError | URIError;
-export declare function getErrorConstructor(error: ErrorValue): ErrorConstructorTag;
-export declare function getErrorOptions(error: Error, features: number): Record<string, unknown> | undefined;
-export {};
-//# sourceMappingURL=error.d.ts.map

dist/types/core/utils/error.d.ts.map

-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/error.ts"],"names":[],"mappings":"AACA,OAAO,EAA4B,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAE7E,KAAK,UAAU,GACX,KAAK,GACL,cAAc,GACd,SAAS,GACT,UAAU,GACV,cAAc,GACd,SAAS,GACT,WAAW,GACX,QAAQ,CAAC;AAEb,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,mBAAmB,CAoB1E;AAkBD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAkBrC"}

dist/types/core/utils/get-identifier.d.ts

-export default function getIdentifier(index: number): string;
-//# sourceMappingURL=get-identifier.d.ts.map

dist/types/core/utils/get-identifier.d.ts.map

-{"version":3,"file":"get-identifier.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/get-identifier.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAU3D"}

dist/types/core/utils/get-object-flag.d.ts

-import { SerovalObjectFlags } from '../constants';
-export declare function getObjectFlag(obj: unknown): SerovalObjectFlags;
-//# sourceMappingURL=get-object-flag.d.ts.map

dist/types/core/utils/get-object-flag.d.ts.map

-{"version":3,"file":"get-object-flag.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/get-object-flag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,CAW9D"}

dist/types/core/utils/is-valid-identifier.d.ts

-export declare function isValidIdentifier(name: string): boolean;
-//# sourceMappingURL=is-valid-identifier.d.ts.map

dist/types/core/utils/is-valid-identifier.d.ts.map

-{"version":3,"file":"is-valid-identifier.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/is-valid-identifier.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CASvD"}

dist/types/core/utils/promise-to-result.d.ts

-export default function promiseToResult(current: Promise<unknown>): Promise<[0 | 1, unknown]>;
-//# sourceMappingURL=promise-to-result.d.ts.map

dist/types/core/utils/promise-to-result.d.ts.map

-{"version":3,"file":"promise-to-result.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/promise-to-result.ts"],"names":[],"mappings":"AAAA,wBAA8B,eAAe,CAC3C,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GACxB,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC,CAM3B"}

dist/types/core/utils/typed-array.d.ts

-type TypedArrayConstructor = Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Uint8ClampedArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor;
-export type TypedArrayValue = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
-export type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;
-export declare function getTypedArrayConstructor(name: string): TypedArrayConstructor;
-export {};
-//# sourceMappingURL=typed-array.d.ts.map

dist/types/core/utils/typed-array.d.ts.map

-{"version":3,"file":"typed-array.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/typed-array.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,sBAAsB,GACtB,4BAA4B,GAC5B,uBAAuB,GACvB,uBAAuB,GACvB,wBAAwB,GACxB,yBAAyB,CAAC;AAE9B,MAAM,MAAM,eAAe,GACvB,SAAS,GACT,UAAU,GACV,UAAU,GACV,UAAU,GACV,WAAW,GACX,WAAW,GACX,iBAAiB,GACjB,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG,cAAc,CAAC;AAEnE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CA2B5E"}

dist/types/core/utils/valid-properties.d.ts

-export declare function isValidKey(key: string): boolean;
-export declare function isValidSymbol(symbol: symbol): boolean;
-//# sourceMappingURL=valid-properties.d.ts.map

dist/types/core/utils/valid-properties.d.ts.map

-{"version":3,"file":"valid-properties.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/valid-properties.ts"],"names":[],"mappings":"AAOA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAc/C;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAUrD"}

dist/types/index.d.ts

-export { Feature } from './core/compat';
-export type { AsyncParsePluginContext, AsyncParserContextOptions, } from './core/context/async-parser';
-export type { BaseDeserializerContextOptions, CrossDeserializerContextOptions, DeserializePluginContext, VanillaDeserializerContextOptions, } from './core/context/deserializer';
-export type { BaseParserContextOptions } from './core/context/parser';
-export type { BaseSerializerContextOptions, CrossContextOptions, CrossSerializerContextOptions, SerializePluginContext, VanillaSerializerContextOptions, } from './core/context/serializer';
-export type { StreamParsePluginContext, StreamParserContextOptions, SyncParsePluginContext, SyncParserContextOptions, } from './core/context/sync-parser';
-export * from './core/cross';
-export * from './core/errors';
-export { getCrossReferenceHeader } from './core/keys';
-export { OpaqueReference } from './core/opaque-reference';
-export * from './core/plugin';
-export { createReference } from './core/reference';
-export { default as Serializer } from './core/Serializer';
-export { createStream } from './core/stream';
-export type { Stream, StreamListener } from './core/stream';
-export * from './core/tree';
-export type { SerovalNode } from './core/types';
-//# sourceMappingURL=index.d.ts.map

dist/types/index.d.ts.map

-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,YAAY,EACV,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,6BAA6B,CAAC;AACrC,YAAY,EACV,8BAA8B,EAC9B,+BAA+B,EAC/B,wBAAwB,EACxB,iCAAiC,GAClC,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,YAAY,EACV,4BAA4B,EAC5B,mBAAmB,EACnB,6BAA6B,EAC7B,sBAAsB,EACtB,+BAA+B,GAChC,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,wBAAwB,EACxB,0BAA0B,EAC1B,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC5D,cAAc,aAAa,CAAC;AAC5B,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC"}

src/core/base-primitives.ts

-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,
-  SerovalSequenceNode,
-  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: Record<string, SerovalNode>,
-): 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.length,
-  );
-}
-
-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: SerovalNodeWithID,
-): SerovalIteratorFactoryInstanceNode {
-  return createSerovalNode(
-    SerovalNodeType.IteratorFactoryInstance,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    [factory, items],
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function createAsyncIteratorFactoryInstanceNode(
-  factory: SerovalNodeWithID,
-  items: SerovalNodeWithID,
-): 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,
-  );
-}
-
-export function createSequenceNode(
-  id: number,
-  sequence: SerovalNode[],
-  throwAt: number,
-  doneAt: number,
-): SerovalSequenceNode {
-  return createSerovalNode(
-    SerovalNodeType.Sequence,
-    id,
-    throwAt,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    sequence,
-    NIL,
-    NIL,
-    NIL,
-    doneAt,
-  );
-}

src/core/compat.ts

-/**
- * 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;

src/core/constants.ts

-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,
-  Sequence = 35,
-}
-
-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,
-  };

src/core/constructors.ts

-import type { Sequence } from './sequence';
-import type { Stream } from './stream';
-
-type SpecialPromise = Promise<unknown> & { s?: 1 | 2; v?: unknown };
-
-export interface PromiseConstructorResolver {
-  p: SpecialPromise;
-  s: (value: unknown) => void;
-  f: (value: unknown) => void;
-}
-
-export const PROMISE_CONSTRUCTOR = (): PromiseConstructorResolver => {
-  const resolver = {
-    p: 0,
-    s: 0,
-    f: 0,
-  } as unknown as PromiseConstructorResolver;
-  resolver.p = new Promise((resolve, reject) => {
-    resolver.s = resolve;
-    resolver.f = reject;
-  });
-  return resolver;
-};
-
-export const PROMISE_SUCCESS = (
-  resolver: PromiseConstructorResolver,
-  data: unknown,
-): void => {
-  resolver.s(data);
-  resolver.p.s = 1;
-  resolver.p.v = data;
-};
-
-export const PROMISE_FAILURE = (
-  resolver: PromiseConstructorResolver,
-  data: unknown,
-): void => {
-  resolver.f(data);
-  resolver.p.s = 2;
-  resolver.p.v = data;
-};
-
-export const SERIALIZED_PROMISE_CONSTRUCTOR =
-  /* @__PURE__ */ PROMISE_CONSTRUCTOR.toString();
-export const SERIALIZED_PROMISE_SUCCESS =
-  /* @__PURE__ */ PROMISE_SUCCESS.toString();
-export const SERIALIZED_PROMISE_FAILURE =
-  /* @__PURE__ */ PROMISE_FAILURE.toString();
-
-interface StreamListener<T> {
-  next(value: T): void;
-  throw(value: unknown): void;
-  return(value: T): void;
-}
-
-export const STREAM_CONSTRUCTOR = () => {
-  const buffer: unknown[] = [];
-  const listeners: StreamListener<unknown>[] = [];
-  let alive = true;
-  let success = false;
-  let count = 0;
-  const flush = (
-    value: unknown,
-    mode: keyof StreamListener<unknown>,
-    x?: number,
-  ) => {
-    for (x = 0; x < count; x++) {
-      if (listeners[x]) {
-        listeners[x][mode](value);
-      }
-    }
-  };
-  const up = (
-    listener: StreamListener<unknown>,
-    x?: number,
-    z?: number,
-    current?: unknown,
-  ) => {
-    for (x = 0, z = buffer.length; x < z; x++) {
-      current = buffer[x];
-      if (!alive && x === z - 1) {
-        listener[success ? 'return' : 'throw'](current);
-      } else {
-        listener.next(current);
-      }
-    }
-  };
-  const on = (listener: StreamListener<unknown>, temp?: number) => {
-    if (alive) {
-      temp = count++;
-      listeners[temp] = listener;
-    }
-    up(listener);
-    return () => {
-      if (alive) {
-        listeners[temp!] = listeners[count];
-        listeners[count--] = undefined as any;
-      }
-    };
-  };
-  return {
-    __SEROVAL_STREAM__: true,
-    on: (listener: StreamListener<unknown>) => on(listener),
-    next: (value: unknown) => {
-      if (alive) {
-        buffer.push(value);
-        flush(value, 'next');
-      }
-    },
-    throw: (value: unknown) => {
-      if (alive) {
-        buffer.push(value);
-        flush(value, 'throw');
-        alive = false;
-        success = false;
-        listeners.length = 0;
-      }
-    },
-    return: (value: unknown) => {
-      if (alive) {
-        buffer.push(value);
-        flush(value, 'return');
-        alive = false;
-        success = true;
-        listeners.length = 0;
-      }
-    },
-  };
-};
-
-export const SERIALIZED_STREAM_CONSTRUCTOR =
-  /* @__PURE__ */ STREAM_CONSTRUCTOR.toString();
-
-export const ITERATOR_CONSTRUCTOR =
-  (symbol: symbol) => (sequence: Sequence) => () => {
-    let index = 0;
-    const instance = {
-      [symbol]: () => instance,
-      next: () => {
-        if (index > sequence.d) {
-          return {
-            done: true,
-            value: undefined,
-          };
-        }
-        const currentIndex = index++;
-        const data = sequence.v[currentIndex];
-        if (currentIndex === sequence.t) {
-          throw data;
-        }
-        return {
-          done: currentIndex === sequence.d,
-          value: data,
-        };
-      },
-    };
-    return instance;
-  };
-
-export const SERIALIZED_ITERATOR_CONSTRUCTOR =
-  /* @__PURE__ */ ITERATOR_CONSTRUCTOR.toString();
-
-export const ASYNC_ITERATOR_CONSTRUCTOR =
-  (symbol: symbol, createPromise: typeof PROMISE_CONSTRUCTOR) =>
-  (stream: Stream<unknown>) =>
-  () => {
-    let count = 0;
-    let doneAt = -1;
-    let isThrow = false;
-    const buffer: unknown[] = [];
-    const pending: PromiseConstructorResolver[] = [];
-    const finalize = (i = 0, len = pending.length) => {
-      for (; i < len; i++) {
-        pending[i].s({
-          done: true,
-          value: undefined,
-        });
-      }
-    };
-    stream.on({
-      next: value => {
-        const temp = pending.shift();
-        if (temp) {
-          temp.s({ done: false, value });
-        }
-        buffer.push(value);
-      },
-      throw: value => {
-        const temp = pending.shift();
-        if (temp) {
-          temp.f(value);
-        }
-        finalize();
-        doneAt = buffer.length;
-        isThrow = true;
-        buffer.push(value);
-      },
-      return: value => {
-        const temp = pending.shift();
-        if (temp) {
-          temp.s({ done: true, value });
-        }
-        finalize();
-        doneAt = buffer.length;
-        buffer.push(value);
-      },
-    });
-
-    const instance = {
-      [symbol]: () => instance,
-      next: () => {
-        if (doneAt === -1) {
-          const index = count++;
-          if (index >= buffer.length) {
-            const temp = createPromise();
-            pending.push(temp);
-            return temp.p;
-          }
-          return {
-            done: false,
-            value: buffer[index],
-          };
-        }
-        if (count > doneAt) {
-          return {
-            done: true,
-            value: undefined,
-          };
-        }
-        const index = count++;
-        const value = buffer[index];
-        if (index !== doneAt) {
-          return {
-            done: false,
-            value,
-          };
-        }
-        if (isThrow) {
-          throw value;
-        }
-        return {
-          done: true,
-          value,
-        };
-      },
-    };
-
-    return instance;
-  };
-
-export const SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR =
-  /* @__PURE__ */ ASYNC_ITERATOR_CONSTRUCTOR.toString();
-
-export const ARRAY_BUFFER_CONSTRUCTOR = (b64: string) => {
-  const decoded = atob(b64);
-  const length = decoded.length;
-  const arr = new Uint8Array(length);
-  for (let i = 0; i < length; i++) {
-    arr[i] = decoded.charCodeAt(i);
-  }
-  return arr.buffer;
-};
-
-export const SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR =
-  /* @__PURE__ */ ARRAY_BUFFER_CONSTRUCTOR.toString();

src/core/context/async-parser.ts

-import {
-  createAggregateErrorNode,
-  createArrayNode,
-  createAsyncIteratorFactoryInstanceNode,
-  createBigIntNode,
-  createBigIntTypedArrayNode,
-  createBoxedNode,
-  createDataViewNode,
-  createDateNode,
-  createErrorNode,
-  createIteratorFactoryInstanceNode,
-  createNumberNode,
-  createPluginNode,
-  createRegExpNode,
-  createSequenceNode,
-  createSetNode,
-  createStreamConstructorNode,
-  createStreamNextNode,
-  createStreamReturnNode,
-  createStreamThrowNode,
-  createStringNode,
-  createTypedArrayNode,
-} from '../base-primitives';
-import { Feature } from '../compat';
-import { NIL, SerovalNodeType } from '../constants';
-import { SerovalDepthLimitError, SerovalParserError, SerovalUnsupportedTypeError } from '../errors';
-import { FALSE_NODE, NULL_NODE, TRUE_NODE, UNDEFINED_NODE } from '../literals';
-import { createSerovalNode } from '../node';
-import { OpaqueReference } from '../opaque-reference';
-import type { SerovalMode } from '../plugin';
-import {
-  createSequenceFromIterable,
-  isSequence,
-  type Sequence,
-} from '../sequence';
-import { SpecialReference } from '../special-reference';
-import type { Stream } from '../stream';
-import { createStreamFromAsyncIterable, isStream } from '../stream';
-import { serializeString } from '../string';
-import {
-  SYM_ASYNC_ITERATOR,
-  SYM_IS_CONCAT_SPREADABLE,
-  SYM_ITERATOR,
-  SYM_TO_STRING_TAG,
-} from '../symbols';
-import type {
-  SerovalAggregateErrorNode,
-  SerovalArrayNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalBoxedNode,
-  SerovalDataViewNode,
-  SerovalErrorNode,
-  SerovalMapNode,
-  SerovalNode,
-  SerovalNodeWithID,
-  SerovalNullConstructorNode,
-  SerovalObjectNode,
-  SerovalObjectRecordKey,
-  SerovalObjectRecordNode,
-  SerovalPluginNode,
-  SerovalPromiseNode,
-  SerovalSequenceNode,
-  SerovalSetNode,
-  SerovalStreamConstructorNode,
-  SerovalTypedArrayNode,
-} from '../types';
-import { getErrorOptions } from '../utils/error';
-import promiseToResult from '../utils/promise-to-result';
-import type {
-  BigIntTypedArrayValue,
-  TypedArrayValue,
-} from '../utils/typed-array';
-import type { BaseParserContext, BaseParserContextOptions } from './parser';
-import {
-  createArrayBufferNode,
-  createBaseParserContext,
-  createMapNode,
-  createObjectNode,
-  getReferenceNode,
-  markParserRef,
-  parseAsyncIteratorFactory,
-  parseIteratorFactory,
-  ParserNodeType,
-  parseSpecialReference,
-  parseWellKnownSymbol,
-} from './parser';
-
-type ObjectLikeNode =
-  | SerovalObjectNode
-  | SerovalNullConstructorNode
-  | SerovalPromiseNode;
-
-export type AsyncParserContextOptions = BaseParserContextOptions;
-
-export interface AsyncParserContext {
-  base: BaseParserContext;
-  child: AsyncParsePluginContext | undefined;
-}
-
-export function createAsyncParserContext(
-  mode: SerovalMode,
-  options: AsyncParserContextOptions,
-): AsyncParserContext {
-  return {
-    base: createBaseParserContext(mode, options),
-    child: undefined,
-  };
-}
-
-export class AsyncParsePluginContext {
-  constructor(
-    private _p: AsyncParserContext,
-    private depth: number,
-  ) {}
-
-  parse<T>(current: T): Promise<SerovalNode> {
-    return parseAsync(this._p, this.depth, current);
-  }
-}
-
-async function parseItems(
-  ctx: AsyncParserContext,
-  depth: number,
-  current: unknown[],
-): Promise<(SerovalNode | 0)[]> {
-  const nodes: (SerovalNode | 0)[] = [];
-  for (let i = 0, len = current.length; i < len; i++) {
-    // For consistency in holes
-    if (i in current) {
-      nodes[i] = await parseAsync(ctx, depth, current[i]);
-    } else {
-      nodes[i] = 0;
-    }
-  }
-  return nodes;
-}
-
-async function parseArray(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: unknown[],
-): Promise<SerovalArrayNode> {
-  return createArrayNode(id, current, await parseItems(ctx, depth, current));
-}
-
-async function parseProperties(
-  ctx: AsyncParserContext,
-  depth: number,
-  properties: Record<string | symbol, unknown>,
-): Promise<SerovalObjectRecordNode> {
-  const entries = Object.entries(properties);
-  const keyNodes: SerovalObjectRecordKey[] = [];
-  const valueNodes: SerovalNode[] = [];
-  for (let i = 0, len = entries.length; i < len; i++) {
-    keyNodes.push(serializeString(entries[i][0]));
-    valueNodes.push(await parseAsync(ctx, depth, entries[i][1]));
-  }
-  // Check special properties
-  if (SYM_ITERATOR in properties) {
-    keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));
-    valueNodes.push(
-      createIteratorFactoryInstanceNode(
-        parseIteratorFactory(ctx.base),
-        (await parseAsync(
-          ctx,
-          depth,
-          createSequenceFromIterable(
-            properties as unknown as Iterable<unknown>,
-          ),
-        )) as SerovalNodeWithID,
-      ),
-    );
-  }
-  if (SYM_ASYNC_ITERATOR in properties) {
-    keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));
-    valueNodes.push(
-      createAsyncIteratorFactoryInstanceNode(
-        parseAsyncIteratorFactory(ctx.base),
-        (await parseAsync(
-          ctx,
-          depth,
-          createStreamFromAsyncIterable(
-            properties as unknown as AsyncIterable<unknown>,
-          ),
-        )) as SerovalNodeWithID,
-      ),
-    );
-  }
-  if (SYM_TO_STRING_TAG in properties) {
-    keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));
-    valueNodes.push(createStringNode(properties[SYM_TO_STRING_TAG] as string));
-  }
-  if (SYM_IS_CONCAT_SPREADABLE in properties) {
-    keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_IS_CONCAT_SPREADABLE));
-    valueNodes.push(
-      properties[SYM_IS_CONCAT_SPREADABLE] ? TRUE_NODE : FALSE_NODE,
-    );
-  }
-  return {
-    k: keyNodes,
-    v: valueNodes,
-  };
-}
-
-async function parsePlainObject(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: Record<string, unknown>,
-  empty: boolean,
-): Promise<ObjectLikeNode> {
-  return createObjectNode(
-    id,
-    current,
-    empty,
-    await parseProperties(ctx, depth, current),
-  );
-}
-
-// TODO: check if parseBoxedSync can be used
-async function parseBoxed(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: object,
-): Promise<SerovalBoxedNode> {
-  return createBoxedNode(id, await parseAsync(ctx, depth, current.valueOf()));
-}
-
-async function parseTypedArray(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: TypedArrayValue,
-): Promise<SerovalTypedArrayNode> {
-  return createTypedArrayNode(
-    id,
-    current,
-    await parseAsync(ctx, depth, current.buffer),
-  );
-}
-
-async function parseBigIntTypedArray(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: BigIntTypedArrayValue,
-): Promise<SerovalBigIntTypedArrayNode> {
-  return createBigIntTypedArrayNode(
-    id,
-    current,
-    await parseAsync(ctx, depth, current.buffer),
-  );
-}
-
-async function parseDataView(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: DataView,
-): Promise<SerovalDataViewNode> {
-  return createDataViewNode(
-    id,
-    current,
-    await parseAsync(ctx, depth, current.buffer),
-  );
-}
-
-async function parseError(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: Error,
-): Promise<SerovalErrorNode> {
-  const options = getErrorOptions(current, ctx.base.features);
-  return createErrorNode(
-    id,
-    current,
-    options ? await parseProperties(ctx, depth, options) : NIL,
-  );
-}
-
-async function parseAggregateError(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: AggregateError,
-): Promise<SerovalAggregateErrorNode> {
-  const options = getErrorOptions(current, ctx.base.features);
-  return createAggregateErrorNode(
-    id,
-    current,
-    options ? await parseProperties(ctx, depth, options) : NIL,
-  );
-}
-
-async function parseMap(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: Map<unknown, unknown>,
-): Promise<SerovalMapNode> {
-  const keyNodes: SerovalNode[] = [];
-  const valueNodes: SerovalNode[] = [];
-  for (const [key, value] of current.entries()) {
-    keyNodes.push(await parseAsync(ctx, depth, key));
-    valueNodes.push(await parseAsync(ctx, depth, value));
-  }
-  return createMapNode(ctx.base, id, keyNodes, valueNodes);
-}
-
-async function parseSet(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: Set<unknown>,
-): Promise<SerovalSetNode> {
-  const items: SerovalNode[] = [];
-  for (const item of current.keys()) {
-    items.push(await parseAsync(ctx, depth, item));
-  }
-  return createSetNode(id, items);
-}
-
-async function parsePlugin(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: unknown,
-): Promise<SerovalPluginNode | undefined> {
-  const currentPlugins = ctx.base.plugins;
-  if (currentPlugins) {
-    for (let i = 0, len = currentPlugins.length; i < len; i++) {
-      const plugin = currentPlugins[i];
-      if (plugin.parse.async && plugin.test(current)) {
-        return createPluginNode(
-          id,
-          plugin.tag,
-          await plugin.parse.async(
-            current,
-            new AsyncParsePluginContext(ctx, depth),
-            {
-              id,
-            },
-          ),
-        );
-      }
-    }
-  }
-  return NIL;
-}
-
-async function parsePromise(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: Promise<unknown>,
-): Promise<SerovalPromiseNode> {
-  const [status, result] = await promiseToResult(current);
-
-  return createSerovalNode(
-    SerovalNodeType.Promise,
-    id,
-    status,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    await parseAsync(ctx, depth, result),
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-function parseStreamHandle<T>(
-  this: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: Stream<T>,
-  resolve: (value: SerovalNode[] | PromiseLike<SerovalNode[]>) => void,
-  reject: (reason?: any) => void,
-): void {
-  const sequence: SerovalNode[] = [];
-  // TODO Optimizable
-  const cleanup = current.on({
-    next: value => {
-      markParserRef(this.base, id);
-      parseAsync(this, depth, value).then(
-        data => {
-          sequence.push(createStreamNextNode(id, data));
-        },
-        data => {
-          reject(data);
-          cleanup();
-        },
-      );
-    },
-    throw: value => {
-      markParserRef(this.base, id);
-      parseAsync(this, depth, value).then(
-        data => {
-          sequence.push(createStreamThrowNode(id, data));
-          resolve(sequence);
-          cleanup();
-        },
-        data => {
-          reject(data);
-          cleanup();
-        },
-      );
-    },
-    return: value => {
-      markParserRef(this.base, id);
-      parseAsync(this, depth, value).then(
-        data => {
-          sequence.push(createStreamReturnNode(id, data));
-          resolve(sequence);
-          cleanup();
-        },
-        data => {
-          reject(data);
-          cleanup();
-        },
-      );
-    },
-  });
-}
-
-async function parseStream(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: Stream<unknown>,
-): Promise<SerovalStreamConstructorNode> {
-  return createStreamConstructorNode(
-    id,
-    parseSpecialReference(ctx.base, SpecialReference.StreamConstructor),
-    await new Promise<SerovalNode[]>(
-      parseStreamHandle.bind(ctx, depth, id, current),
-    ),
-  );
-}
-
-async function parseSequence(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: Sequence,
-): Promise<SerovalSequenceNode> {
-  const nodes: SerovalNode[] = [];
-  for (let i = 0, len = current.v.length; i < len; i++) {
-    nodes[i] = await parseAsync(ctx, depth, current.v[i]);
-  }
-  return createSequenceNode(id, nodes, current.t, current.d);
-}
-
-export async function parseObjectAsync(
-  ctx: AsyncParserContext,
-  depth: number,
-  id: number,
-  current: object,
-): Promise<SerovalNode> {
-  if (Array.isArray(current)) {
-    return parseArray(ctx, depth, id, current);
-  }
-  if (isStream(current)) {
-    return parseStream(ctx, depth, id, current);
-  }
-  if (isSequence(current)) {
-    return parseSequence(ctx, depth, id, current);
-  }
-  const currentClass = current.constructor;
-  if (currentClass === OpaqueReference) {
-    return parseAsync(
-      ctx,
-      depth,
-      (current as OpaqueReference<unknown, unknown>).replacement,
-    );
-  }
-  const parsed = await parsePlugin(ctx, depth, id, current);
-  if (parsed) {
-    return parsed;
-  }
-  switch (currentClass) {
-    case Object:
-      return parsePlainObject(
-        ctx,
-        depth,
-        id,
-        current as Record<string, unknown>,
-        false,
-      );
-    case NIL:
-      return parsePlainObject(
-        ctx,
-        depth,
-        id,
-        current as Record<string, unknown>,
-        true,
-      );
-    case Date:
-      return createDateNode(id, current as unknown as Date);
-    case Error:
-    case EvalError:
-    case RangeError:
-    case ReferenceError:
-    case SyntaxError:
-    case TypeError:
-    case URIError:
-      return parseError(ctx, depth, id, current as unknown as Error);
-    case Number:
-    case Boolean:
-    case String:
-    case BigInt:
-      return parseBoxed(ctx, depth, id, current);
-    case ArrayBuffer:
-      return createArrayBufferNode(
-        ctx.base,
-        id,
-        current as unknown as ArrayBuffer,
-      );
-    case Int8Array:
-    case Int16Array:
-    case Int32Array:
-    case Uint8Array:
-    case Uint16Array:
-    case Uint32Array:
-    case Uint8ClampedArray:
-    case Float32Array:
-    case Float64Array:
-      return parseTypedArray(
-        ctx,
-        depth,
-        id,
-        current as unknown as TypedArrayValue,
-      );
-    case DataView:
-      return parseDataView(ctx, depth, id, current as unknown as DataView);
-    case Map:
-      return parseMap(
-        ctx,
-        depth,
-        id,
-        current as unknown as Map<unknown, unknown>,
-      );
-    case Set:
-      return parseSet(ctx, depth, id, current as unknown as Set<unknown>);
-    default:
-      break;
-  }
-  // Promises
-  if (currentClass === Promise || current instanceof Promise) {
-    return parsePromise(ctx, depth, id, current as unknown as Promise<unknown>);
-  }
-  const currentFeatures = ctx.base.features;
-  if (currentFeatures & Feature.RegExp && currentClass === RegExp) {
-    return createRegExpNode(id, current as unknown as RegExp);
-  }
-  // BigInt Typed Arrays
-  if (currentFeatures & Feature.BigIntTypedArray) {
-    switch (currentClass) {
-      case BigInt64Array:
-      case BigUint64Array:
-        return parseBigIntTypedArray(
-          ctx,
-          depth,
-          id,
-          current as unknown as BigIntTypedArrayValue,
-        );
-      default:
-        break;
-    }
-  }
-  if (
-    currentFeatures & Feature.AggregateError &&
-    typeof AggregateError !== 'undefined' &&
-    (currentClass === AggregateError || current instanceof AggregateError)
-  ) {
-    return parseAggregateError(
-      ctx,
-      depth,
-      id,
-      current as unknown as AggregateError,
-    );
-  }
-  // Slow path. We only need to handle Errors and Iterators
-  // since they have very broad implementations.
-  if (current instanceof Error) {
-    return parseError(ctx, depth, id, current);
-  }
-  // Generator functions don't have a global constructor
-  // despite existing
-  if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) {
-    return parsePlainObject(ctx, depth, id, current, !!currentClass);
-  }
-  throw new SerovalUnsupportedTypeError(current);
-}
-
-export async function parseFunctionAsync(
-  ctx: AsyncParserContext,
-  depth: number,
-  current: unknown,
-): Promise<SerovalNode> {
-  const ref = getReferenceNode(ctx.base, current);
-  if (ref.type !== ParserNodeType.Fresh) {
-    return ref.value;
-  }
-  const plugin = await parsePlugin(ctx, depth, ref.value, current);
-  if (plugin) {
-    return plugin;
-  }
-  throw new SerovalUnsupportedTypeError(current);
-}
-
-export async function parseAsync<T>(
-  ctx: AsyncParserContext,
-  depth: number,
-  current: T,
-): Promise<SerovalNode> {
-  if (depth >= ctx.base.depthLimit) {
-    throw new SerovalDepthLimitError(ctx.base.depthLimit);
-  }
-  switch (typeof current) {
-    case 'boolean':
-      return current ? TRUE_NODE : FALSE_NODE;
-    case 'undefined':
-      return UNDEFINED_NODE;
-    case 'string':
-      return createStringNode(current as string);
-    case 'number':
-      return createNumberNode(current as number);
-    case 'bigint':
-      return createBigIntNode(current as bigint);
-    case 'object': {
-      if (current) {
-        const ref = getReferenceNode(ctx.base, current);
-        return ref.type === 0
-          ? await parseObjectAsync(ctx, depth + 1, ref.value, current as object)
-          : ref.value;
-      }
-      return NULL_NODE;
-    }
-    case 'symbol':
-      return parseWellKnownSymbol(ctx.base, current);
-    case 'function':
-      return parseFunctionAsync(ctx, depth, current);
-    default:
-      throw new SerovalUnsupportedTypeError(current);
-  }
-}
-
-export async function parseTopAsync<T>(
-  ctx: AsyncParserContext,
-  current: T,
-): Promise<SerovalNode> {
-  try {
-    return await parseAsync(ctx, 0, current);
-  } catch (error) {
-    throw error instanceof SerovalParserError
-      ? error
-      : new SerovalParserError(error);
-  }
-}

src/core/context/deserializer.ts

-import { ALL_ENABLED, Feature } from '../compat';
-import {
-  CONSTANT_VAL,
-  ERROR_CONSTRUCTOR,
-  NIL,
-  SerovalNodeType,
-  SerovalObjectFlags,
-  SYMBOL_REF,
-} from '../constants';
-import {
-  ARRAY_BUFFER_CONSTRUCTOR,
-  PROMISE_CONSTRUCTOR,
-  type PromiseConstructorResolver,
-} from '../constructors';
-import {
-  SerovalDepthLimitError,
-  SerovalDeserializationError,
-  SerovalMalformedNodeError,
-  SerovalMissingInstanceError,
-  SerovalMissingPluginError,
-  SerovalUnsupportedNodeError,
-} from '../errors';
-import type { PluginAccessOptions } from '../plugin';
-import { SerovalMode } from '../plugin';
-import { getReference } from '../reference';
-import { createSequence, type Sequence, sequenceToIterator } from '../sequence';
-import type { Stream } from '../stream';
-import { createStream, streamToAsyncIterable } from '../stream';
-import { deserializeString } from '../string';
-import type {
-  SerovalAggregateErrorNode,
-  SerovalArrayBufferNode,
-  SerovalArrayNode,
-  SerovalAsyncIteratorFactoryInstanceNode,
-  SerovalAsyncIteratorFactoryNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalBoxedNode,
-  SerovalDataViewNode,
-  SerovalDateNode,
-  SerovalErrorNode,
-  SerovalIteratorFactoryInstanceNode,
-  SerovalIteratorFactoryNode,
-  SerovalMapNode,
-  SerovalNode,
-  SerovalNullConstructorNode,
-  SerovalObjectNode,
-  SerovalObjectRecordNode,
-  SerovalPluginNode,
-  SerovalPromiseConstructorNode,
-  SerovalPromiseNode,
-  SerovalPromiseRejectNode,
-  SerovalPromiseResolveNode,
-  SerovalReferenceNode,
-  SerovalRegExpNode,
-  SerovalSequenceNode,
-  SerovalSetNode,
-  SerovalStreamConstructorNode,
-  SerovalStreamNextNode,
-  SerovalStreamReturnNode,
-  SerovalStreamThrowNode,
-  SerovalTypedArrayNode,
-} from '../types';
-import type {
-  BigIntTypedArrayValue,
-  TypedArrayValue,
-} from '../utils/typed-array';
-import { getTypedArrayConstructor } from '../utils/typed-array';
-import { isValidKey, isValidSymbol } from '../utils/valid-properties';
-
-const MAX_BASE64_LENGTH = 1_000_000; // ~0.75MB decoded
-const MAX_BIGINT_LENGTH = 10_000;
-const MAX_REGEXP_SOURCE_LENGTH = 20_000;
-
-function applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {
-  switch (flag) {
-    case SerovalObjectFlags.Frozen:
-      return Object.freeze(obj);
-    case SerovalObjectFlags.NonExtensible:
-      return Object.preventExtensions(obj);
-    case SerovalObjectFlags.Sealed:
-      return Object.seal(obj);
-    default:
-      return obj;
-  }
-}
-
-type AssignableValue = AggregateError | Error | Iterable<unknown>;
-type AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode;
-
-export interface BaseDeserializerContextOptions extends PluginAccessOptions {
-  refs?: Map<number, unknown>;
-  features?: number;
-  disabledFeatures?: number;
-  depthLimit?: number;
-}
-
-export interface BaseDeserializerContext extends PluginAccessOptions {
-  readonly mode: SerovalMode;
-  /**
-   * Mapping ids to values
-   */
-  refs: Map<number, unknown> & { types: Map<number, SerovalNodeType> };
-  features: number;
-  depthLimit: number;
-}
-
-const DEFAULT_DEPTH_LIMIT = 1000;
-
-export function createBaseDeserializerContext(
-  mode: SerovalMode,
-  options: BaseDeserializerContextOptions,
-): BaseDeserializerContext {
-  const refs = options.refs || new Map();
-  if (!('types' in refs)) {
-    Object.assign(refs, {
-      types: new Map(),
-    });
-  }
-  return {
-    mode,
-    plugins: options.plugins,
-    refs: refs as BaseDeserializerContext['refs'],
-    features: options.features ?? ALL_ENABLED ^ (options.disabledFeatures || 0),
-    depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT,
-  };
-}
-
-export interface VanillaDeserializerContextOptions
-  extends Omit<BaseDeserializerContextOptions, 'refs'> {
-  markedRefs: number[] | Set<number>;
-}
-
-export interface VanillaDeserializerState {
-  marked: Set<number>;
-}
-
-export interface VanillaDeserializerContext {
-  mode: SerovalMode.Vanilla;
-  base: BaseDeserializerContext;
-  child: DeserializePluginContext | undefined;
-  state: VanillaDeserializerState;
-}
-
-export function createVanillaDeserializerContext(
-  options: VanillaDeserializerContextOptions,
-): VanillaDeserializerContext {
-  return {
-    mode: SerovalMode.Vanilla,
-    base: createBaseDeserializerContext(SerovalMode.Vanilla, options),
-    child: NIL,
-    state: {
-      marked: new Set(options.markedRefs),
-    },
-  };
-}
-
-export interface CrossDeserializerContext {
-  mode: SerovalMode.Cross;
-  base: BaseDeserializerContext;
-  child: DeserializePluginContext | undefined;
-}
-
-export type CrossDeserializerContextOptions = BaseDeserializerContextOptions;
-
-export function createCrossDeserializerContext(
-  options: CrossDeserializerContextOptions,
-): CrossDeserializerContext {
-  return {
-    mode: SerovalMode.Cross,
-    base: createBaseDeserializerContext(SerovalMode.Cross, options),
-    child: NIL,
-  };
-}
-
-type DeserializerContext =
-  | VanillaDeserializerContext
-  | CrossDeserializerContext;
-
-export class DeserializePluginContext {
-  constructor(
-    private _p: DeserializerContext,
-    private depth: number,
-  ) {}
-
-  deserialize<T>(node: SerovalNode): T {
-    return deserialize(this._p, this.depth, node) as T;
-  }
-}
-
-function guardIndexedValue(ctx: BaseDeserializerContext, id: number): void {
-  if (id < 0 || !Number.isFinite(id) || !Number.isInteger(id)) {
-    throw new SerovalMalformedNodeError({
-      t: SerovalNodeType.IndexedValue,
-      i: id,
-    } as SerovalNode);
-  }
-  if (ctx.refs.has(id)) {
-    throw new Error('Conflicted ref id: ' + id);
-  }
-}
-
-function assignIndexedValueVanilla<T>(
-  ctx: VanillaDeserializerContext,
-  id: number,
-  value: T,
-): T {
-  guardIndexedValue(ctx.base, id);
-  if (ctx.state.marked.has(id)) {
-    ctx.base.refs.set(id, value);
-  }
-  return value;
-}
-
-function assignIndexedValueCross<T>(
-  ctx: CrossDeserializerContext,
-  id: number,
-  value: T,
-): T {
-  guardIndexedValue(ctx.base, id);
-  ctx.base.refs.set(id, value);
-  return value;
-}
-
-function assignIndexedValue<T>(
-  ctx: DeserializerContext,
-  id: number,
-  value: T,
-): T {
-  return ctx.mode === SerovalMode.Vanilla
-    ? assignIndexedValueVanilla(ctx, id, value)
-    : assignIndexedValueCross(ctx, id, value);
-}
-
-function deserializeKnownValue<
-  T extends Record<string, unknown>,
-  K extends keyof T,
->(node: SerovalNode, record: T, key: K): T[K] {
-  if (Object.hasOwn(record, key)) {
-    return record[key];
-  }
-  throw new SerovalMalformedNodeError(node);
-}
-
-function deserializeReference(
-  ctx: DeserializerContext,
-  node: SerovalReferenceNode,
-): unknown {
-  return assignIndexedValue(
-    ctx,
-    node.i,
-    getReference(deserializeString(node.s)),
-  );
-}
-
-function deserializeArray(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalArrayNode,
-): unknown[] {
-  const items = node.a;
-  const len = items.length;
-  const result: unknown[] = assignIndexedValue(
-    ctx,
-    node.i,
-    new Array<unknown>(len),
-  );
-  for (let i = 0, item: SerovalNode | 0; i < len; i++) {
-    item = items[i];
-    if (item) {
-      result[i] = deserialize(ctx, depth, item);
-    }
-  }
-  applyObjectFlag(result, node.o);
-  return result;
-}
-
-function assignStringProperty(
-  object: Record<string | symbol, unknown>,
-  key: string,
-  value: unknown,
-): void {
-  if (isValidKey(key)) {
-    object[key] = value;
-  } else {
-    Object.defineProperty(object, key, {
-      value,
-      configurable: true,
-      enumerable: true,
-      writable: true,
-    });
-  }
-}
-
-function assignProperty(
-  ctx: DeserializerContext,
-  depth: number,
-  object: Record<string | symbol, unknown>,
-  key: string | SerovalNode,
-  value: SerovalNode,
-): void {
-  if (typeof key === 'string') {
-    assignStringProperty(
-      object,
-      deserializeString(key),
-      deserialize(ctx, depth, value),
-    );
-  } else {
-    const actual = deserialize(ctx, depth, key);
-    switch (typeof actual) {
-      case 'string':
-        assignStringProperty(object, actual, deserialize(ctx, depth, value));
-        break;
-      case 'symbol':
-        if (isValidSymbol(actual)) {
-          object[actual] = deserialize(ctx, depth, value);
-        }
-        break;
-      default:
-        throw new SerovalMalformedNodeError(key);
-    }
-  }
-}
-
-function assignNodeType(
-  ctx: DeserializerContext,
-  id: number,
-  type: SerovalNodeType,
-): void {
-  ctx.base.refs.types.set(id, type);
-}
-
-function validateNodeType(
-  ctx: DeserializerContext,
-  node: SerovalNode,
-  id: number,
-  type: SerovalNodeType,
-): asserts id is SerovalNodeType {
-  if (ctx.base.refs.types.get(id) !== type) {
-    throw new SerovalMalformedNodeError(node);
-  }
-}
-
-function deserializeProperties(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalObjectRecordNode,
-  result: Record<string | symbol, unknown>,
-): Record<string | symbol, unknown> {
-  const keys = node.k;
-  const len = keys.length;
-  if (len > 0) {
-    for (let i = 0, vals = node.v, len = keys.length; i < len; i++) {
-      assignProperty(ctx, depth, result, keys[i], vals[i]);
-    }
-  }
-  return result;
-}
-
-function deserializeObject(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalObjectNode | SerovalNullConstructorNode,
-): Record<string, unknown> {
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    (node.t === SerovalNodeType.Object ? {} : Object.create(null)) as Record<
-      string,
-      unknown
-    >,
-  );
-  deserializeProperties(ctx, depth, node.p, result);
-  applyObjectFlag(result, node.o);
-  return result;
-}
-
-function deserializeDate(
-  ctx: DeserializerContext,
-  node: SerovalDateNode,
-): Date {
-  return assignIndexedValue(ctx, node.i, new Date(node.s));
-}
-
-function deserializeRegExp(
-  ctx: DeserializerContext,
-  node: SerovalRegExpNode,
-): RegExp {
-  if (ctx.base.features & Feature.RegExp) {
-    const source = deserializeString(node.c);
-    if (source.length > MAX_REGEXP_SOURCE_LENGTH) {
-      throw new SerovalMalformedNodeError(node);
-    }
-    return assignIndexedValue(ctx, node.i, new RegExp(source, node.m));
-  }
-  throw new SerovalUnsupportedNodeError(node);
-}
-
-function deserializeSet(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalSetNode,
-): Set<unknown> {
-  const result = assignIndexedValue(ctx, node.i, new Set<unknown>());
-  for (let i = 0, items = node.a, len = items.length; i < len; i++) {
-    result.add(deserialize(ctx, depth, items[i]));
-  }
-  return result;
-}
-
-function deserializeMap(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalMapNode,
-): Map<unknown, unknown> {
-  const result = assignIndexedValue(ctx, node.i, new Map<unknown, unknown>());
-  for (
-    let i = 0, keys = node.e.k, vals = node.e.v, len = keys.length;
-    i < len;
-    i++
-  ) {
-    result.set(
-      deserialize(ctx, depth, keys[i]),
-      deserialize(ctx, depth, vals[i]),
-    );
-  }
-  return result;
-}
-
-function deserializeArrayBuffer(
-  ctx: DeserializerContext,
-  node: SerovalArrayBufferNode,
-): ArrayBuffer {
-  if (node.s.length > MAX_BASE64_LENGTH) {
-    throw new SerovalMalformedNodeError(node);
-  }
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    ARRAY_BUFFER_CONSTRUCTOR(deserializeString(node.s)),
-  );
-  return result;
-}
-
-function deserializeTypedArray(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
-): TypedArrayValue | BigIntTypedArrayValue {
-  const construct = getTypedArrayConstructor(node.c) as Int8ArrayConstructor;
-  const source = deserialize(ctx, depth, node.f) as ArrayBuffer;
-  const offset = node.b ?? 0;
-  if (offset < 0 || offset > source.byteLength) {
-    throw new SerovalMalformedNodeError(node);
-  }
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new construct(source, offset, node.l),
-  );
-  return result;
-}
-
-function deserializeDataView(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalDataViewNode,
-): DataView {
-  const source = deserialize(ctx, depth, node.f) as ArrayBuffer;
-  const offset = node.b ?? 0;
-  if (offset < 0 || offset > source.byteLength) {
-    throw new SerovalMalformedNodeError(node);
-  }
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new DataView(source, offset, node.l),
-  );
-  return result;
-}
-
-function deserializeDictionary<T extends AssignableValue>(
-  ctx: DeserializerContext,
-  depth: number,
-  node: AssignableNode,
-  result: T,
-): T {
-  if (node.p) {
-    const fields = deserializeProperties(ctx, depth, node.p, {});
-    Object.defineProperties(result, Object.getOwnPropertyDescriptors(fields));
-  }
-  return result;
-}
-
-function deserializeAggregateError(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalAggregateErrorNode,
-): AggregateError {
-  // Serialize the required arguments
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new AggregateError([], deserializeString(node.m)),
-  );
-  // `AggregateError` might've been extended
-  // either through class or custom properties
-  // Make sure to assign extra properties
-  return deserializeDictionary(ctx, depth, node, result);
-}
-
-function deserializeError(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalErrorNode,
-): Error {
-  const construct = deserializeKnownValue(node, ERROR_CONSTRUCTOR, node.s);
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new construct(deserializeString(node.m)),
-  );
-  return deserializeDictionary(ctx, depth, node, result);
-}
-
-function deserializePromise(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalPromiseNode,
-): Promise<unknown> {
-  const deferred = PROMISE_CONSTRUCTOR();
-  const result = assignIndexedValue(ctx, node.i, deferred.p);
-  const deserialized = deserialize(ctx, depth, node.f);
-  if (node.s) {
-    deferred.s(deserialized);
-  } else {
-    deferred.f(deserialized);
-  }
-  return result;
-}
-
-function deserializeBoxed(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalBoxedNode,
-): unknown {
-  return assignIndexedValue(
-    ctx,
-    node.i,
-    // biome-ignore lint/style/useConsistentBuiltinInstantiation: intended
-    Object(deserialize(ctx, depth, node.f)),
-  );
-}
-
-function deserializePlugin(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalPluginNode,
-): unknown {
-  const currentPlugins = ctx.base.plugins;
-  if (currentPlugins) {
-    const tag = deserializeString(node.c);
-    for (let i = 0, len = currentPlugins.length; i < len; i++) {
-      const plugin = currentPlugins[i];
-      if (plugin.tag === tag) {
-        return assignIndexedValue(
-          ctx,
-          node.i,
-          plugin.deserialize(node.s, new DeserializePluginContext(ctx, depth), {
-            id: node.i,
-          }),
-        );
-      }
-    }
-  }
-  throw new SerovalMissingPluginError(node.c);
-}
-
-function deserializePromiseConstructor(
-  ctx: DeserializerContext,
-  node: SerovalPromiseConstructorNode,
-): unknown {
-  const value = assignIndexedValue(
-    ctx,
-    node.i,
-    assignIndexedValue(ctx, node.s, PROMISE_CONSTRUCTOR()).p,
-  );
-  assignNodeType(ctx, node.s, SerovalNodeType.PromiseConstructor);
-  return value;
-}
-
-function deserializePromiseResolve(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalPromiseResolveNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as
-    | PromiseConstructorResolver
-    | undefined;
-  if (deferred) {
-    validateNodeType(ctx, node, node.i, SerovalNodeType.PromiseConstructor);
-    deferred.s(deserialize(ctx, depth, node.a[1]));
-    return NIL;
-  }
-  throw new SerovalMissingInstanceError('Promise');
-}
-
-function deserializePromiseReject(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalPromiseRejectNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as
-    | PromiseConstructorResolver
-    | undefined;
-  if (deferred) {
-    validateNodeType(ctx, node, node.i, SerovalNodeType.PromiseConstructor);
-    deferred.f(deserialize(ctx, depth, node.a[1]));
-    return NIL;
-  }
-  throw new SerovalMissingInstanceError('Promise');
-}
-
-function deserializeIteratorFactoryInstance(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalIteratorFactoryInstanceNode,
-): unknown {
-  deserialize(ctx, depth, node.a[0]);
-  const source = deserialize(ctx, depth, node.a[1]);
-  return sequenceToIterator(source as Sequence);
-}
-
-function deserializeAsyncIteratorFactoryInstance(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalAsyncIteratorFactoryInstanceNode,
-): unknown {
-  deserialize(ctx, depth, node.a[0]);
-  const source = deserialize(ctx, depth, node.a[1]);
-  return streamToAsyncIterable(source as Stream<any>);
-}
-
-function deserializeStreamConstructor(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalStreamConstructorNode,
-): unknown {
-  const result = assignIndexedValue(ctx, node.i, createStream());
-  assignNodeType(ctx, node.i, SerovalNodeType.StreamConstructor);
-  const items = node.a;
-  const len = items.length;
-  if (len) {
-    for (let i = 0; i < len; i++) {
-      deserialize(ctx, depth, items[i]);
-    }
-  }
-  return result;
-}
-
-function deserializeStreamNext(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalStreamNextNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
-  if (deferred) {
-    validateNodeType(ctx, node, node.i, SerovalNodeType.StreamConstructor);
-    deferred.next(deserialize(ctx, depth, node.f));
-    return NIL;
-  }
-  throw new SerovalMissingInstanceError('Stream');
-}
-
-function deserializeStreamThrow(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalStreamThrowNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
-  if (deferred) {
-    validateNodeType(ctx, node, node.i, SerovalNodeType.StreamConstructor);
-    deferred.throw(deserialize(ctx, depth, node.f));
-    return NIL;
-  }
-  throw new SerovalMissingInstanceError('Stream');
-}
-
-function deserializeStreamReturn(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalStreamReturnNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
-  if (deferred) {
-    validateNodeType(ctx, node, node.i, SerovalNodeType.StreamConstructor);
-    deferred.return(deserialize(ctx, depth, node.f));
-    return NIL;
-  }
-  throw new SerovalMissingInstanceError('Stream');
-}
-
-function deserializeIteratorFactory(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalIteratorFactoryNode,
-): unknown {
-  deserialize(ctx, depth, node.f);
-  return NIL;
-}
-
-function deserializeAsyncIteratorFactory(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalAsyncIteratorFactoryNode,
-): unknown {
-  deserialize(ctx, depth, node.a[1]);
-  return NIL;
-}
-
-function deserializeSequence(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalSequenceNode,
-): Sequence {
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    createSequence([], node.s, node.l),
-  );
-  for (let i = 0, len = node.a.length; i < len; i++) {
-    result.v[i] = deserialize(ctx, depth, node.a[i]);
-  }
-  return result;
-}
-
-function deserialize(
-  ctx: DeserializerContext,
-  depth: number,
-  node: SerovalNode,
-): unknown {
-  if (depth > ctx.base.depthLimit) {
-    throw new SerovalDepthLimitError(ctx.base.depthLimit);
-  }
-  depth += 1;
-  switch (node.t) {
-    case SerovalNodeType.Constant:
-      return deserializeKnownValue(node, CONSTANT_VAL, node.s);
-    case SerovalNodeType.Number:
-      return Number(node.s);
-    case SerovalNodeType.String:
-      return deserializeString(String(node.s));
-    case SerovalNodeType.BigInt:
-      if (String(node.s).length > MAX_BIGINT_LENGTH) {
-        throw new SerovalMalformedNodeError(node);
-      }
-      return BigInt(node.s);
-    case SerovalNodeType.IndexedValue:
-      return ctx.base.refs.get(node.i);
-    case SerovalNodeType.Reference:
-      return deserializeReference(ctx, node);
-    case SerovalNodeType.Array:
-      return deserializeArray(ctx, depth, node);
-    case SerovalNodeType.Object:
-    case SerovalNodeType.NullConstructor:
-      return deserializeObject(ctx, depth, node);
-    case SerovalNodeType.Date:
-      return deserializeDate(ctx, node);
-    case SerovalNodeType.RegExp:
-      return deserializeRegExp(ctx, node);
-    case SerovalNodeType.Set:
-      return deserializeSet(ctx, depth, node);
-    case SerovalNodeType.Map:
-      return deserializeMap(ctx, depth, node);
-    case SerovalNodeType.ArrayBuffer:
-      return deserializeArrayBuffer(ctx, node);
-    case SerovalNodeType.BigIntTypedArray:
-    case SerovalNodeType.TypedArray:
-      return deserializeTypedArray(ctx, depth, node);
-    case SerovalNodeType.DataView:
-      return deserializeDataView(ctx, depth, node);
-    case SerovalNodeType.AggregateError:
-      return deserializeAggregateError(ctx, depth, node);
-    case SerovalNodeType.Error:
-      return deserializeError(ctx, depth, node);
-    case SerovalNodeType.Promise:
-      return deserializePromise(ctx, depth, node);
-    case SerovalNodeType.WKSymbol:
-      return deserializeKnownValue(node, SYMBOL_REF, node.s);
-    case SerovalNodeType.Boxed:
-      return deserializeBoxed(ctx, depth, node);
-    case SerovalNodeType.Plugin:
-      return deserializePlugin(ctx, depth, node);
-    case SerovalNodeType.PromiseConstructor:
-      return deserializePromiseConstructor(ctx, node);
-    case SerovalNodeType.PromiseSuccess:
-      return deserializePromiseResolve(ctx, depth, node);
-    case SerovalNodeType.PromiseFailure:
-      return deserializePromiseReject(ctx, depth, node);
-    case SerovalNodeType.IteratorFactoryInstance:
-      return deserializeIteratorFactoryInstance(ctx, depth, node);
-    case SerovalNodeType.AsyncIteratorFactoryInstance:
-      return deserializeAsyncIteratorFactoryInstance(ctx, depth, node);
-    case SerovalNodeType.StreamConstructor:
-      return deserializeStreamConstructor(ctx, depth, node);
-    case SerovalNodeType.StreamNext:
-      return deserializeStreamNext(ctx, depth, node);
-    case SerovalNodeType.StreamThrow:
-      return deserializeStreamThrow(ctx, depth, node);
-    case SerovalNodeType.StreamReturn:
-      return deserializeStreamReturn(ctx, depth, node);
-    case SerovalNodeType.IteratorFactory:
-      return deserializeIteratorFactory(ctx, depth, node);
-    case SerovalNodeType.AsyncIteratorFactory:
-      return deserializeAsyncIteratorFactory(ctx, depth, node);
-    // case SerovalNodeType.SpecialReference:
-    case SerovalNodeType.Sequence:
-      return deserializeSequence(ctx, depth, node);
-    default:
-      throw new SerovalUnsupportedNodeError(node);
-  }
-}
-
-export function deserializeTop(
-  ctx: DeserializerContext,
-  node: SerovalNode,
-): unknown {
-  try {
-    return deserialize(ctx, 0, node);
-  } catch (error) {
-    throw new SerovalDeserializationError(error);
-  }
-}

src/core/context/parser.ts

-import {
-  createIndexedValueNode,
-  createReferenceNode,
-  createWKSymbolNode,
-} from '../base-primitives';
-import { ALL_ENABLED } from '../compat';
-import type { WellKnownSymbols } from '../constants';
-import { INV_SYMBOL_REF, NIL, SerovalNodeType } from '../constants';
-import { SerovalUnsupportedTypeError } from '../errors';
-import { createSerovalNode } from '../node';
-import type { PluginAccessOptions, SerovalMode } from '../plugin';
-import { hasReferenceID } from '../reference';
-import {
-  ASYNC_ITERATOR,
-  ITERATOR,
-  SPECIAL_REFS,
-  SpecialReference,
-} from '../special-reference';
-import { serializeString } from '../string';
-import { SYM_ASYNC_ITERATOR, SYM_ITERATOR } from '../symbols';
-import type {
-  SerovalArrayBufferNode,
-  SerovalAsyncIteratorFactoryNode,
-  SerovalIndexedValueNode,
-  SerovalIteratorFactoryNode,
-  SerovalMapNode,
-  SerovalNode,
-  SerovalNullConstructorNode,
-  SerovalObjectNode,
-  SerovalObjectRecordNode,
-  SerovalPromiseConstructorNode,
-  SerovalReferenceNode,
-  SerovalSpecialReferenceNode,
-  SerovalWKSymbolNode,
-} from '../types';
-import { getObjectFlag } from '../utils/get-object-flag';
-
-export interface BaseParserContextOptions extends PluginAccessOptions {
-  disabledFeatures?: number;
-  refs?: Map<unknown, number>;
-  depthLimit?: number;
-}
-
-export const enum ParserNodeType {
-  Fresh = 0,
-  Indexed = 1,
-  Referenced = 2,
-}
-
-export interface FreshNode {
-  type: ParserNodeType.Fresh;
-  value: number;
-}
-
-export interface IndexedNode {
-  type: ParserNodeType.Indexed;
-  value: SerovalIndexedValueNode;
-}
-
-export interface ReferencedNode {
-  type: ParserNodeType.Referenced;
-  value: SerovalReferenceNode;
-}
-
-type ObjectNode = FreshNode | IndexedNode | ReferencedNode;
-
-export interface BaseParserContext extends PluginAccessOptions {
-  readonly mode: SerovalMode;
-
-  marked: Set<number>;
-
-  refs: Map<unknown, number>;
-
-  features: number;
-
-  depthLimit: number;
-}
-
-export function createBaseParserContext(
-  mode: SerovalMode,
-  options: BaseParserContextOptions,
-): BaseParserContext {
-  return {
-    plugins: options.plugins,
-    mode,
-    marked: new Set(),
-    features: ALL_ENABLED ^ (options.disabledFeatures || 0),
-    refs: options.refs || new Map(),
-    depthLimit: options.depthLimit || 1000,
-  };
-}
-
-/**
- * Ensures that the value (based on an identifier) has been visited by the parser.
- * @param ctx
- * @param id
- */
-export function markParserRef(ctx: BaseParserContext, id: number): void {
-  ctx.marked.add(id);
-}
-
-export function isParserRefMarked(ctx: BaseParserContext, id: number): boolean {
-  return ctx.marked.has(id);
-}
-
-/**
- * Creates an identifier for a value
- * @param ctx
- * @param current
- */
-export function createIndexForValue<T>(
-  ctx: BaseParserContext,
-  current: T,
-): number {
-  const id = ctx.refs.size;
-  ctx.refs.set(current, id);
-  return id;
-}
-
-export function getNodeForIndexedValue<T>(
-  ctx: BaseParserContext,
-  current: T,
-): FreshNode | IndexedNode {
-  const registeredId = ctx.refs.get(current);
-  if (registeredId != null) {
-    markParserRef(ctx, registeredId);
-    return {
-      type: ParserNodeType.Indexed,
-      value: createIndexedValueNode(registeredId),
-    };
-  }
-  return {
-    type: ParserNodeType.Fresh,
-    value: createIndexForValue(ctx, current),
-  };
-}
-
-export function getReferenceNode<T>(
-  ctx: BaseParserContext,
-  current: T,
-): ObjectNode {
-  const indexed = getNodeForIndexedValue(ctx, current);
-  if (indexed.type === ParserNodeType.Indexed) {
-    return indexed;
-  }
-  // Special references are special ;)
-  if (hasReferenceID(current)) {
-    return {
-      type: ParserNodeType.Referenced,
-      value: createReferenceNode(indexed.value, current),
-    };
-  }
-  return indexed;
-}
-
-/**
- * Parsing methods
- */
-export function parseWellKnownSymbol(
-  ctx: BaseParserContext,
-  current: symbol,
-): SerovalIndexedValueNode | SerovalWKSymbolNode | SerovalReferenceNode {
-  const ref = getReferenceNode(ctx, current);
-  if (ref.type !== ParserNodeType.Fresh) {
-    return ref.value;
-  }
-  if (current in INV_SYMBOL_REF) {
-    return createWKSymbolNode(ref.value, current as WellKnownSymbols);
-  }
-  throw new SerovalUnsupportedTypeError(current);
-}
-
-export function parseSpecialReference(
-  ctx: BaseParserContext,
-  ref: SpecialReference,
-): SerovalIndexedValueNode | SerovalSpecialReferenceNode {
-  const result = getNodeForIndexedValue(ctx, SPECIAL_REFS[ref]);
-  if (result.type === ParserNodeType.Indexed) {
-    return result.value;
-  }
-  return createSerovalNode(
-    SerovalNodeType.SpecialReference,
-    result.value,
-    ref,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function parseIteratorFactory(
-  ctx: BaseParserContext,
-): SerovalIndexedValueNode | SerovalIteratorFactoryNode {
-  const result = getNodeForIndexedValue(ctx, ITERATOR);
-  if (result.type === ParserNodeType.Indexed) {
-    return result.value;
-  }
-  return createSerovalNode(
-    SerovalNodeType.IteratorFactory,
-    result.value,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    parseWellKnownSymbol(ctx, SYM_ITERATOR),
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function parseAsyncIteratorFactory(
-  ctx: BaseParserContext,
-): SerovalIndexedValueNode | SerovalAsyncIteratorFactoryNode {
-  const result = getNodeForIndexedValue(ctx, ASYNC_ITERATOR);
-  if (result.type === ParserNodeType.Indexed) {
-    return result.value;
-  }
-  return createSerovalNode(
-    SerovalNodeType.AsyncIteratorFactory,
-    result.value,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    [
-      parseSpecialReference(ctx, SpecialReference.PromiseConstructor),
-      parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR),
-    ],
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function createObjectNode(
-  id: number,
-  current: Record<string, unknown>,
-  empty: boolean,
-  record: SerovalObjectRecordNode,
-): SerovalObjectNode | SerovalNullConstructorNode {
-  return createSerovalNode(
-    empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-    id,
-    NIL,
-    NIL,
-    NIL,
-    record,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    getObjectFlag(current),
-    NIL,
-  );
-}
-
-export function createMapNode(
-  ctx: BaseParserContext,
-  id: number,
-  k: SerovalNode[],
-  v: SerovalNode[],
-): SerovalMapNode {
-  return createSerovalNode(
-    SerovalNodeType.Map,
-    id,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    { k, v },
-    NIL,
-    parseSpecialReference(ctx, SpecialReference.MapSentinel),
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function createPromiseConstructorNode(
-  ctx: BaseParserContext,
-  id: number,
-  resolver: number,
-): SerovalPromiseConstructorNode {
-  return createSerovalNode(
-    SerovalNodeType.PromiseConstructor,
-    id,
-    resolver,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    parseSpecialReference(ctx, SpecialReference.PromiseConstructor),
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export function createArrayBufferNode(
-  ctx: BaseParserContext,
-  id: number,
-  current: ArrayBuffer,
-): SerovalArrayBufferNode {
-  const bytes = new Uint8Array(current);
-  let result = '';
-  for (let i = 0, len = bytes.length; i < len; i++) {
-    result += String.fromCharCode(bytes[i]);
-  }
-  return createSerovalNode(
-    SerovalNodeType.ArrayBuffer,
-    id,
-    serializeString(btoa(result)),
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    parseSpecialReference(ctx, SpecialReference.ArrayBufferConstructor),
-    NIL,
-    NIL,
-    NIL,
-  );
-}

src/core/context/serializer.ts

-import { Feature } from '../compat';
-import {
-  CONSTANT_STRING,
-  ERROR_CONSTRUCTOR_STRING,
-  NIL,
-  SerovalNodeType,
-  SerovalObjectFlags,
-  SYMBOL_STRING,
-} from '../constants';
-import {
-  SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR,
-  SERIALIZED_ITERATOR_CONSTRUCTOR,
-} from '../constructors';
-import {
-  SerovalMissingPluginError,
-  SerovalSerializationError,
-  SerovalUnsupportedNodeError,
-} from '../errors';
-import { createEffectfulFunction, createFunction } from '../function-string';
-import { GLOBAL_CONTEXT_REFERENCES, REFERENCES_KEY } from '../keys';
-import type { PluginAccessOptions } from '../plugin';
-import { SerovalMode } from '../plugin';
-import { SPECIAL_REF_STRING } from '../special-reference';
-import { deserializeString, serializeString } from '../string';
-import type {
-  SerovalAggregateErrorNode,
-  SerovalArrayBufferNode,
-  SerovalArrayNode,
-  SerovalAsyncIteratorFactoryInstanceNode,
-  SerovalAsyncIteratorFactoryNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalBoxedNode,
-  SerovalDataViewNode,
-  SerovalDateNode,
-  SerovalErrorNode,
-  SerovalIndexedValueNode,
-  SerovalIteratorFactoryInstanceNode,
-  SerovalIteratorFactoryNode,
-  SerovalMapNode,
-  SerovalNode,
-  SerovalNodeWithID,
-  SerovalNullConstructorNode,
-  SerovalObjectNode,
-  SerovalObjectRecordKey,
-  SerovalObjectRecordNode,
-  SerovalPluginNode,
-  SerovalPromiseConstructorNode,
-  SerovalPromiseNode,
-  SerovalPromiseRejectNode,
-  SerovalPromiseResolveNode,
-  SerovalReferenceNode,
-  SerovalRegExpNode,
-  SerovalSequenceNode,
-  SerovalSetNode,
-  SerovalStreamConstructorNode,
-  SerovalStreamNextNode,
-  SerovalStreamReturnNode,
-  SerovalStreamThrowNode,
-  SerovalTypedArrayNode,
-} from '../types';
-import getIdentifier from '../utils/get-identifier';
-import { isValidIdentifier } from '../utils/is-valid-identifier';
-import { isValidKey } from '../utils/valid-properties';
-
-const enum AssignmentType {
-  Index = 0,
-  Add = 1,
-  Set = 2,
-  Delete = 3,
-  Define = 4,
-}
-
-interface IndexAssignment {
-  t: AssignmentType.Index;
-  s: string;
-  k: undefined;
-  v: string;
-}
-
-interface SetAssignment {
-  t: AssignmentType.Set;
-  s: string;
-  k: string;
-  v: string;
-}
-
-interface AddAssignment {
-  t: AssignmentType.Add;
-  s: string;
-  k: undefined;
-  v: string;
-}
-
-interface DeleteAssignment {
-  t: AssignmentType.Delete;
-  s: string;
-  k: string;
-  v: undefined;
-}
-
-// Defines an own `__proto__` data property (see `createObjectAssign`).
-// `k` holds the serialized value; `v` is unused so this never participates
-// in the value-based merging done by `mergeAssignments`.
-interface DefineAssignment {
-  t: AssignmentType.Define;
-  s: string;
-  k: string;
-  v: undefined;
-}
-
-// Array of assignments to be done (used for recursion)
-type Assignment =
-  | IndexAssignment
-  | AddAssignment
-  | SetAssignment
-  | DeleteAssignment
-  | DefineAssignment;
-
-export interface FlaggedObject {
-  type: SerovalObjectFlags;
-  value: string;
-}
-
-function getAssignmentExpression(assignment: Assignment): string {
-  switch (assignment.t) {
-    case AssignmentType.Index:
-      return assignment.s + '=' + assignment.v;
-    case AssignmentType.Set:
-      return assignment.s + '.set(' + assignment.k + ',' + assignment.v + ')';
-    case AssignmentType.Add:
-      return assignment.s + '.add(' + assignment.v + ')';
-    case AssignmentType.Delete:
-      return assignment.s + '.delete(' + assignment.k + ')';
-    case AssignmentType.Define:
-      return (
-        'Object.defineProperty(' +
-        assignment.s +
-        ',"__proto__",{value:' +
-        assignment.k +
-        ',configurable:!0,enumerable:!0,writable:!0})'
-      );
-  }
-}
-
-function mergeAssignments(assignments: Assignment[]): Assignment[] {
-  const newAssignments: Assignment[] = [];
-  let current = assignments[0];
-  for (
-    let i = 1, len = assignments.length, item: Assignment, prev = current;
-    i < len;
-    i++
-  ) {
-    item = assignments[i];
-    if (item.t === AssignmentType.Index && item.v === prev.v) {
-      // Merge if the right-hand value is the same
-      // saves at least 2 chars
-      current = {
-        t: AssignmentType.Index,
-        s: item.s,
-        k: NIL,
-        v: getAssignmentExpression(current),
-      } as IndexAssignment;
-    } else if (item.t === AssignmentType.Set && item.s === prev.s) {
-      // Maps has chaining methods, merge if source is the same
-      current = {
-        t: AssignmentType.Set,
-        s: getAssignmentExpression(current),
-        k: item.k,
-        v: item.v,
-      } as SetAssignment;
-    } else if (item.t === AssignmentType.Add && item.s === prev.s) {
-      // Sets has chaining methods too
-      current = {
-        t: AssignmentType.Add,
-        s: getAssignmentExpression(current),
-        k: NIL,
-        v: item.v,
-      } as AddAssignment;
-    } else if (item.t === AssignmentType.Delete && item.s === prev.s) {
-      // Maps has chaining methods, merge if source is the same
-      current = {
-        t: AssignmentType.Delete,
-        s: getAssignmentExpression(current),
-        k: item.k,
-        v: NIL,
-      } as DeleteAssignment;
-    } else {
-      // Different assignment, push current
-      newAssignments.push(current);
-      current = item;
-    }
-    prev = item;
-  }
-
-  newAssignments.push(current);
-
-  return newAssignments;
-}
-
-function resolveAssignments(assignments: Assignment[]): string | undefined {
-  if (assignments.length) {
-    let result = '';
-    const merged = mergeAssignments(assignments);
-    for (let i = 0, len = merged.length; i < len; i++) {
-      result += getAssignmentExpression(merged[i]) + ',';
-    }
-    return result;
-  }
-  return NIL;
-}
-
-const NULL_CONSTRUCTOR = 'Object.create(null)';
-const SET_CONSTRUCTOR = 'new Set';
-const MAP_CONSTRUCTOR = 'new Map';
-
-const PROMISE_RESOLVE = 'Promise.resolve';
-const PROMISE_REJECT = 'Promise.reject';
-
-const OBJECT_FLAG_CONSTRUCTOR: Record<SerovalObjectFlags, string | undefined> =
-  {
-    [SerovalObjectFlags.Frozen]: 'Object.freeze',
-    [SerovalObjectFlags.Sealed]: 'Object.seal',
-    [SerovalObjectFlags.NonExtensible]: 'Object.preventExtensions',
-    [SerovalObjectFlags.None]: NIL,
-  };
-
-type SerovalNodeWithProperties =
-  | SerovalObjectNode
-  | SerovalNullConstructorNode
-  | SerovalAggregateErrorNode
-  | SerovalErrorNode;
-
-export interface BaseSerializerContextOptions extends PluginAccessOptions {
-  features: number;
-  markedRefs: number[] | Set<number>;
-}
-
-export interface BaseSerializerContext extends PluginAccessOptions {
-  readonly mode: SerovalMode;
-
-  features: number;
-  /*
-   * To check if an object is synchronously referencing itself
-   */
-  stack: number[];
-  /**
-   * Array of object mutations
-   */
-  flags: FlaggedObject[];
-  /**
-   * Array of assignments to be done (used for recursion)
-   */
-  assignments: Assignment[];
-  /**
-   * Refs that are...referenced
-   */
-  marked: Set<number>;
-}
-
-export interface CrossContextOptions {
-  scopeId?: string;
-}
-
-export function createBaseSerializerContext(
-  mode: SerovalMode,
-  options: BaseSerializerContextOptions,
-): BaseSerializerContext {
-  return {
-    mode,
-    plugins: options.plugins,
-    features: options.features,
-    marked: new Set(options.markedRefs),
-    stack: [],
-    flags: [],
-    assignments: [],
-  };
-}
-
-export interface VanillaSerializerState {
-  valid: Map<number, number>;
-  vars: string[];
-}
-
-function createVanillaSerializerState(): VanillaSerializerState {
-  return {
-    valid: new Map(),
-    vars: [],
-  };
-}
-
-export interface VanillaSerializerContext {
-  mode: SerovalMode.Vanilla;
-  base: BaseSerializerContext;
-  state: VanillaSerializerState;
-  child: SerializePluginContext | undefined;
-}
-
-export type VanillaSerializerContextOptions = BaseSerializerContextOptions;
-
-export function createVanillaSerializerContext(
-  options: VanillaSerializerContextOptions,
-): VanillaSerializerContext {
-  return {
-    mode: SerovalMode.Vanilla,
-    base: createBaseSerializerContext(SerovalMode.Vanilla, options),
-    state: createVanillaSerializerState(),
-    child: NIL,
-  };
-}
-
-export interface CrossSerializerContext {
-  mode: SerovalMode.Cross;
-  base: BaseSerializerContext;
-  state: CrossContextOptions;
-  child: SerializePluginContext | undefined;
-}
-
-export interface CrossSerializerContextOptions
-  extends BaseSerializerContextOptions,
-    CrossContextOptions {
-  // empty
-}
-
-export function createCrossSerializerContext(
-  options: CrossSerializerContextOptions,
-): CrossSerializerContext {
-  return {
-    mode: SerovalMode.Cross,
-    base: createBaseSerializerContext(SerovalMode.Cross, options),
-    state: options,
-    child: NIL,
-  };
-}
-
-type SerializerContext = VanillaSerializerContext | CrossSerializerContext;
-
-export class SerializePluginContext {
-  constructor(private _p: SerializerContext) {}
-
-  serialize(node: SerovalNode) {
-    return serialize(this._p, node);
-  }
-}
-
-/**
- * Creates the reference param (identifier) from the given reference ID
- * Calling this function means the value has been referenced somewhere
- */
-function getVanillaRefParam(
-  state: VanillaSerializerState,
-  index: number,
-): string {
-  /**
-   * 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 = state.valid.get(index);
-  if (actualIndex == null) {
-    actualIndex = state.valid.size;
-    state.valid.set(index, actualIndex);
-  }
-  let identifier = state.vars[actualIndex];
-  if (identifier == null) {
-    identifier = getIdentifier(actualIndex);
-    state.vars[actualIndex] = identifier;
-  }
-  return identifier;
-}
-
-function getCrossRefParam(id: number): string {
-  return GLOBAL_CONTEXT_REFERENCES + '[' + id + ']';
-}
-
-/**
- * Converts the ID of a reference into a identifier string
- * that is used to refer to the object instance in the
- * generated script.
- */
-function getRefParam(ctx: SerializerContext, id: number): string {
-  return ctx.mode === SerovalMode.Vanilla
-    ? getVanillaRefParam(ctx.state, id)
-    : getCrossRefParam(id);
-}
-
-function markSerializerRef(ctx: BaseSerializerContext, id: number): void {
-  ctx.marked.add(id);
-}
-
-function isSerializerRefMarked(
-  ctx: BaseSerializerContext,
-  id: number,
-): boolean {
-  return ctx.marked.has(id);
-}
-
-function pushObjectFlag(
-  ctx: SerializerContext,
-  flag: SerovalObjectFlags,
-  id: number,
-): void {
-  if (flag !== SerovalObjectFlags.None) {
-    markSerializerRef(ctx.base, id);
-    ctx.base.flags.push({
-      type: flag,
-      value: getRefParam(ctx, id),
-    });
-  }
-}
-
-function resolveFlags(ctx: BaseSerializerContext): string | undefined {
-  let result = '';
-  for (let i = 0, current = ctx.flags, len = current.length; i < len; i++) {
-    const flag = current[i];
-    result += OBJECT_FLAG_CONSTRUCTOR[flag.type] + '(' + flag.value + '),';
-  }
-  return result;
-}
-
-function resolvePatches(ctx: BaseSerializerContext): string | undefined {
-  const assignments = resolveAssignments(ctx.assignments);
-  const flags = resolveFlags(ctx);
-  if (assignments) {
-    if (flags) {
-      return assignments + flags;
-    }
-    return assignments;
-  }
-  return flags;
-}
-
-/**
- * Generates the inlined assignment for the reference
- * This is different from the assignments array as this one
- * signifies creation rather than mutation
- */
-function createAssignment(
-  ctx: BaseSerializerContext,
-  source: string,
-  value: string,
-): void {
-  ctx.assignments.push({
-    t: AssignmentType.Index,
-    s: source,
-    k: NIL,
-    v: value,
-  });
-}
-
-function createAddAssignment(
-  ctx: SerializerContext,
-  ref: number,
-  value: string,
-): void {
-  ctx.base.assignments.push({
-    t: AssignmentType.Add,
-    s: getRefParam(ctx, ref),
-    k: NIL,
-    v: value,
-  });
-}
-
-function createSetAssignment(
-  ctx: SerializerContext,
-  ref: number,
-  key: string,
-  value: string,
-): void {
-  ctx.base.assignments.push({
-    t: AssignmentType.Set,
-    s: getRefParam(ctx, ref),
-    k: key,
-    v: value,
-  });
-}
-
-function createDeleteAssignment(
-  ctx: SerializerContext,
-  ref: number,
-  key: string,
-): void {
-  ctx.base.assignments.push({
-    t: AssignmentType.Delete,
-    s: getRefParam(ctx, ref),
-    k: key,
-    v: NIL,
-  });
-}
-
-function createArrayAssign(
-  ctx: SerializerContext,
-  ref: number,
-  index: number | string,
-  value: string,
-): void {
-  createAssignment(ctx.base, getRefParam(ctx, ref) + '[' + index + ']', value);
-}
-
-function createObjectAssign(
-  ctx: SerializerContext,
-  ref: number,
-  key: string,
-  value: string,
-): void {
-  if (!isValidKey(key)) {
-    // `obj.__proto__ = x`, including the bracket form `obj["__proto__"] = x`,
-    // invokes the prototype setter rather than creating an own property.
-    // Define the property instead so the round-trip preserves it as an actual
-    // own property (matches the inline path in `serializeProperty`).
-    ctx.base.assignments.push({
-      t: AssignmentType.Define,
-      s: getRefParam(ctx, ref),
-      k: value,
-      v: NIL,
-    });
-    return;
-  }
-  createAssignment(ctx.base, getRefParam(ctx, ref) + '.' + key, value);
-}
-
-function createSequenceAssign(
-  ctx: SerializerContext,
-  ref: number,
-  index: number | string,
-  value: string,
-): void {
-  createAssignment(
-    ctx.base,
-    getRefParam(ctx, ref) + '.v[' + index + ']',
-    value,
-  );
-}
-
-/**
- * Checks if the value is in the stack. Stack here is a reference
- * structure to know if a object is to be accessed in a TDZ.
- */
-function isIndexedValueInStack(
-  ctx: BaseSerializerContext,
-  node: SerovalNode,
-): boolean {
-  return node.t === SerovalNodeType.IndexedValue && ctx.stack.includes(node.i);
-}
-
-/**
- * Produces an assignment expression. `id` generates a reference
- * parameter (through `getRefParam`) and has the option to
- * return the reference parameter directly or assign a value to
- * it.
- */
-function assignIndexedValue(
-  ctx: SerializerContext,
-  index: number,
-  value: string,
-): string {
-  if (
-    ctx.mode === SerovalMode.Vanilla &&
-    !isSerializerRefMarked(ctx.base, index)
-  ) {
-    return value;
-  }
-  /**
-   * In cross-reference, we have to assume that
-   * every reference are going to be referenced
-   * in the future, and so we need to store
-   * all of it into the reference array.
-   *
-   * otherwise in vanilla, we only do this if it
-   * is actually referenced
-   */
-  return getRefParam(ctx, index) + '=' + value;
-}
-
-function serializeReference(node: SerovalReferenceNode): string {
-  return REFERENCES_KEY + '.get("' + node.s + '")';
-}
-
-function serializeArrayItem(
-  ctx: SerializerContext,
-  id: number,
-  item: SerovalNode | 0,
-  index: number,
-): string {
-  // Check if index is a hole
-  if (item) {
-    // Check if item is a parent
-    if (isIndexedValueInStack(ctx.base, item)) {
-      markSerializerRef(ctx.base, id);
-      createArrayAssign(
-        ctx,
-        id,
-        index,
-        getRefParam(ctx, (item as SerovalIndexedValueNode).i),
-      );
-      return '';
-    }
-    return serialize(ctx, item);
-  }
-  return '';
-}
-
-function serializeArray(
-  ctx: SerializerContext,
-  node: SerovalArrayNode,
-): string {
-  const id = node.i;
-  const list = node.a;
-  const len = list.length;
-  if (len > 0) {
-    ctx.base.stack.push(id);
-    let values = serializeArrayItem(ctx, id, list[0], 0);
-    // This is different than Map and Set
-    // because we also need to serialize
-    // the holes of the Array
-    let isHoley = values === '';
-    for (let i = 1, item: string; i < len; i++) {
-      item = serializeArrayItem(ctx, id, list[i], i);
-      values += ',' + item;
-      isHoley = item === '';
-    }
-    ctx.base.stack.pop();
-    pushObjectFlag(ctx, node.o, node.i);
-    return '[' + values + (isHoley ? ',]' : ']');
-  }
-  return '[]';
-}
-
-function serializeProperty(
-  ctx: SerializerContext,
-  source: SerovalNodeWithProperties,
-  key: SerovalObjectRecordKey,
-  val: SerovalNode,
-): string {
-  if (typeof key === 'string') {
-    const check = Number(key);
-    const isIdentifier =
-      // Test if key is a valid positive number or JS identifier
-      // so that we don't have to serialize the key and wrap with brackets
-      (check >= 0 &&
-        // It's also important to consider that if the key is
-        // indeed numeric, we need to make sure that when
-        // converted back into a string, it's still the same
-        // to the original key. This allows us to differentiate
-        // keys that has numeric formats but in a different
-        // format, which can cause unintentional key declaration
-        // Example: { 0x1: 1 } vs { '0x1': 1 }
-        check.toString() === key) ||
-      isValidIdentifier(key);
-    if (isIndexedValueInStack(ctx.base, val)) {
-      const refParam = getRefParam(ctx, (val as SerovalIndexedValueNode).i);
-      markSerializerRef(ctx.base, source.i);
-      // Strict identifier check, make sure
-      // that it isn't numeric (except NaN)
-      if (isIdentifier && check !== check) {
-        createObjectAssign(ctx, source.i, key, refParam);
-      } else {
-        createArrayAssign(
-          ctx,
-          source.i,
-          isIdentifier ? key : '"' + key + '"',
-          refParam,
-        );
-      }
-      return '';
-    }
-    if (isValidKey(key)) {
-      return (isIdentifier ? key : '"' + key + '"') + ':' + serialize(ctx, val);
-    }
-    // `__proto__` as an identifier or string key in an object literal is the
-    // prototype setter, not an own property; use a computed key so the
-    // round-trip preserves it as an actual own property.
-    return '["' + key + '"]:' + serialize(ctx, val);
-  }
-  return '[' + serialize(ctx, key) + ']:' + serialize(ctx, val);
-}
-
-function serializeProperties(
-  ctx: SerializerContext,
-  source: SerovalNodeWithProperties,
-  record: SerovalObjectRecordNode,
-): string {
-  const keys = record.k;
-  const len = keys.length;
-  if (len > 0) {
-    const values = record.v;
-    ctx.base.stack.push(source.i);
-    let result = serializeProperty(ctx, source, keys[0], values[0]);
-    for (let i = 1, item = result; i < len; i++) {
-      item = serializeProperty(ctx, source, keys[i], values[i]);
-      result += (item && result && ',') + item;
-    }
-    ctx.base.stack.pop();
-    return '{' + result + '}';
-  }
-  return '{}';
-}
-
-function serializeObject(
-  ctx: SerializerContext,
-  node: SerovalObjectNode,
-): string {
-  pushObjectFlag(ctx, node.o, node.i);
-  return serializeProperties(ctx, node, node.p);
-}
-
-function serializeWithObjectAssign(
-  ctx: SerializerContext,
-  source: SerovalNodeWithProperties,
-  value: SerovalObjectRecordNode,
-  serialized: string,
-): string {
-  const fields = serializeProperties(ctx, source, value);
-  if (fields !== '{}') {
-    return 'Object.assign(' + serialized + ',' + fields + ')';
-  }
-  return serialized;
-}
-
-function serializeStringKeyAssignment(
-  ctx: SerializerContext,
-  source: SerovalNodeWithProperties,
-  mainAssignments: Assignment[],
-  key: string,
-  value: SerovalNode,
-): void {
-  const base = ctx.base;
-  const serialized = serialize(ctx, value);
-  const check = Number(key);
-  const isIdentifier =
-    // Test if key is a valid positive number or JS identifier
-    // so that we don't have to serialize the key and wrap with brackets
-    (check >= 0 &&
-      // It's also important to consider that if the key is
-      // indeed numeric, we need to make sure that when
-      // converted back into a string, it's still the same
-      // to the original key. This allows us to differentiate
-      // keys that has numeric formats but in a different
-      // format, which can cause unintentional key declaration
-      // Example: { 0x1: 1 } vs { '0x1': 1 }
-      check.toString() === key) ||
-    isValidIdentifier(key);
-  if (isIndexedValueInStack(base, value)) {
-    // Strict identifier check, make sure
-    // that it isn't numeric (except NaN)
-    if (isIdentifier && check !== check) {
-      createObjectAssign(ctx, source.i, key, serialized);
-    } else {
-      createArrayAssign(
-        ctx,
-        source.i,
-        isIdentifier ? key : '"' + key + '"',
-        serialized,
-      );
-    }
-  } else {
-    const parentAssignment = base.assignments;
-    base.assignments = mainAssignments;
-    if (isIdentifier && check !== check) {
-      createObjectAssign(ctx, source.i, key, serialized);
-    } else {
-      createArrayAssign(
-        ctx,
-        source.i,
-        isIdentifier ? key : '"' + key + '"',
-        serialized,
-      );
-    }
-    base.assignments = parentAssignment;
-  }
-}
-
-function serializeAssignment(
-  ctx: SerializerContext,
-  source: SerovalNodeWithProperties,
-  mainAssignments: Assignment[],
-  key: SerovalObjectRecordKey,
-  value: SerovalNode,
-): void {
-  if (typeof key === 'string') {
-    serializeStringKeyAssignment(ctx, source, mainAssignments, key, value);
-  } else {
-    const base = ctx.base;
-    const parent = base.stack;
-    base.stack = [];
-    const serialized = serialize(ctx, value);
-    base.stack = parent;
-    const parentAssignment = base.assignments;
-    base.assignments = mainAssignments;
-    createArrayAssign(ctx, source.i, serialize(ctx, key), serialized);
-    base.assignments = parentAssignment;
-  }
-}
-
-function serializeAssignments(
-  ctx: SerializerContext,
-  source: SerovalNodeWithProperties,
-  node: SerovalObjectRecordNode,
-): string | undefined {
-  const keys = node.k;
-  const len = keys.length;
-  if (len > 0) {
-    const mainAssignments: Assignment[] = [];
-    const values = node.v;
-    ctx.base.stack.push(source.i);
-    for (let i = 0; i < len; i++) {
-      serializeAssignment(ctx, source, mainAssignments, keys[i], values[i]);
-    }
-    ctx.base.stack.pop();
-    return resolveAssignments(mainAssignments);
-  }
-  return NIL;
-}
-
-function serializeDictionary(
-  ctx: SerializerContext,
-  node: SerovalNodeWithProperties,
-  init: string,
-): string {
-  if (node.p) {
-    const base = ctx.base;
-    if (base.features & Feature.ObjectAssign) {
-      init = serializeWithObjectAssign(ctx, node, node.p, init);
-    } else {
-      markSerializerRef(base, node.i);
-      const assignments = serializeAssignments(ctx, node, node.p);
-      if (assignments) {
-        return (
-          '(' +
-          assignIndexedValue(ctx, node.i, init) +
-          ',' +
-          assignments +
-          getRefParam(ctx, node.i) +
-          ')'
-        );
-      }
-    }
-  }
-  return init;
-}
-
-function serializeNullConstructor(
-  ctx: SerializerContext,
-  node: SerovalNullConstructorNode,
-): string {
-  pushObjectFlag(ctx, node.o, node.i);
-  return serializeDictionary(ctx, node, NULL_CONSTRUCTOR);
-}
-
-function serializeDate(node: SerovalDateNode): string {
-  return 'new Date("' + node.s + '")';
-}
-
-function serializeRegExp(
-  ctx: SerializerContext,
-  node: SerovalRegExpNode,
-): string {
-  if (ctx.base.features & Feature.RegExp) {
-    return '/' + deserializeString(node.c) + '/' + node.m;
-  }
-  throw new SerovalUnsupportedNodeError(node);
-}
-
-function serializeSetItem(
-  ctx: SerializerContext,
-  id: number,
-  item: SerovalNode,
-): string {
-  const base = ctx.base;
-  if (isIndexedValueInStack(base, item)) {
-    markSerializerRef(base, id);
-    createAddAssignment(
-      ctx,
-      id,
-      getRefParam(ctx, (item as SerovalIndexedValueNode).i),
-    );
-    return '';
-  }
-  return serialize(ctx, item);
-}
-
-function serializeSet(ctx: SerializerContext, node: SerovalSetNode): string {
-  let serialized = SET_CONSTRUCTOR;
-  const items = node.a;
-  const size = items.length;
-  const id = node.i;
-  if (size > 0) {
-    ctx.base.stack.push(id);
-    let result = serializeSetItem(ctx, id, items[0]);
-    for (let i = 1, item = result; i < size; i++) {
-      item = serializeSetItem(ctx, id, items[i]);
-      result += (item && result && ',') + item;
-    }
-    ctx.base.stack.pop();
-    if (result) {
-      serialized += '([' + result + '])';
-    }
-  }
-  return serialized;
-}
-
-function serializeMapEntry(
-  ctx: SerializerContext,
-  id: number,
-  key: SerovalNode,
-  val: SerovalNode,
-  sentinel: string,
-): string {
-  const base = ctx.base;
-  if (isIndexedValueInStack(base, key)) {
-    // Create reference for the map instance
-    const keyRef = getRefParam(ctx, (key as SerovalIndexedValueNode).i);
-    markSerializerRef(base, id);
-    // Check if value is a parent
-    if (isIndexedValueInStack(base, val)) {
-      const valueRef = getRefParam(ctx, (val as SerovalIndexedValueNode).i);
-      // Register an assignment since
-      // both key and value are a parent of this
-      // Map instance
-      createSetAssignment(ctx, id, keyRef, valueRef);
-      return '';
-    }
-    // Reset the stack
-    // This is required because the serialized
-    // value is no longer part of the expression
-    // tree and has been moved to the deferred
-    // assignment
-    if (
-      val.t !== SerovalNodeType.IndexedValue &&
-      val.i != null &&
-      isSerializerRefMarked(base, val.i)
-    ) {
-      // We use a trick here using sequence (or comma) expressions
-      // basically we serialize the intended object in place WITHOUT
-      // actually returning it, this is by returning a placeholder
-      // value that we will remove sometime after.
-      const serialized =
-        '(' + serialize(ctx, val) + ',[' + sentinel + ',' + sentinel + '])';
-      createSetAssignment(ctx, id, keyRef, getRefParam(ctx, val.i));
-      createDeleteAssignment(ctx, id, sentinel);
-      return serialized;
-    }
-    const parent = base.stack;
-    base.stack = [];
-    createSetAssignment(ctx, id, keyRef, serialize(ctx, val));
-    base.stack = parent;
-    return '';
-  }
-  if (isIndexedValueInStack(base, val)) {
-    // Create ref for the Map instance
-    const valueRef = getRefParam(ctx, (val as SerovalIndexedValueNode).i);
-    markSerializerRef(base, id);
-    if (
-      key.t !== SerovalNodeType.IndexedValue &&
-      key.i != null &&
-      isSerializerRefMarked(base, key.i)
-    ) {
-      const serialized =
-        '(' + serialize(ctx, key) + ',[' + sentinel + ',' + sentinel + '])';
-      createSetAssignment(ctx, id, getRefParam(ctx, key.i), valueRef);
-      createDeleteAssignment(ctx, id, sentinel);
-      return serialized;
-    }
-    // Reset stack for the key serialization
-    const parent = base.stack;
-    base.stack = [];
-    createSetAssignment(ctx, id, serialize(ctx, key), valueRef);
-    base.stack = parent;
-    return '';
-  }
-
-  return '[' + serialize(ctx, key) + ',' + serialize(ctx, val) + ']';
-}
-
-function serializeMap(ctx: SerializerContext, node: SerovalMapNode): string {
-  let serialized = MAP_CONSTRUCTOR;
-  const keys = node.e.k;
-  const size = keys.length;
-  const id = node.i;
-  const sentinel = node.f;
-  const sentinelId = getRefParam(ctx, sentinel.i);
-  const base = ctx.base;
-  if (size > 0) {
-    const vals = node.e.v;
-    base.stack.push(id);
-    let result = serializeMapEntry(ctx, id, keys[0], vals[0], sentinelId);
-    for (let i = 1, item = result; i < size; i++) {
-      item = serializeMapEntry(ctx, id, keys[i], vals[i], sentinelId);
-      result += (item && result && ',') + item;
-    }
-    base.stack.pop();
-    // Check if there are any values
-    // so that the empty Map constructor
-    // can be used instead
-    if (result) {
-      serialized += '([' + result + '])';
-    }
-  }
-  if (sentinel.t === SerovalNodeType.SpecialReference) {
-    markSerializerRef(base, sentinel.i);
-    serialized = '(' + serialize(ctx, sentinel) + ',' + serialized + ')';
-  }
-  return serialized;
-}
-
-function serializeArrayBuffer(
-  ctx: SerializerContext,
-  node: SerovalArrayBufferNode,
-): string {
-  return getConstructor(ctx, node.f) + '("' + node.s + '")';
-}
-
-function serializeTypedArray(
-  ctx: SerializerContext,
-  node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
-): string {
-  return (
-    'new ' +
-    node.c +
-    '(' +
-    serialize(ctx, node.f) +
-    ',' +
-    node.b +
-    ',' +
-    node.l +
-    ')'
-  );
-}
-
-function serializeDataView(
-  ctx: SerializerContext,
-  node: SerovalDataViewNode,
-): string {
-  return (
-    'new DataView(' + serialize(ctx, node.f) + ',' + node.b + ',' + node.l + ')'
-  );
-}
-
-function serializeAggregateError(
-  ctx: SerializerContext,
-  node: SerovalAggregateErrorNode,
-): string {
-  const id = node.i;
-  // `AggregateError` might've been extended
-  // either through class or custom properties
-  // Make sure to assign extra properties
-  ctx.base.stack.push(id);
-  const serialized = serializeDictionary(
-    ctx,
-    node,
-    'new AggregateError([],"' + node.m + '")',
-  );
-  ctx.base.stack.pop();
-  return serialized;
-}
-
-function serializeError(
-  ctx: SerializerContext,
-  node: SerovalErrorNode,
-): string {
-  return serializeDictionary(
-    ctx,
-    node,
-    'new ' + ERROR_CONSTRUCTOR_STRING[node.s] + '("' + node.m + '")',
-  );
-}
-
-function serializePromise(
-  ctx: SerializerContext,
-  node: SerovalPromiseNode,
-): string {
-  let serialized: string;
-  // Check if resolved value is a parent expression
-  const fulfilled = node.f;
-  const id = node.i;
-  const promiseConstructor = node.s ? PROMISE_RESOLVE : PROMISE_REJECT;
-  const base = ctx.base;
-  if (isIndexedValueInStack(base, fulfilled)) {
-    // A Promise trick, reference the value
-    // inside the `then` expression so that
-    // the Promise evaluates after the parent
-    // has initialized
-    const ref = getRefParam(ctx, (fulfilled as SerovalIndexedValueNode).i);
-    serialized =
-      promiseConstructor +
-      (node.s
-        ? '().then(' + createFunction([], ref) + ')'
-        : '().catch(' + createEffectfulFunction([], 'throw ' + ref) + ')');
-  } else {
-    base.stack.push(id);
-    const result = serialize(ctx, fulfilled);
-    base.stack.pop();
-    // just inline the value/reference here
-    serialized = promiseConstructor + '(' + result + ')';
-  }
-  return serialized;
-}
-
-function serializeBoxed(
-  ctx: SerializerContext,
-  node: SerovalBoxedNode,
-): string {
-  return 'Object(' + serialize(ctx, node.f) + ')';
-}
-
-function getConstructor(
-  ctx: SerializerContext,
-  node: SerovalNodeWithID,
-): string {
-  const current = serialize(ctx, node);
-  return node.t === SerovalNodeType.IndexedValue
-    ? current
-    : '(' + current + ')';
-}
-
-function serializePromiseConstructor(
-  ctx: SerializerContext,
-  node: SerovalPromiseConstructorNode,
-): string {
-  if (ctx.mode === SerovalMode.Vanilla) {
-    throw new SerovalUnsupportedNodeError(node);
-  }
-  const resolver = assignIndexedValue(
-    ctx,
-    node.s,
-    getConstructor(ctx, node.f) + '()',
-  );
-  return '(' + resolver + ').p';
-}
-
-function serializePromiseResolve(
-  ctx: SerializerContext,
-  node: SerovalPromiseResolveNode,
-): string {
-  if (ctx.mode === SerovalMode.Vanilla) {
-    throw new SerovalUnsupportedNodeError(node);
-  }
-  return (
-    getConstructor(ctx, node.a[0]) +
-    '(' +
-    getRefParam(ctx, node.i) +
-    ',' +
-    serialize(ctx, node.a[1]) +
-    ')'
-  );
-}
-
-function serializePromiseReject(
-  ctx: SerializerContext,
-  node: SerovalPromiseRejectNode,
-): string {
-  if (ctx.mode === SerovalMode.Vanilla) {
-    throw new SerovalUnsupportedNodeError(node);
-  }
-  return (
-    getConstructor(ctx, node.a[0]) +
-    '(' +
-    getRefParam(ctx, node.i) +
-    ',' +
-    serialize(ctx, node.a[1]) +
-    ')'
-  );
-}
-
-function serializePlugin(
-  ctx: SerializerContext,
-  node: SerovalPluginNode,
-): string {
-  const currentPlugins = ctx.base.plugins;
-  if (currentPlugins) {
-    for (let i = 0, len = currentPlugins.length; i < len; i++) {
-      const plugin = currentPlugins[i];
-      if (plugin.tag === node.c) {
-        if (ctx.child == null) {
-          ctx.child = new SerializePluginContext(ctx);
-        }
-        return plugin.serialize(node.s, ctx.child, {
-          id: node.i,
-        });
-      }
-    }
-  }
-  throw new SerovalMissingPluginError(node.c);
-}
-
-function serializeIteratorFactory(
-  ctx: SerializerContext,
-  node: SerovalIteratorFactoryNode,
-): string {
-  let result = '';
-  let initialized = false;
-  if (node.f.t !== SerovalNodeType.IndexedValue) {
-    markSerializerRef(ctx.base, node.f.i);
-    result = '(' + serialize(ctx, node.f) + ',';
-    initialized = true;
-  }
-  result += assignIndexedValue(
-    ctx,
-    node.i,
-    '(' +
-      SERIALIZED_ITERATOR_CONSTRUCTOR +
-      ')(' +
-      getRefParam(ctx, node.f.i) +
-      ')',
-  );
-  if (initialized) {
-    result += ')';
-  }
-  return result;
-}
-
-function serializeIteratorFactoryInstance(
-  ctx: SerializerContext,
-  node: SerovalIteratorFactoryInstanceNode,
-): string {
-  return getConstructor(ctx, node.a[0]) + '(' + serialize(ctx, node.a[1]) + ')';
-}
-
-function serializeAsyncIteratorFactory(
-  ctx: SerializerContext,
-  node: SerovalAsyncIteratorFactoryNode,
-): string {
-  const promise = node.a[0];
-  const symbol = node.a[1];
-  const base = ctx.base;
-
-  let result = '';
-
-  if (promise.t !== SerovalNodeType.IndexedValue) {
-    markSerializerRef(base, promise.i);
-    result += '(' + serialize(ctx, promise);
-  }
-  if (symbol.t !== SerovalNodeType.IndexedValue) {
-    markSerializerRef(base, symbol.i);
-    result += (result ? ',' : '(') + serialize(ctx, symbol);
-  }
-  if (result) {
-    result += ',';
-  }
-
-  const iterator = assignIndexedValue(
-    ctx,
-    node.i,
-    '(' +
-      SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR +
-      ')(' +
-      getRefParam(ctx, symbol.i) +
-      ',' +
-      getRefParam(ctx, promise.i) +
-      ')',
-  );
-
-  if (result) {
-    return result + iterator + ')';
-  }
-
-  return iterator;
-}
-
-function serializeAsyncIteratorFactoryInstance(
-  ctx: SerializerContext,
-  node: SerovalAsyncIteratorFactoryInstanceNode,
-): string {
-  return getConstructor(ctx, node.a[0]) + '(' + serialize(ctx, node.a[1]) + ')';
-}
-
-function serializeStreamConstructor(
-  ctx: SerializerContext,
-  node: SerovalStreamConstructorNode,
-): string {
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    getConstructor(ctx, node.f) + '()',
-  );
-  const len = node.a.length;
-  if (len) {
-    let values = serialize(ctx, node.a[0]);
-    for (let i = 1; i < len; i++) {
-      values += ',' + serialize(ctx, node.a[i]);
-    }
-    return '(' + result + ',' + values + ',' + getRefParam(ctx, node.i) + ')';
-  }
-  return result;
-}
-
-function serializeStreamNext(
-  ctx: SerializerContext,
-  node: SerovalStreamNextNode,
-): string {
-  return getRefParam(ctx, node.i) + '.next(' + serialize(ctx, node.f) + ')';
-}
-
-function serializeStreamThrow(
-  ctx: SerializerContext,
-  node: SerovalStreamThrowNode,
-): string {
-  return getRefParam(ctx, node.i) + '.throw(' + serialize(ctx, node.f) + ')';
-}
-
-function serializeStreamReturn(
-  ctx: SerializerContext,
-  node: SerovalStreamReturnNode,
-): string {
-  return getRefParam(ctx, node.i) + '.return(' + serialize(ctx, node.f) + ')';
-}
-
-function serializeSequenceItem(
-  ctx: SerializerContext,
-  id: number,
-  index: number,
-  item: SerovalNode,
-): string {
-  const base = ctx.base;
-  if (isIndexedValueInStack(base, item)) {
-    markSerializerRef(base, id);
-    createSequenceAssign(
-      ctx,
-      id,
-      index,
-      getRefParam(ctx, (item as SerovalIndexedValueNode).i),
-    );
-    return '';
-  }
-  return serialize(ctx, item);
-}
-
-function serializeSequence(
-  ctx: SerializerContext,
-  node: SerovalSequenceNode,
-): string {
-  const items = node.a;
-  const size = items.length;
-  const id = node.i;
-  if (size > 0) {
-    ctx.base.stack.push(id);
-    let result = serializeSequenceItem(ctx, id, 0, items[0]);
-    for (let i = 1, item = result; i < size; i++) {
-      item = serializeSequenceItem(ctx, id, i, items[i]);
-      result += (item && result && ',') + item;
-    }
-    ctx.base.stack.pop();
-    if (result) {
-      return (
-        '{__SEROVAL_SEQUENCE__:!0,v:[' +
-        result +
-        '],t:' +
-        node.s +
-        ',d:' +
-        node.l +
-        '}'
-      );
-    }
-  }
-  return '{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}';
-}
-
-function serializeAssignable(
-  ctx: SerializerContext,
-  node: SerovalNode,
-): string {
-  switch (node.t) {
-    case SerovalNodeType.WKSymbol:
-      return SYMBOL_STRING[node.s];
-    case SerovalNodeType.Reference:
-      return serializeReference(node);
-    case SerovalNodeType.Array:
-      return serializeArray(ctx, node);
-    case SerovalNodeType.Object:
-      return serializeObject(ctx, node);
-    case SerovalNodeType.NullConstructor:
-      return serializeNullConstructor(ctx, node);
-    case SerovalNodeType.Date:
-      return serializeDate(node);
-    case SerovalNodeType.RegExp:
-      return serializeRegExp(ctx, node);
-    case SerovalNodeType.Set:
-      return serializeSet(ctx, node);
-    case SerovalNodeType.Map:
-      return serializeMap(ctx, node);
-    case SerovalNodeType.ArrayBuffer:
-      return serializeArrayBuffer(ctx, node);
-    case SerovalNodeType.BigIntTypedArray:
-    case SerovalNodeType.TypedArray:
-      return serializeTypedArray(ctx, node);
-    case SerovalNodeType.DataView:
-      return serializeDataView(ctx, node);
-    case SerovalNodeType.AggregateError:
-      return serializeAggregateError(ctx, node);
-    case SerovalNodeType.Error:
-      return serializeError(ctx, node);
-    case SerovalNodeType.Promise:
-      return serializePromise(ctx, node);
-    case SerovalNodeType.Boxed:
-      return serializeBoxed(ctx, node);
-    case SerovalNodeType.PromiseConstructor:
-      return serializePromiseConstructor(ctx, node);
-    case SerovalNodeType.Plugin:
-      return serializePlugin(ctx, node);
-    case SerovalNodeType.SpecialReference:
-      return SPECIAL_REF_STRING[node.s];
-    case SerovalNodeType.Sequence:
-      return serializeSequence(ctx, node);
-    default:
-      throw new SerovalUnsupportedNodeError(node);
-  }
-}
-
-function serialize(ctx: SerializerContext, node: SerovalNode): string {
-  switch (node.t) {
-    case SerovalNodeType.Constant:
-      return CONSTANT_STRING[node.s];
-    case SerovalNodeType.Number:
-      return '' + node.s;
-    case SerovalNodeType.String:
-      return '"' + node.s + '"';
-    case SerovalNodeType.BigInt:
-      return node.s + 'n';
-    case SerovalNodeType.IndexedValue:
-      return getRefParam(ctx, node.i);
-    case SerovalNodeType.PromiseSuccess:
-      return serializePromiseResolve(ctx, node);
-    case SerovalNodeType.PromiseFailure:
-      return serializePromiseReject(ctx, node);
-    case SerovalNodeType.IteratorFactory:
-      return serializeIteratorFactory(ctx, node);
-    case SerovalNodeType.IteratorFactoryInstance:
-      return serializeIteratorFactoryInstance(ctx, node);
-    case SerovalNodeType.AsyncIteratorFactory:
-      return serializeAsyncIteratorFactory(ctx, node);
-    case SerovalNodeType.AsyncIteratorFactoryInstance:
-      return serializeAsyncIteratorFactoryInstance(ctx, node);
-    case SerovalNodeType.StreamConstructor:
-      return serializeStreamConstructor(ctx, node);
-    case SerovalNodeType.StreamNext:
-      return serializeStreamNext(ctx, node);
-    case SerovalNodeType.StreamThrow:
-      return serializeStreamThrow(ctx, node);
-    case SerovalNodeType.StreamReturn:
-      return serializeStreamReturn(ctx, node);
-    default:
-      return assignIndexedValue(ctx, node.i, serializeAssignable(ctx, node));
-  }
-}
-
-export function serializeRoot(
-  ctx: SerializerContext,
-  node: SerovalNode,
-): string {
-  try {
-    return serialize(ctx, node);
-  } catch (error) {
-    throw error instanceof SerovalSerializationError
-      ? error
-      : new SerovalSerializationError(error);
-  }
-}
-
-export function serializeTopVanilla(
-  ctx: VanillaSerializerContext,
-  tree: SerovalNode,
-): string {
-  const result = serialize(ctx, tree);
-  // Shared references detected
-  if (tree.i != null && ctx.state.vars.length) {
-    const patches = resolvePatches(ctx.base);
-    let body = result;
-    if (patches) {
-      // Get (or create) a ref from the source
-      const index = getRefParam(ctx, tree.i);
-      body = result + ',' + patches + index;
-      if (!result.startsWith(index + '=')) {
-        body = index + '=' + body;
-      }
-      body = '(' + body + ')';
-    }
-    return '(' + createFunction(ctx.state.vars, body) + ')()';
-  }
-  if (tree.t === SerovalNodeType.Object) {
-    return '(' + result + ')';
-  }
-  return result;
-}
-
-export function serializeTopCross(
-  ctx: CrossSerializerContext,
-  tree: SerovalNode,
-): string {
-  // Get the serialized result
-  const result = serialize(ctx, tree);
-  // If the node is a non-reference, return
-  // the result immediately
-  const id = tree.i;
-  if (id == null) {
-    return result;
-  }
-  // Get the patches
-  const patches = resolvePatches(ctx.base);
-  // Get the variable that represents the root
-  const ref = getRefParam(ctx, id);
-  const scopeId = ctx.state.scopeId;
-  // Parameters needed for scoping
-  const params = scopeId == null ? '' : GLOBAL_CONTEXT_REFERENCES;
-  // If there are patches, append it after the result
-  const body = patches ? '(' + result + ',' + patches + ref + ')' : result;
-  // If there are no params, there's no need to generate a function
-  if (params === '') {
-    if (tree.t === SerovalNodeType.Object && !patches) {
-      return '(' + body + ')';
-    }
-    return body;
-  }
-  // Get the arguments for the IIFE
-  const args =
-    scopeId == null
-      ? '()'
-      : '(' +
-        GLOBAL_CONTEXT_REFERENCES +
-        '["' +
-        serializeString(scopeId) +
-        '"])';
-  // Create the IIFE
-  return '(' + createFunction([params], body) + ')' + args;
-}

src/core/context/sync-parser.ts

-import {
-  createAggregateErrorNode,
-  createArrayNode,
-  createAsyncIteratorFactoryInstanceNode,
-  createBigIntNode,
-  createBigIntTypedArrayNode,
-  createBoxedNode,
-  createDataViewNode,
-  createDateNode,
-  createErrorNode,
-  createIteratorFactoryInstanceNode,
-  createNumberNode,
-  createPluginNode,
-  createRegExpNode,
-  createSequenceNode,
-  createSetNode,
-  createStreamConstructorNode,
-  createStreamNextNode,
-  createStreamReturnNode,
-  createStreamThrowNode,
-  createStringNode,
-  createTypedArrayNode,
-} from '../base-primitives';
-import { Feature } from '../compat';
-import { NIL, SerovalNodeType } from '../constants';
-import {
-  SerovalDepthLimitError,
-  SerovalParserError,
-  SerovalUnsupportedTypeError,
-} from '../errors';
-import { FALSE_NODE, NULL_NODE, TRUE_NODE, UNDEFINED_NODE } from '../literals';
-import { createSerovalNode } from '../node';
-import { OpaqueReference } from '../opaque-reference';
-import { type Plugin, SerovalMode } from '../plugin';
-import {
-  createSequenceFromIterable,
-  isSequence,
-  type Sequence,
-} from '../sequence';
-import { SpecialReference } from '../special-reference';
-import type { Stream } from '../stream';
-import {
-  createStream,
-  createStreamFromAsyncIterable,
-  isStream,
-} from '../stream';
-import { serializeString } from '../string';
-import {
-  SYM_ASYNC_ITERATOR,
-  SYM_IS_CONCAT_SPREADABLE,
-  SYM_ITERATOR,
-  SYM_TO_STRING_TAG,
-} from '../symbols';
-import type {
-  SerovalAggregateErrorNode,
-  SerovalArrayNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalBoxedNode,
-  SerovalDataViewNode,
-  SerovalErrorNode,
-  SerovalMapNode,
-  SerovalNode,
-  SerovalNodeWithID,
-  SerovalNullConstructorNode,
-  SerovalObjectNode,
-  SerovalObjectRecordKey,
-  SerovalObjectRecordNode,
-  SerovalPluginNode,
-  SerovalPromiseConstructorNode,
-  SerovalSequenceNode,
-  SerovalSetNode,
-  SerovalTypedArrayNode,
-} from '../types';
-import { getErrorOptions } from '../utils/error';
-import type {
-  BigIntTypedArrayValue,
-  TypedArrayValue,
-} from '../utils/typed-array';
-import type { BaseParserContext, BaseParserContextOptions } from './parser';
-import {
-  createArrayBufferNode,
-  createBaseParserContext,
-  createIndexForValue,
-  createMapNode,
-  createObjectNode,
-  createPromiseConstructorNode,
-  getReferenceNode,
-  parseAsyncIteratorFactory,
-  parseIteratorFactory,
-  ParserNodeType,
-  parseSpecialReference,
-  parseWellKnownSymbol,
-} from './parser';
-
-type ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode;
-
-export type SyncParserContextOptions = BaseParserContextOptions;
-
-const enum ParserMode {
-  Sync = 1,
-  Stream = 2,
-}
-
-export interface SyncParserContext {
-  type: ParserMode.Sync;
-  base: BaseParserContext;
-  child: SyncParsePluginContext | undefined;
-}
-
-export function createSyncParserContext(
-  mode: SerovalMode,
-  options: SyncParserContextOptions,
-): SyncParserContext {
-  return {
-    type: ParserMode.Sync,
-    base: createBaseParserContext(mode, options),
-    child: NIL,
-  };
-}
-
-export class SyncParsePluginContext {
-  constructor(
-    private _p: SyncParserContext,
-    private depth: number,
-  ) {}
-
-  parse<T>(current: T): SerovalNode {
-    return parseSOS(this._p, this.depth, current);
-  }
-}
-
-export interface StreamParserContextOptions extends SyncParserContextOptions {
-  onParse: (node: SerovalNode, initial: boolean) => void;
-  onError?: (error: unknown) => void;
-  onDone?: () => void;
-}
-
-export interface StreamParserContext {
-  type: ParserMode.Stream;
-  base: BaseParserContext;
-  state: StreamParserState;
-}
-export class StreamParsePluginContext {
-  constructor(
-    private _p: StreamParserContext,
-    private depth: number,
-  ) {}
-
-  parse<T>(current: T): SerovalNode {
-    return parseSOS(this._p, this.depth, current);
-  }
-
-  parseWithError<T>(current: T): SerovalNode | undefined {
-    return parseWithError(this._p, this.depth, current);
-  }
-
-  isAlive(): boolean {
-    return this._p.state.alive;
-  }
-
-  pushPendingState(): void {
-    pushPendingState(this._p);
-  }
-
-  popPendingState(): void {
-    popPendingState(this._p);
-  }
-
-  onParse(node: SerovalNode): void {
-    onParse(this._p, node);
-  }
-
-  onError(error: unknown): void {
-    onError(this._p, error);
-  }
-
-  addCleanup(callback: () => void): void {
-    this._p.state.cleanups.push(callback);
-  }
-}
-
-interface StreamParserState {
-  // Life cycle
-  alive: boolean;
-  // Number of pending things
-  pending: number;
-  //
-  initial: boolean;
-  //
-  buffer: SerovalNode[];
-  // Callbacks
-  onParse: (node: SerovalNode, initial: boolean) => void;
-  onError?: (error: unknown) => void;
-  onDone?: () => void;
-
-  cleanups: (() => void)[];
-}
-
-function createStreamParserState(
-  options: StreamParserContextOptions,
-): StreamParserState {
-  return {
-    alive: true,
-    pending: 0,
-    initial: true,
-    buffer: [],
-    onParse: options.onParse,
-    onError: options.onError,
-    onDone: options.onDone,
-    cleanups: [],
-  };
-}
-
-export function createStreamParserContext(
-  options: StreamParserContextOptions,
-): StreamParserContext {
-  return {
-    type: ParserMode.Stream,
-    base: createBaseParserContext(SerovalMode.Cross, options),
-    state: createStreamParserState(options),
-  };
-}
-
-type SOSParserContext = SyncParserContext | StreamParserContext;
-
-function parseItems(
-  ctx: SOSParserContext,
-  depth: number,
-  current: unknown[],
-): (SerovalNode | 0)[] {
-  const nodes: (SerovalNode | 0)[] = [];
-  for (let i = 0, len = current.length; i < len; i++) {
-    if (i in current) {
-      nodes[i] = parseSOS(ctx, depth, current[i]);
-    } else {
-      nodes[i] = 0;
-    }
-  }
-  return nodes;
-}
-
-function parseArray(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: unknown[],
-): SerovalArrayNode {
-  return createArrayNode(id, current, parseItems(ctx, depth, current));
-}
-
-function parseProperties(
-  ctx: SOSParserContext,
-  depth: number,
-  properties: Record<string | symbol, unknown>,
-): SerovalObjectRecordNode {
-  const entries = Object.entries(properties);
-  const keyNodes: SerovalObjectRecordKey[] = [];
-  const valueNodes: SerovalNode[] = [];
-  for (let i = 0, len = entries.length; i < len; i++) {
-    keyNodes.push(serializeString(entries[i][0]));
-    valueNodes.push(parseSOS(ctx, depth, entries[i][1]));
-  }
-  // Check special properties, symbols in this case
-  if (SYM_ITERATOR in properties) {
-    keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));
-    valueNodes.push(
-      createIteratorFactoryInstanceNode(
-        parseIteratorFactory(ctx.base),
-        parseSOS(
-          ctx,
-          depth,
-          createSequenceFromIterable(
-            properties as unknown as Iterable<unknown>,
-          ),
-        ) as SerovalNodeWithID,
-      ),
-    );
-  }
-  if (SYM_ASYNC_ITERATOR in properties) {
-    keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));
-    valueNodes.push(
-      createAsyncIteratorFactoryInstanceNode(
-        parseAsyncIteratorFactory(ctx.base),
-        parseSOS(
-          ctx,
-          depth,
-          ctx.type === ParserMode.Sync
-            ? createStream()
-            : createStreamFromAsyncIterable(
-                properties as unknown as AsyncIterable<unknown>,
-              ),
-        ) as SerovalNodeWithID,
-      ),
-    );
-  }
-  if (SYM_TO_STRING_TAG in properties) {
-    keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));
-    valueNodes.push(createStringNode(properties[SYM_TO_STRING_TAG] as string));
-  }
-  if (SYM_IS_CONCAT_SPREADABLE in properties) {
-    keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_IS_CONCAT_SPREADABLE));
-    valueNodes.push(
-      properties[SYM_IS_CONCAT_SPREADABLE] ? TRUE_NODE : FALSE_NODE,
-    );
-  }
-  return {
-    k: keyNodes,
-    v: valueNodes,
-  };
-}
-
-function parsePlainObject(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: Record<string, unknown>,
-  empty: boolean,
-): ObjectLikeNode {
-  return createObjectNode(
-    id,
-    current,
-    empty,
-    parseProperties(ctx, depth, current),
-  );
-}
-
-function parseBoxed(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: object,
-): SerovalBoxedNode {
-  return createBoxedNode(id, parseSOS(ctx, depth, current.valueOf()));
-}
-
-function parseTypedArray(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: TypedArrayValue,
-): SerovalTypedArrayNode {
-  return createTypedArrayNode(
-    id,
-    current,
-    parseSOS(ctx, depth, current.buffer),
-  );
-}
-
-function parseBigIntTypedArray(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: BigIntTypedArrayValue,
-): SerovalBigIntTypedArrayNode {
-  return createBigIntTypedArrayNode(
-    id,
-    current,
-    parseSOS(ctx, depth, current.buffer),
-  );
-}
-
-function parseDataView(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: DataView,
-): SerovalDataViewNode {
-  return createDataViewNode(id, current, parseSOS(ctx, depth, current.buffer));
-}
-
-function parseError(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: Error,
-): SerovalErrorNode {
-  const options = getErrorOptions(current, ctx.base.features);
-  return createErrorNode(
-    id,
-    current,
-    options ? parseProperties(ctx, depth, options) : NIL,
-  );
-}
-
-function parseAggregateError(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: AggregateError,
-): SerovalAggregateErrorNode {
-  const options = getErrorOptions(current, ctx.base.features);
-  return createAggregateErrorNode(
-    id,
-    current,
-    options ? parseProperties(ctx, depth, options) : NIL,
-  );
-}
-
-function parseMap(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: Map<unknown, unknown>,
-): SerovalMapNode {
-  const keyNodes: SerovalNode[] = [];
-  const valueNodes: SerovalNode[] = [];
-  for (const [key, value] of current.entries()) {
-    keyNodes.push(parseSOS(ctx, depth, key));
-    valueNodes.push(parseSOS(ctx, depth, value));
-  }
-  return createMapNode(ctx.base, id, keyNodes, valueNodes);
-}
-
-function parseSet(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: Set<unknown>,
-): SerovalSetNode {
-  const items: SerovalNode[] = [];
-  for (const item of current.keys()) {
-    items.push(parseSOS(ctx, depth, item));
-  }
-  return createSetNode(id, items);
-}
-
-function parseStream(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: Stream<unknown>,
-): SerovalNode {
-  const result = createStreamConstructorNode(
-    id,
-    parseSpecialReference(ctx.base, SpecialReference.StreamConstructor),
-    [],
-  );
-  if (ctx.type === ParserMode.Sync) {
-    return result;
-  }
-  pushPendingState(ctx);
-  current.on({
-    next: value => {
-      if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, depth, value);
-        if (parsed) {
-          onParse(ctx, createStreamNextNode(id, parsed));
-        }
-      }
-    },
-    throw: value => {
-      if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, depth, value);
-        if (parsed) {
-          onParse(ctx, createStreamThrowNode(id, parsed));
-        }
-      }
-      popPendingState(ctx);
-    },
-    return: value => {
-      if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, depth, value);
-        if (parsed) {
-          onParse(ctx, createStreamReturnNode(id, parsed));
-        }
-      }
-      popPendingState(ctx);
-    },
-  });
-  return result;
-}
-
-function handlePromiseSuccess(
-  this: StreamParserContext,
-  id: number,
-  depth: number,
-  data: unknown,
-): void {
-  if (this.state.alive) {
-    const parsed = parseWithError(this, depth, data);
-    if (parsed) {
-      onParse(
-        this,
-        createSerovalNode(
-          SerovalNodeType.PromiseSuccess,
-          id,
-          NIL,
-          NIL,
-          NIL,
-          NIL,
-          NIL,
-          [
-            parseSpecialReference(this.base, SpecialReference.PromiseSuccess),
-            parsed,
-          ],
-          NIL,
-          NIL,
-          NIL,
-          NIL,
-        ),
-      );
-    }
-    popPendingState(this);
-  }
-}
-
-function handlePromiseFailure(
-  this: StreamParserContext,
-  id: number,
-  depth: number,
-  data: unknown,
-): void {
-  if (this.state.alive) {
-    const parsed = parseWithError(this, depth, data);
-    if (parsed) {
-      onParse(
-        this,
-        createSerovalNode(
-          SerovalNodeType.PromiseFailure,
-          id,
-          NIL,
-          NIL,
-          NIL,
-          NIL,
-          NIL,
-          [
-            parseSpecialReference(this.base, SpecialReference.PromiseFailure),
-            parsed,
-          ],
-          NIL,
-          NIL,
-          NIL,
-          NIL,
-        ),
-      );
-    }
-  }
-  popPendingState(this);
-}
-
-function parsePromise(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: Promise<unknown>,
-): SerovalPromiseConstructorNode {
-  // Creates a unique reference for the promise resolver
-  const resolver = createIndexForValue(ctx.base, {});
-  if (ctx.type === ParserMode.Stream) {
-    pushPendingState(ctx);
-    current.then(
-      handlePromiseSuccess.bind(ctx, resolver, depth),
-      handlePromiseFailure.bind(ctx, resolver, depth),
-    );
-  }
-  return createPromiseConstructorNode(ctx.base, id, resolver);
-}
-
-function parsePluginSync(
-  ctx: SyncParserContext,
-  depth: number,
-  id: number,
-  current: unknown,
-  currentPlugins: Plugin<any, any>[],
-): SerovalPluginNode | undefined {
-  for (let i = 0, len = currentPlugins.length; i < len; i++) {
-    const plugin = currentPlugins[i];
-    if (plugin.parse.sync && plugin.test(current)) {
-      return createPluginNode(
-        id,
-        plugin.tag,
-        plugin.parse.sync(current, new SyncParsePluginContext(ctx, depth), {
-          id,
-        }),
-      );
-    }
-  }
-  return NIL;
-}
-
-function parsePluginStream(
-  ctx: StreamParserContext,
-  depth: number,
-  id: number,
-  current: unknown,
-  currentPlugins: Plugin<any, any>[],
-): SerovalPluginNode | undefined {
-  for (let i = 0, len = currentPlugins.length; i < len; i++) {
-    const plugin = currentPlugins[i];
-    if (plugin.parse.stream && plugin.test(current)) {
-      return createPluginNode(
-        id,
-        plugin.tag,
-        plugin.parse.stream(current, new StreamParsePluginContext(ctx, depth), {
-          id,
-        }),
-      );
-    }
-  }
-  return NIL;
-}
-
-function parsePlugin(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: unknown,
-): SerovalPluginNode | undefined {
-  const currentPlugins = ctx.base.plugins;
-  if (currentPlugins) {
-    return ctx.type === ParserMode.Sync
-      ? parsePluginSync(ctx, depth, id, current, currentPlugins)
-      : parsePluginStream(ctx, depth, id, current, currentPlugins);
-  }
-  return NIL;
-}
-
-function parseSequence(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: Sequence,
-): SerovalSequenceNode {
-  const nodes: SerovalNode[] = [];
-  for (let i = 0, len = current.v.length; i < len; i++) {
-    nodes[i] = parseSOS(ctx, depth, current.v[i]);
-  }
-  return createSequenceNode(id, nodes, current.t, current.d);
-}
-
-function parseObjectPhase2(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: object,
-  currentClass: unknown,
-): SerovalNode {
-  switch (currentClass) {
-    case Object:
-      return parsePlainObject(
-        ctx,
-        depth,
-        id,
-        current as Record<string, unknown>,
-        false,
-      );
-    case NIL:
-      return parsePlainObject(
-        ctx,
-        depth,
-        id,
-        current as Record<string, unknown>,
-        true,
-      );
-    case Date:
-      return createDateNode(id, current as unknown as Date);
-    case Error:
-    case EvalError:
-    case RangeError:
-    case ReferenceError:
-    case SyntaxError:
-    case TypeError:
-    case URIError:
-      return parseError(ctx, depth, id, current as unknown as Error);
-    case Number:
-    case Boolean:
-    case String:
-    case BigInt:
-      return parseBoxed(ctx, depth, id, current);
-    case ArrayBuffer:
-      return createArrayBufferNode(
-        ctx.base,
-        id,
-        current as unknown as ArrayBuffer,
-      );
-    case Int8Array:
-    case Int16Array:
-    case Int32Array:
-    case Uint8Array:
-    case Uint16Array:
-    case Uint32Array:
-    case Uint8ClampedArray:
-    case Float32Array:
-    case Float64Array:
-      return parseTypedArray(
-        ctx,
-        depth,
-        id,
-        current as unknown as TypedArrayValue,
-      );
-    case DataView:
-      return parseDataView(ctx, depth, id, current as unknown as DataView);
-    case Map:
-      return parseMap(
-        ctx,
-        depth,
-        id,
-        current as unknown as Map<unknown, unknown>,
-      );
-    case Set:
-      return parseSet(ctx, depth, id, current as unknown as Set<unknown>);
-    default:
-      break;
-  }
-  // Promises
-  if (currentClass === Promise || current instanceof Promise) {
-    return parsePromise(ctx, depth, id, current as unknown as Promise<unknown>);
-  }
-  const currentFeatures = ctx.base.features;
-  if (currentFeatures & Feature.RegExp && currentClass === RegExp) {
-    return createRegExpNode(id, current as unknown as RegExp);
-  }
-  // BigInt Typed Arrays
-  if (currentFeatures & Feature.BigIntTypedArray) {
-    switch (currentClass) {
-      case BigInt64Array:
-      case BigUint64Array:
-        return parseBigIntTypedArray(
-          ctx,
-          depth,
-          id,
-          current as unknown as BigIntTypedArrayValue,
-        );
-      default:
-        break;
-    }
-  }
-  if (
-    currentFeatures & Feature.AggregateError &&
-    typeof AggregateError !== 'undefined' &&
-    (currentClass === AggregateError || current instanceof AggregateError)
-  ) {
-    return parseAggregateError(
-      ctx,
-      depth,
-      id,
-      current as unknown as AggregateError,
-    );
-  }
-  // Slow path. We only need to handle Errors and Iterators
-  // since they have very broad implementations.
-  if (current instanceof Error) {
-    return parseError(ctx, depth, id, current);
-  }
-  // Generator functions don't have a global constructor
-  // despite existing
-  if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) {
-    return parsePlainObject(ctx, depth, id, current, !!currentClass);
-  }
-  throw new SerovalUnsupportedTypeError(current);
-}
-
-function parseObject(
-  ctx: SOSParserContext,
-  depth: number,
-  id: number,
-  current: object,
-): SerovalNode {
-  if (Array.isArray(current)) {
-    return parseArray(ctx, depth, id, current);
-  }
-  if (isStream(current)) {
-    return parseStream(ctx, depth, id, current);
-  }
-  if (isSequence(current)) {
-    return parseSequence(ctx, depth, id, current);
-  }
-  const currentClass = current.constructor;
-  if (currentClass === OpaqueReference) {
-    return parseSOS(
-      ctx,
-      depth,
-      (current as OpaqueReference<unknown, unknown>).replacement,
-    );
-  }
-  const parsed = parsePlugin(ctx, depth, id, current);
-  if (parsed) {
-    return parsed;
-  }
-  return parseObjectPhase2(ctx, depth, id, current, currentClass);
-}
-
-function parseFunction(
-  ctx: SOSParserContext,
-  depth: number,
-  current: unknown,
-): SerovalNode {
-  const ref = getReferenceNode(ctx.base, current);
-  if (ref.type !== ParserNodeType.Fresh) {
-    return ref.value;
-  }
-  const plugin = parsePlugin(ctx, depth, ref.value, current);
-  if (plugin) {
-    return plugin;
-  }
-  throw new SerovalUnsupportedTypeError(current);
-}
-
-export function parseSOS<T>(
-  ctx: SOSParserContext,
-  depth: number,
-  current: T,
-): SerovalNode {
-  if (depth >= ctx.base.depthLimit) {
-    throw new SerovalDepthLimitError(ctx.base.depthLimit);
-  }
-  switch (typeof current) {
-    case 'boolean':
-      return current ? TRUE_NODE : FALSE_NODE;
-    case 'undefined':
-      return UNDEFINED_NODE;
-    case 'string':
-      return createStringNode(current as string);
-    case 'number':
-      return createNumberNode(current as number);
-    case 'bigint':
-      return createBigIntNode(current as bigint);
-    case 'object': {
-      if (current) {
-        const ref = getReferenceNode(ctx.base, current);
-        return ref.type === ParserNodeType.Fresh
-          ? parseObject(ctx, depth + 1, ref.value, current as object)
-          : ref.value;
-      }
-      return NULL_NODE;
-    }
-    case 'symbol':
-      return parseWellKnownSymbol(ctx.base, current);
-    case 'function': {
-      return parseFunction(ctx, depth, current);
-    }
-    default:
-      throw new SerovalUnsupportedTypeError(current);
-  }
-}
-
-export function parseTop<T>(ctx: SyncParserContext, current: T): SerovalNode {
-  try {
-    return parseSOS(ctx, 0, current);
-  } catch (error) {
-    throw error instanceof SerovalParserError
-      ? error
-      : new SerovalParserError(error);
-  }
-}
-
-function onParse(ctx: StreamParserContext, node: SerovalNode): void {
-  // If the value emitted happens to be during parsing, we push to the
-  // buffer and emit after the initial parsing is done.
-  if (ctx.state.initial) {
-    ctx.state.buffer.push(node);
-  } else {
-    onParseInternal(ctx, node, false);
-  }
-}
-
-function onError(ctx: StreamParserContext, error: unknown): void {
-  if (ctx.state.onError) {
-    ctx.state.onError(error);
-  } else {
-    throw error instanceof SerovalParserError
-      ? error
-      : new SerovalParserError(error);
-  }
-}
-
-function onDone(ctx: StreamParserContext): void {
-  if (ctx.state.onDone) {
-    ctx.state.onDone();
-  }
-
-  for (let i = 0, len = ctx.state.cleanups.length; i < len; i++) {
-    ctx.state.cleanups[i]();
-  }
-}
-
-function onParseInternal(
-  ctx: StreamParserContext,
-  node: SerovalNode,
-  initial: boolean,
-): void {
-  try {
-    ctx.state.onParse(node, initial);
-  } catch (error) {
-    onError(ctx, error);
-  }
-}
-
-function pushPendingState(ctx: StreamParserContext): void {
-  ctx.state.pending++;
-}
-
-function popPendingState(ctx: StreamParserContext): void {
-  if (--ctx.state.pending <= 0) {
-    onDone(ctx);
-  }
-}
-
-function parseWithError<T>(
-  ctx: StreamParserContext,
-  depth: number,
-  current: T,
-): SerovalNode | undefined {
-  try {
-    return parseSOS(ctx, depth, current);
-  } catch (err) {
-    onError(ctx, err);
-    return NIL;
-  }
-}
-
-export function startStreamParse<T>(
-  ctx: StreamParserContext,
-  current: T,
-): void {
-  const parsed = parseWithError(ctx, 0, current);
-  if (parsed) {
-    onParseInternal(ctx, parsed, true);
-    ctx.state.initial = false;
-    flushStreamParse(ctx, ctx.state);
-
-    // Check if there's any pending pushes
-    if (ctx.state.pending <= 0) {
-      destroyStreamParse(ctx);
-    }
-  }
-}
-
-function flushStreamParse(
-  ctx: StreamParserContext,
-  state: StreamParserState,
-): void {
-  for (let i = 0, len = state.buffer.length; i < len; i++) {
-    onParseInternal(ctx, state.buffer[i], false);
-  }
-}
-
-export function destroyStreamParse(ctx: StreamParserContext): void {
-  if (ctx.state.alive) {
-    onDone(ctx);
-    ctx.state.alive = false;
-  }
-}

src/core/cross/index.ts

-import type { AsyncParserContextOptions } from '../context/async-parser';
-import {
-  createAsyncParserContext,
-  parseTopAsync,
-} from '../context/async-parser';
-import type { CrossDeserializerContextOptions } from '../context/deserializer';
-import {
-  createCrossDeserializerContext,
-  deserializeTop,
-} from '../context/deserializer';
-import type { CrossContextOptions } from '../context/serializer';
-import {
-  createCrossSerializerContext,
-  serializeTopCross,
-} from '../context/serializer';
-import type {
-  StreamParserContextOptions,
-  SyncParserContextOptions,
-} from '../context/sync-parser';
-import {
-  createStreamParserContext,
-  createSyncParserContext,
-  destroyStreamParse,
-  parseTop,
-  startStreamParse,
-} from '../context/sync-parser';
-import { resolvePlugins, SerovalMode } from '../plugin';
-import type { SerovalNode } from '../types';
-
-export interface CrossSerializeOptions
-  extends SyncParserContextOptions,
-    CrossContextOptions {}
-
-export function crossSerialize<T>(
-  source: T,
-  options: CrossSerializeOptions = {},
-): string {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createSyncParserContext(SerovalMode.Cross, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  const tree = parseTop(ctx, source);
-  const serial = createCrossSerializerContext({
-    plugins,
-    features: ctx.base.features,
-    scopeId: options.scopeId,
-    markedRefs: ctx.base.marked,
-  });
-  return serializeTopCross(serial, tree);
-}
-
-export interface CrossSerializeAsyncOptions
-  extends AsyncParserContextOptions,
-    CrossContextOptions {}
-
-export async function crossSerializeAsync<T>(
-  source: T,
-  options: CrossSerializeAsyncOptions = {},
-): Promise<string> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createAsyncParserContext(SerovalMode.Cross, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  const tree = await parseTopAsync(ctx, source);
-  const serial = createCrossSerializerContext({
-    plugins,
-    features: ctx.base.features,
-    scopeId: options.scopeId,
-    markedRefs: ctx.base.marked,
-  });
-  return serializeTopCross(serial, tree);
-}
-
-export type ToCrossJSONOptions = SyncParserContextOptions;
-
-export function toCrossJSON<T>(
-  source: T,
-  options: ToCrossJSONOptions = {},
-): SerovalNode {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createSyncParserContext(SerovalMode.Cross, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  return parseTop(ctx, source);
-}
-
-export type ToCrossJSONAsyncOptions = AsyncParserContextOptions;
-
-export async function toCrossJSONAsync<T>(
-  source: T,
-  options: ToCrossJSONAsyncOptions = {},
-): Promise<SerovalNode> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createAsyncParserContext(SerovalMode.Cross, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  return await parseTopAsync(ctx, source);
-}
-
-export interface CrossSerializeStreamOptions
-  extends Omit<StreamParserContextOptions, 'onParse'>,
-    CrossContextOptions {
-  onSerialize: (data: string, initial: boolean) => void;
-}
-
-export function crossSerializeStream<T>(
-  source: T,
-  options: CrossSerializeStreamOptions,
-): () => void {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createStreamParserContext({
-    plugins,
-    refs: options.refs,
-    disabledFeatures: options.disabledFeatures,
-    onParse(node, initial): void {
-      const serial = createCrossSerializerContext({
-        plugins,
-        features: ctx.base.features,
-        scopeId: options.scopeId,
-        markedRefs: ctx.base.marked,
-      });
-
-      let serialized: string;
-
-      try {
-        serialized = serializeTopCross(serial, node);
-      } catch (err) {
-        if (options.onError) {
-          options.onError(err);
-        }
-        return;
-      }
-
-      options.onSerialize(serialized, initial);
-    },
-    onError: options.onError,
-    onDone: options.onDone,
-  });
-
-  startStreamParse(ctx, source);
-
-  return destroyStreamParse.bind(null, ctx);
-}
-
-export type ToCrossJSONStreamOptions = StreamParserContextOptions;
-
-export function toCrossJSONStream<T>(
-  source: T,
-  options: ToCrossJSONStreamOptions,
-): () => void {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createStreamParserContext({
-    plugins,
-    refs: options.refs,
-    disabledFeatures: options.disabledFeatures,
-    depthLimit: options.depthLimit,
-    onParse: options.onParse,
-    onError: options.onError,
-    onDone: options.onDone,
-  });
-
-  startStreamParse(ctx, source);
-
-  return destroyStreamParse.bind(null, ctx);
-}
-
-export type FromCrossJSONOptions = CrossDeserializerContextOptions;
-
-export function fromCrossJSON<T>(
-  source: SerovalNode,
-  options: FromCrossJSONOptions,
-): T {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createCrossDeserializerContext({
-    plugins,
-    refs: options.refs,
-    features: options.features,
-    disabledFeatures: options.disabledFeatures,
-    depthLimit: options.depthLimit,
-  });
-  return deserializeTop(ctx, source) as T;
-}

src/core/errors.ts

-/// <reference types="pridepack/env" />
-
-import { serializeString } from './string';
-import type { SerovalNode } from './types';
-
-const { toString: objectToString } = /* @__PURE__ */ Object.prototype;
-
-const enum StepErrorCodes {
-  Parse = 1,
-  Serialize = 2,
-  Deserialize = 3,
-}
-
-function getErrorMessageDev(type: string, cause: unknown): string {
-  if (cause instanceof Error) {
-    return `Seroval caught an error during the ${type} process.
-
-${cause.name}
-${cause.message}
-
-- For more information, please check the "cause" property of this error.
-- If you believe this is an error in Seroval, please submit an issue at https://github.com/lxsmnsyc/seroval/issues/new`;
-  }
-  return `Seroval caught an error during the ${type} process.
-
-"${objectToString.call(cause)}"
-
-For more information, please check the "cause" property of this error.`;
-}
-
-const STEP_ERROR_CODES: Record<string, StepErrorCodes> = {
-  parsing: StepErrorCodes.Parse,
-  serialization: StepErrorCodes.Serialize,
-  deserialization: StepErrorCodes.Deserialize,
-};
-
-function getErrorMessageProd(type: string): string {
-  return `Seroval Error (step: ${STEP_ERROR_CODES[type]})`;
-}
-
-const getErrorMessage = (type: string, cause: any) =>
-  import.meta.env.PROD
-    ? getErrorMessageProd(type)
-    : getErrorMessageDev(type, cause);
-
-export class SerovalError extends Error {
-  constructor(
-    type: string,
-    public cause: unknown,
-  ) {
-    super(getErrorMessage(type, cause));
-  }
-}
-
-export class SerovalParserError extends SerovalError {
-  constructor(cause: unknown) {
-    super('parsing', cause);
-  }
-}
-
-export class SerovalSerializationError extends SerovalError {
-  constructor(cause: unknown) {
-    super('serialization', cause);
-  }
-}
-
-export class SerovalDeserializationError extends SerovalError {
-  constructor(cause: unknown) {
-    super('deserialization', cause);
-  }
-}
-
-const enum SpecificErrorCodes {
-  UnsupportedType = 1,
-  UnsupportedNode = 2,
-  MissingPlugin = 3,
-  MissingInstance = 4,
-  MissingReference = 5,
-  MissingReferenceForId = 6,
-  UnknownTypedArray = 7,
-  MalformedNode = 8,
-  ConflictedNodeId = 9,
-  DepthLimit = 10,
-}
-
-function getSpecificErrorMessage(code: SpecificErrorCodes): string {
-  return `Seroval Error (specific: ${code})`;
-}
-
-export class SerovalUnsupportedTypeError extends Error {
-  constructor(public value: unknown) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedType)
-        : `The value ${objectToString.call(value)} of type "${typeof value}" cannot be parsed/serialized.
-      
-There are few workarounds for this problem:
-- Transform the value in a way that it can be serialized.
-- If the reference is present on multiple runtimes (isomorphic), you can use the Reference API to map the references.`,
-    );
-  }
-}
-
-export class SerovalUnsupportedNodeError extends Error {
-  constructor(node: SerovalNode) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedNode)
-        : 'Unsupported node type "' + node.t + '".',
-    );
-  }
-}
-
-export class SerovalMissingPluginError extends Error {
-  constructor(tag: string) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MissingPlugin)
-        : 'Missing plugin for tag "' + tag + '".',
-    );
-  }
-}
-
-export class SerovalMissingInstanceError extends Error {
-  constructor(tag: string) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MissingInstance)
-        : 'Missing "' + tag + '" instance.',
-    );
-  }
-}
-
-export class SerovalMissingReferenceError extends Error {
-  constructor(public value: unknown) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MissingReference)
-        : 'Missing reference for the value "' +
-            objectToString.call(value) +
-            '" of type "' +
-            typeof value +
-            '"',
-    );
-  }
-}
-
-export class SerovalMissingReferenceForIdError extends Error {
-  constructor(id: string) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MissingReferenceForId)
-        : 'Missing reference for id "' + serializeString(id) + '"',
-    );
-  }
-}
-
-export class SerovalUnknownTypedArrayError extends Error {
-  constructor(name: string) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.UnknownTypedArray)
-        : 'Unknown TypedArray "' + name + '"',
-    );
-  }
-}
-
-export class SerovalMalformedNodeError extends Error {
-  constructor(node: SerovalNode) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MalformedNode)
-        : 'Malformed node type "' + node.t + '".',
-    );
-  }
-}
-
-export class SerovalConflictedNodeIdError extends Error {
-  constructor(node: SerovalNode) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.ConflictedNodeId)
-        : 'Conflicted node id "' + node.i + '".',
-    );
-  }
-}
-
-export class SerovalDepthLimitError extends Error {
-  constructor(limit: number) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.ConflictedNodeId)
-        : 'Depth limit of ' + limit + ' reached',
-    );
-  }
-}

src/core/function-string.ts

-declare const T: unknown;
-
-const RETURN = () => T;
-const SERIALIZED_RETURN = /* @__PURE__ */ RETURN.toString();
-
-const IS_MODERN = /* @__PURE__ */ /=>/.test(SERIALIZED_RETURN);
-
-export function createFunction(parameters: string[], body: string): string {
-  if (IS_MODERN) {
-    const joined =
-      parameters.length === 1
-        ? parameters[0]
-        : '(' + parameters.join(',') + ')';
-    return joined + '=>' + (body.startsWith('{') ? '(' + body + ')' : body);
-  }
-  return 'function(' + parameters.join(',') + '){return ' + body + '}';
-}
-
-export function createEffectfulFunction(
-  parameters: string[],
-  body: string,
-): string {
-  if (IS_MODERN) {
-    const joined =
-      parameters.length === 1
-        ? parameters[0]
-        : '(' + parameters.join(',') + ')';
-    return joined + '=>{' + body + '}';
-  }
-  return 'function(' + parameters.join(',') + '){' + body + '}';
-}

src/core/keys.ts

-import { serializeString } from './string';
-
-// Used for mapping isomorphic references
-export const REFERENCES_KEY = '__SEROVAL_REFS__';
-
-export const GLOBAL_CONTEXT_REFERENCES = '$R';
-
-const GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`;
-
-export function getCrossReferenceHeader(id?: string): string {
-  if (id == null) {
-    return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
-  }
-  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(
-    id,
-  )}"]=[]`;
-}

src/core/literals.ts

-import { NIL, SerovalConstant, SerovalNodeType } from './constants';
-import { createSerovalNode } from './node';
-import type { SerovalConstantNode } from './types';
-
-function createConstantNode(value: SerovalConstant): SerovalConstantNode {
-  return createSerovalNode(
-    SerovalNodeType.Constant,
-    NIL,
-    value,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export const TRUE_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.True,
-);
-export const FALSE_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.False,
-);
-export const UNDEFINED_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.Undefined,
-);
-export const NULL_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.Null,
-);
-export const NEG_ZERO_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.NegZero,
-);
-export const INFINITY_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.Inf,
-);
-export const NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.NegInf,
-);
-export const NAN_NODE = /* @__PURE__ */ createConstantNode(SerovalConstant.Nan);

src/core/node.ts

-import type { SerovalNodeType } from './constants';
-import type { SerovalNode } from './types';
-
-type ExtractedNodeType<T extends SerovalNodeType> = Extract<
-  SerovalNode,
-  { t: T }
->;
-
-export function createSerovalNode<
-  T extends SerovalNodeType,
-  N extends ExtractedNodeType<T>,
->(
-  t: T,
-  i: N['i'],
-  s: N['s'],
-  c: N['c'],
-  m: N['m'],
-  p: N['p'],
-  e: N['e'],
-  a: N['a'],
-  f: N['f'],
-  b: N['b'],
-  o: N['o'],
-  l: N['l'],
-): N {
-  return {
-    t,
-    i,
-    s,
-    c,
-    m,
-    p,
-    e,
-    a,
-    f,
-    b,
-    o,
-    l,
-  } as N;
-}

src/core/opaque-reference.ts

-/**
- * An opaque reference allows hiding values from the serializer.
- */
-export class OpaqueReference<V, R = undefined> {
-  constructor(
-    public readonly value: V,
-    public readonly replacement?: R,
-  ) {}
-}

src/core/plugin.ts

-import type { AsyncParsePluginContext } from './context/async-parser';
-import type { DeserializePluginContext } from './context/deserializer';
-import type { SerializePluginContext } from './context/serializer';
-import type {
-  StreamParsePluginContext,
-  SyncParsePluginContext,
-} from './context/sync-parser';
-import type { SerovalNode } from './types';
-
-export const enum SerovalMode {
-  Vanilla = 1,
-  Cross = 2,
-}
-
-export interface PluginData {
-  id: number;
-}
-
-export type PluginInfo = {
-  [key: string]: SerovalNode;
-};
-
-export interface Plugin<Value, Info extends PluginInfo> {
-  /**
-   * A unique string that helps idenfity the plugin
-   */
-  tag: string;
-  /**
-   * List of dependency plugins
-   */
-  extends?: Plugin<any, any>[];
-  /**
-   * Method to test if a value is an expected value of the plugin
-   * @param value
-   */
-  test(value: unknown): boolean;
-  /**
-   * Parsing modes
-   */
-  parse: {
-    sync?: (
-      value: Value,
-      ctx: SyncParsePluginContext,
-      data: PluginData,
-    ) => Info;
-    async?: (
-      value: Value,
-      ctx: AsyncParsePluginContext,
-      data: PluginData,
-    ) => Promise<Info>;
-    stream?: (
-      value: Value,
-      ctx: StreamParsePluginContext,
-      data: PluginData,
-    ) => Info;
-  };
-  /**
-   * Convert the parsed node into a JS string
-   */
-  serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;
-  /**
-   * Convert the parsed node into its runtime equivalent.
-   */
-  deserialize(
-    node: Info,
-    ctx: DeserializePluginContext,
-    data: PluginData,
-  ): Value;
-}
-
-export function createPlugin<Value, Info extends PluginInfo>(
-  plugin: Plugin<Value, Info>,
-): Plugin<Value, Info> {
-  return plugin;
-}
-
-export interface PluginAccessOptions {
-  plugins?: Plugin<any, any>[];
-}
-
-function dedupePlugins(
-  deduped: Set<Plugin<any, any>>,
-  plugins: Plugin<any, any>[],
-): void {
-  for (let i = 0, len = plugins.length; i < len; i++) {
-    const current = plugins[i];
-    if (!deduped.has(current)) {
-      deduped.add(current);
-      if (current.extends) {
-        dedupePlugins(deduped, current.extends);
-      }
-    }
-  }
-}
-
-export function resolvePlugins(
-  plugins?: Plugin<any, any>[],
-): Plugin<any, any>[] | undefined {
-  if (plugins) {
-    const deduped = new Set<Plugin<any, any>>();
-    dedupePlugins(deduped, plugins);
-    return [...deduped];
-  }
-  return undefined;
-}

src/core/reference.ts

-import {
-  SerovalMissingReferenceError,
-  SerovalMissingReferenceForIdError,
-} from '..';
-import { REFERENCES_KEY } from './keys';
-
-const REFERENCE = new Map<unknown, string>();
-const INV_REFERENCE = new Map<string, unknown>();
-
-export function createReference<T>(id: string, value: T): T {
-  REFERENCE.set(value, id);
-  INV_REFERENCE.set(id, value);
-  return value;
-}
-
-export function hasReferenceID<T>(value: T): boolean {
-  return REFERENCE.has(value);
-}
-
-export function hasReference(id: string): boolean {
-  return INV_REFERENCE.has(id);
-}
-
-export function getReferenceID<T>(value: T): string {
-  if (hasReferenceID(value)) {
-    return REFERENCE.get(value)!;
-  }
-  throw new SerovalMissingReferenceError(value);
-}
-
-export function getReference<T>(id: string): T {
-  if (hasReference(id)) {
-    return INV_REFERENCE.get(id) as T;
-  }
-  throw new SerovalMissingReferenceForIdError(id);
-}
-
-if (typeof globalThis !== 'undefined') {
-  Object.defineProperty(globalThis, REFERENCES_KEY, {
-    value: INV_REFERENCE,
-    configurable: true,
-    writable: false,
-    enumerable: false,
-  });
-} else if (typeof window !== 'undefined') {
-  Object.defineProperty(window, REFERENCES_KEY, {
-    value: INV_REFERENCE,
-    configurable: true,
-    writable: false,
-    enumerable: false,
-  });
-} else if (typeof self !== 'undefined') {
-  Object.defineProperty(self, REFERENCES_KEY, {
-    value: INV_REFERENCE,
-    configurable: true,
-    writable: false,
-    enumerable: false,
-  });
-} else if (typeof global !== 'undefined') {
-  Object.defineProperty(global, REFERENCES_KEY, {
-    value: INV_REFERENCE,
-    configurable: true,
-    writable: false,
-    enumerable: false,
-  });
-}

src/core/sequence.ts

-import { ITERATOR_CONSTRUCTOR } from './constructors';
-import { SYM_ITERATOR } from './symbols';
-
-export interface Sequence {
-  __SEROVAL_SEQUENCE__: true;
-
-  v: unknown[];
-  t: number;
-  d: number;
-}
-
-export function isSequence(value: object): value is Sequence {
-  return '__SEROVAL_SEQUENCE__' in value;
-}
-
-export function createSequence(
-  values: unknown[],
-  throwAt: number,
-  doneAt: number,
-): Sequence {
-  return {
-    __SEROVAL_SEQUENCE__: true,
-
-    v: values,
-    t: throwAt,
-    d: doneAt,
-  };
-}
-
-export function createSequenceFromIterable<T>(source: Iterable<T>): Sequence {
-  const values: unknown[] = [];
-  let throwsAt = -1;
-  let doneAt = -1;
-  const iterator = source[SYM_ITERATOR]();
-
-  while (true) {
-    try {
-      const value = iterator.next();
-      values.push(value.value);
-      if (value.done) {
-        doneAt = values.length - 1;
-        break;
-      }
-    } catch (error) {
-      throwsAt = values.length;
-      values.push(error);
-    }
-  }
-
-  return createSequence(values, throwsAt, doneAt);
-}
-
-const createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
-
-export function sequenceToIterator<T>(
-  sequence: Sequence,
-): () => IterableIterator<T> {
-  return createIterator(sequence) as unknown as () => IterableIterator<T>;
-}

src/core/Serializer.ts

-import { crossSerializeStream } from './cross';
-import {
-  resolvePlugins,
-  type Plugin,
-  type PluginAccessOptions,
-} from './plugin';
-import { serializeString } from './string';
-
-export interface SerializerOptions extends PluginAccessOptions {
-  globalIdentifier: string;
-  scopeId?: string;
-  disabledFeatures?: number;
-  onData: (result: string) => void;
-  onError: (error: unknown) => void;
-  onDone?: () => void;
-}
-
-export default class Serializer {
-  private alive = true;
-
-  private flushed = false;
-
-  private done = false;
-
-  private pending = 0;
-
-  private cleanups: (() => void)[] = [];
-
-  private refs = new Map<unknown, number>();
-
-  private plugins?: Plugin<any, any>[];
-
-  constructor(private options: SerializerOptions) {
-    this.plugins = resolvePlugins(options.plugins);
-  }
-
-  keys = new Set<string>();
-
-  write(key: string, value: unknown): void {
-    if (this.alive && !this.flushed) {
-      this.pending++;
-      this.keys.add(key);
-      this.cleanups.push(
-        crossSerializeStream(value, {
-          plugins: this.plugins,
-          scopeId: this.options.scopeId,
-          refs: this.refs,
-          disabledFeatures: this.options.disabledFeatures,
-          onError: this.options.onError,
-          onSerialize: (data, initial) => {
-            if (this.alive) {
-              this.options.onData(
-                initial
-                  ? this.options.globalIdentifier +
-                      '["' +
-                      serializeString(key) +
-                      '"]=' +
-                      data
-                  : data,
-              );
-            }
-          },
-          onDone: () => {
-            if (this.alive) {
-              this.pending--;
-              if (
-                this.pending <= 0 &&
-                this.flushed &&
-                !this.done &&
-                this.options.onDone
-              ) {
-                this.options.onDone();
-                this.done = true;
-              }
-            }
-          },
-        }),
-      );
-    }
-  }
-
-  ids = 0;
-
-  private getNextID(): string {
-    while (this.keys.has('' + this.ids)) {
-      this.ids++;
-    }
-    return '' + this.ids;
-  }
-
-  push(value: unknown): string {
-    const newID = this.getNextID();
-    this.write(newID, value);
-    return newID;
-  }
-
-  flush(): void {
-    if (this.alive) {
-      this.flushed = true;
-      if (this.pending <= 0 && !this.done && this.options.onDone) {
-        this.options.onDone();
-        this.done = true;
-      }
-    }
-  }
-
-  close(): void {
-    if (this.alive) {
-      for (let i = 0, len = this.cleanups.length; i < len; i++) {
-        this.cleanups[i]();
-      }
-      if (!this.done && this.options.onDone) {
-        this.options.onDone();
-        this.done = true;
-      }
-      this.alive = false;
-    }
-  }
-}

src/core/special-reference.ts

-import {
-  SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
-  SERIALIZED_PROMISE_CONSTRUCTOR,
-  SERIALIZED_PROMISE_FAILURE,
-  SERIALIZED_PROMISE_SUCCESS,
-  SERIALIZED_STREAM_CONSTRUCTOR,
-} from './constructors';
-
-export const ITERATOR = {};
-
-export const ASYNC_ITERATOR = {};
-
-export const enum SpecialReference {
-  MapSentinel = 0,
-  PromiseConstructor = 1,
-  PromiseSuccess = 2,
-  PromiseFailure = 3,
-  StreamConstructor = 4,
-  ArrayBufferConstructor = 5,
-}
-
-/**
- * Placeholder references
- */
-export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
-  [SpecialReference.MapSentinel]: {},
-  [SpecialReference.PromiseConstructor]: {},
-  [SpecialReference.PromiseSuccess]: {},
-  [SpecialReference.PromiseFailure]: {},
-  [SpecialReference.StreamConstructor]: {},
-  [SpecialReference.ArrayBufferConstructor]: {},
-};
-
-export const SPECIAL_REF_STRING: Record<SpecialReference, string> = {
-  [SpecialReference.MapSentinel]: '[]',
-  [SpecialReference.PromiseConstructor]: SERIALIZED_PROMISE_CONSTRUCTOR,
-  [SpecialReference.PromiseSuccess]: SERIALIZED_PROMISE_SUCCESS,
-  [SpecialReference.PromiseFailure]: SERIALIZED_PROMISE_FAILURE,
-  [SpecialReference.StreamConstructor]: SERIALIZED_STREAM_CONSTRUCTOR,
-  [SpecialReference.ArrayBufferConstructor]:
-    SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
-};

src/core/stream.ts

-import {
-  ASYNC_ITERATOR_CONSTRUCTOR,
-  PROMISE_CONSTRUCTOR,
-  STREAM_CONSTRUCTOR,
-} from './constructors';
-import { SYM_ASYNC_ITERATOR } from './symbols';
-
-export interface StreamListener<T> {
-  next(value: T): void;
-  throw(value: unknown): void;
-  return(value: T): void;
-}
-
-export interface Stream<T> {
-  __SEROVAL_STREAM__: true;
-
-  on(listener: StreamListener<T>): () => void;
-
-  next(value: T): void;
-  throw(value: unknown): void;
-  return(value: T): void;
-}
-
-export function isStream<T>(value: object): value is Stream<T> {
-  return '__SEROVAL_STREAM__' in value;
-}
-
-export function createStream<T>(): Stream<T> {
-  return STREAM_CONSTRUCTOR() as unknown as Stream<T>;
-}
-
-export function createStreamFromAsyncIterable<T>(
-  iterable: AsyncIterable<T>,
-): Stream<T> {
-  const stream = createStream<T>();
-
-  const iterator = iterable[SYM_ASYNC_ITERATOR]();
-
-  async function push(): Promise<void> {
-    try {
-      const value = await iterator.next();
-      if (value.done) {
-        stream.return(value.value as T);
-      } else {
-        stream.next(value.value);
-        await push();
-      }
-    } catch (error) {
-      stream.throw(error);
-    }
-  }
-
-  push().catch(() => {
-    // no-op
-  });
-
-  return stream;
-}
-
-const createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(
-  SYM_ASYNC_ITERATOR,
-  PROMISE_CONSTRUCTOR,
-);
-
-export function streamToAsyncIterable<T>(
-  stream: Stream<T>,
-): () => AsyncIterableIterator<T> {
-  return createAsyncIterable(
-    stream,
-  ) as unknown as () => AsyncIterableIterator<T>;
-}

src/core/string.ts

-import { NIL } from './constants';
-
-export function serializeChar(str: string): string | undefined {
-  switch (str) {
-    case '"':
-      return '\\"';
-    case '\\':
-      return '\\\\';
-    case '\n':
-      return '\\n';
-    case '\r':
-      return '\\r';
-    case '\b':
-      return '\\b';
-    case '\t':
-      return '\\t';
-    case '\f':
-      return '\\f';
-    case '<':
-      return '\\x3C';
-    case '\u2028':
-      return '\\u2028';
-    case '\u2029':
-      return '\\u2029';
-    default:
-      return NIL;
-  }
-}
-
-// Written by https://github.com/DylanPiercey and is distributed under the MIT license.
-// Creates a JavaScript double quoted string and escapes all characters
-// not listed as DoubleStringCharacters on
-// Also includes "<" to escape "</script>" and "\" to avoid invalid escapes in the output.
-// http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
-export function serializeString(str: string): string {
-  let result = '';
-  let lastPos = 0;
-  let replacement: string | undefined;
-  for (let i = 0, len = str.length; i < len; i++) {
-    replacement = serializeChar(str[i]);
-    if (replacement) {
-      result += str.slice(lastPos, i) + replacement;
-      lastPos = i + 1;
-    }
-  }
-  if (lastPos === 0) {
-    result = str;
-  } else {
-    result += str.slice(lastPos);
-  }
-  return result;
-}
-
-function deserializeReplacer(str: string): string {
-  switch (str) {
-    case '\\\\':
-      return '\\';
-    case '\\"':
-      return '"';
-    case '\\n':
-      return '\n';
-    case '\\r':
-      return '\r';
-    case '\\b':
-      return '\b';
-    case '\\t':
-      return '\t';
-    case '\\f':
-      return '\f';
-    case '\\x3C':
-      return '\x3C';
-    case '\\u2028':
-      return '\u2028';
-    case '\\u2029':
-      return '\u2029';
-    default:
-      return str;
-  }
-}
-
-export function deserializeString(str: string): string {
-  return str.replace(
-    /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,
-    deserializeReplacer,
-  );
-}

src/core/symbols.ts

-export const SYM_ASYNC_ITERATOR: typeof Symbol.asyncIterator =
-  Symbol.asyncIterator;
-export const SYM_HAS_INSTANCE: typeof Symbol.hasInstance = Symbol.hasInstance;
-export const SYM_IS_CONCAT_SPREADABLE: typeof Symbol.isConcatSpreadable =
-  Symbol.isConcatSpreadable;
-export const SYM_ITERATOR: typeof Symbol.iterator = Symbol.iterator;
-export const SYM_MATCH: typeof Symbol.match = Symbol.match;
-export const SYM_MATCH_ALL: typeof Symbol.matchAll = Symbol.matchAll;
-export const SYM_REPLACE: typeof Symbol.replace = Symbol.replace;
-export const SYM_SEARCH: typeof Symbol.search = Symbol.search;
-export const SYM_SPECIES: typeof Symbol.species = Symbol.species;
-export const SYM_SPLIT: typeof Symbol.split = Symbol.split;
-export const SYM_TO_PRIMITIVE: typeof Symbol.toPrimitive = Symbol.toPrimitive;
-export const SYM_TO_STRING_TAG: typeof Symbol.toStringTag = Symbol.toStringTag;
-export const SYM_UNSCOPABLES: typeof Symbol.unscopables = Symbol.unscopables;
-
-// For the future
-
-// export const SYM_DISPOSE = Symbol.dispose;
-// export const SYM_ASYNC_DISPOSE = Symbol.asyncDispose;

src/core/tree/index.ts

-import {
-  createAsyncParserContext,
-  parseTopAsync,
-} from '../context/async-parser';
-import {
-  createVanillaDeserializerContext,
-  deserializeTop,
-} from '../context/deserializer';
-import type { BaseParserContextOptions } from '../context/parser';
-import {
-  createVanillaSerializerContext,
-  serializeTopVanilla,
-} from '../context/serializer';
-import { createSyncParserContext, parseTop } from '../context/sync-parser';
-import {
-  type PluginAccessOptions,
-  resolvePlugins,
-  SerovalMode,
-} from '../plugin';
-import type { SerovalNode } from '../types';
-import { ALL_ENABLED } from '../compat';
-export type SyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
-export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
-
-export function serialize<T>(
-  source: T,
-  options: SyncParserContextOptions = {},
-): string {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createSyncParserContext(SerovalMode.Vanilla, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-  });
-  const tree = parseTop(ctx, source);
-  const serial = createVanillaSerializerContext({
-    plugins,
-    features: ctx.base.features,
-    markedRefs: ctx.base.marked,
-  });
-  return serializeTopVanilla(serial, tree);
-}
-
-export async function serializeAsync<T>(
-  source: T,
-  options: AsyncParserContextOptions = {},
-): Promise<string> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createAsyncParserContext(SerovalMode.Vanilla, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-  });
-  const tree = await parseTopAsync(ctx, source);
-  const serial = createVanillaSerializerContext({
-    plugins,
-    features: ctx.base.features,
-    markedRefs: ctx.base.marked,
-  });
-  return serializeTopVanilla(serial, tree);
-}
-
-export function deserialize<T>(source: string): T {
-  return (0, eval)(source) as T;
-}
-
-export interface SerovalJSON {
-  t: SerovalNode;
-  f: number;
-  m: number[];
-}
-
-export interface FromJSONOptions extends PluginAccessOptions {
-  disabledFeatures?: number;
-}
-
-export function toJSON<T>(
-  source: T,
-  options: SyncParserContextOptions = {},
-): SerovalJSON {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createSyncParserContext(SerovalMode.Vanilla, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-  });
-  return {
-    t: parseTop(ctx, source),
-    f: ctx.base.features,
-    m: Array.from(ctx.base.marked),
-  };
-}
-
-export async function toJSONAsync<T>(
-  source: T,
-  options: AsyncParserContextOptions = {},
-): Promise<SerovalJSON> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createAsyncParserContext(SerovalMode.Vanilla, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-  });
-  return {
-    t: await parseTopAsync(ctx, source),
-    f: ctx.base.features,
-    m: Array.from(ctx.base.marked),
-  };
-}
-
-export function compileJSON(
-  source: SerovalJSON,
-  options: PluginAccessOptions = {},
-): string {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createVanillaSerializerContext({
-    plugins,
-    features: source.f,
-    markedRefs: source.m,
-  });
-  return serializeTopVanilla(ctx, source.t);
-}
-
-export function fromJSON<T>(
-  source: SerovalJSON,
-  options: FromJSONOptions = {},
-): T {
-  const plugins = resolvePlugins(options.plugins);
-  const disabledFeatures = options.disabledFeatures || 0;
-  const sourceFeatures = source.f ?? ALL_ENABLED;
-  const ctx = createVanillaDeserializerContext({
-    plugins,
-    markedRefs: source.m,
-    features: sourceFeatures & ~disabledFeatures,
-    disabledFeatures,
-  });
-  return deserializeTop(ctx, source.t) as T;
-}

src/core/types.ts

-import type {
-  ErrorConstructorTag,
-  SerovalConstant,
-  SerovalNodeType,
-  SerovalObjectFlags,
-  Symbols,
-} from './constants';
-import type { SpecialReference } from './special-reference';
-
-export interface SerovalBaseNode {
-  // Type of the node
-  t: SerovalNodeType;
-  // Reference ID
-  i: number | undefined;
-  // Serialized value
-  s: unknown;
-  // Constructor name / RegExp source
-  c: string | undefined;
-  // message/flags
-  m: string | undefined;
-  // properties (objects)
-  p: SerovalObjectRecordNode | undefined;
-  // entries (for Map, etc.)
-  e: SerovalMapRecordNode | undefined;
-  // array of nodes
-  a: (SerovalNode | 0)[] | undefined;
-  // fulfilled node
-  f: SerovalNode | undefined;
-  // byte offset/object flags
-  b: number | undefined;
-  // object flag
-  o: SerovalObjectFlags | undefined;
-  // length
-  l: number | undefined;
-}
-
-export type SerovalObjectRecordKey = string | SerovalNode;
-
-export interface SerovalObjectRecordNode {
-  k: SerovalObjectRecordKey[];
-  v: SerovalNode[];
-}
-
-export interface SerovalMapRecordNode {
-  k: SerovalNode[];
-  v: SerovalNode[];
-}
-
-export interface SerovalNumberNode extends SerovalBaseNode {
-  t: SerovalNodeType.Number;
-  s: number;
-}
-
-export interface SerovalStringNode extends SerovalBaseNode {
-  t: SerovalNodeType.String;
-  s: string;
-}
-
-export interface SerovalConstantNode extends SerovalBaseNode {
-  t: SerovalNodeType.Constant;
-  s: SerovalConstant;
-}
-
-export type SerovalPrimitiveNode =
-  | SerovalNumberNode
-  | SerovalStringNode
-  | SerovalConstantNode;
-
-export interface SerovalIndexedValueNode extends SerovalBaseNode {
-  t: SerovalNodeType.IndexedValue;
-  // id
-  i: number;
-}
-
-export interface SerovalBigIntNode extends SerovalBaseNode {
-  t: SerovalNodeType.BigInt;
-  // value in string
-  s: string;
-}
-
-export interface SerovalDateNode extends SerovalBaseNode {
-  t: SerovalNodeType.Date;
-  // id (Dates are stateful)
-  i: number;
-  // value in ISO string
-  s: string;
-}
-
-export interface SerovalRegExpNode extends SerovalBaseNode {
-  t: SerovalNodeType.RegExp;
-  // id (RegExp are stateful)
-  i: number;
-  // source
-  c: string;
-  // flags
-  m: string;
-}
-
-export interface SerovalArrayBufferNode extends SerovalBaseNode {
-  t: SerovalNodeType.ArrayBuffer;
-  // id
-  i: number;
-  // byte string
-  s: string;
-  // array buffer constructor
-  f: SerovalNodeWithID;
-}
-
-export interface SerovalTypedArrayNode extends SerovalBaseNode {
-  t: SerovalNodeType.TypedArray;
-  // id
-  i: number;
-  // TypedArray Constructor
-  c: string;
-  // ArrayBuffer reference
-  f: SerovalNode;
-  // Byte Offset
-  b: number;
-  // length
-  l: number;
-}
-
-export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
-  t: SerovalNodeType.BigIntTypedArray;
-  i: number;
-  // TypedArray Constructor
-  c: string;
-  // ArrayBuffer reference
-  f: SerovalNode;
-  // Byte Offset
-  b: number;
-  // length
-  l: number;
-}
-
-export type SerovalSemiPrimitiveNode =
-  | SerovalBigIntNode
-  | SerovalDateNode
-  | SerovalRegExpNode
-  | SerovalTypedArrayNode
-  | SerovalBigIntTypedArrayNode;
-
-export interface SerovalSetNode extends SerovalBaseNode {
-  t: SerovalNodeType.Set;
-  // id
-  i: number;
-  // Items in Set (as array)
-  a: SerovalNode[];
-}
-
-export interface SerovalMapNode extends SerovalBaseNode {
-  t: SerovalNodeType.Map;
-  i: number;
-  // key/value pairs
-  e: SerovalMapRecordNode;
-  f: SerovalNodeWithID;
-}
-
-export interface SerovalArrayNode extends SerovalBaseNode {
-  t: SerovalNodeType.Array;
-  // items
-  a: (SerovalNode | 0)[];
-  i: number;
-  o: SerovalObjectFlags;
-}
-
-export interface SerovalObjectNode extends SerovalBaseNode {
-  t: SerovalNodeType.Object;
-  // key/value pairs
-  p: SerovalObjectRecordNode;
-  i: number;
-  o: SerovalObjectFlags;
-}
-
-export interface SerovalNullConstructorNode extends SerovalBaseNode {
-  t: SerovalNodeType.NullConstructor;
-  // key/value pairs
-  p: SerovalObjectRecordNode;
-  i: number;
-  o: SerovalObjectFlags;
-}
-
-export interface SerovalPromiseNode extends SerovalBaseNode {
-  t: SerovalNodeType.Promise;
-  s: 0 | 1;
-  // resolved value
-  f: SerovalNode;
-  i: number;
-}
-
-export interface SerovalErrorNode extends SerovalBaseNode {
-  t: SerovalNodeType.Error;
-  // constructor name
-  s: ErrorConstructorTag;
-  // message
-  m: string;
-  // other properties
-  p: SerovalObjectRecordNode | undefined;
-  i: number;
-}
-
-export interface SerovalAggregateErrorNode extends SerovalBaseNode {
-  t: SerovalNodeType.AggregateError;
-  i: number;
-  // message
-  m: string;
-  // other properties
-  p: SerovalObjectRecordNode | undefined;
-}
-
-export interface SerovalWKSymbolNode extends SerovalBaseNode {
-  t: SerovalNodeType.WKSymbol;
-  i: number;
-  s: Symbols;
-}
-
-export interface SerovalReferenceNode extends SerovalBaseNode {
-  t: SerovalNodeType.Reference;
-  i: number;
-  // id of the reference in the map
-  s: string;
-}
-
-export interface SerovalDataViewNode extends SerovalBaseNode {
-  t: SerovalNodeType.DataView;
-  i: number;
-  // reference to array buffer
-  f: SerovalNode;
-  // byte offset
-  b: number;
-  // byte length
-  l: number;
-}
-
-export interface SerovalBoxedNode extends SerovalBaseNode {
-  t: SerovalNodeType.Boxed;
-  i: number;
-  f: SerovalNode;
-}
-
-export interface SerovalPromiseConstructorNode extends SerovalBaseNode {
-  t: SerovalNodeType.PromiseConstructor;
-  i: number;
-  s: number;
-  f: SerovalNodeWithID;
-}
-
-export interface SerovalPromiseResolveNode extends SerovalBaseNode {
-  t: SerovalNodeType.PromiseSuccess;
-  i: number;
-  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
-}
-
-export interface SerovalPromiseRejectNode extends SerovalBaseNode {
-  t: SerovalNodeType.PromiseFailure;
-  i: number;
-  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
-}
-
-export interface SerovalPluginNode extends SerovalBaseNode {
-  t: SerovalNodeType.Plugin;
-  i: number;
-  // value
-  s: Record<string, SerovalNode>;
-  // tag name
-  c: string;
-}
-
-/**
- * Represents special values as placeholders
- */
-export interface SerovalSpecialReferenceNode extends SerovalBaseNode {
-  t: SerovalNodeType.SpecialReference;
-  i: number;
-  s: SpecialReference;
-}
-
-export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
-  t: SerovalNodeType.IteratorFactory;
-  i: number;
-  f: SerovalNodeWithID;
-}
-
-export interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
-  t: SerovalNodeType.IteratorFactoryInstance;
-  a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
-}
-
-export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
-  t: SerovalNodeType.AsyncIteratorFactory;
-  i: number;
-  a: [promise: SerovalNodeWithID, symbol: SerovalNodeWithID];
-}
-
-export interface SerovalAsyncIteratorFactoryInstanceNode
-  extends SerovalBaseNode {
-  t: SerovalNodeType.AsyncIteratorFactoryInstance;
-  a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
-}
-
-export interface SerovalStreamConstructorNode extends SerovalBaseNode {
-  t: SerovalNodeType.StreamConstructor;
-  i: number;
-  a: SerovalNode[];
-  // special reference to the constructor
-  f: SerovalNodeWithID;
-}
-
-export interface SerovalStreamNextNode extends SerovalBaseNode {
-  t: SerovalNodeType.StreamNext;
-  i: number;
-  // Next value
-  f: SerovalNode;
-}
-
-export interface SerovalStreamThrowNode extends SerovalBaseNode {
-  t: SerovalNodeType.StreamThrow;
-  i: number;
-  // Throw value
-  f: SerovalNode;
-}
-
-export interface SerovalStreamReturnNode extends SerovalBaseNode {
-  t: SerovalNodeType.StreamReturn;
-  i: number;
-  // Return value
-  f: SerovalNode;
-}
-
-export interface SerovalSequenceNode extends SerovalBaseNode {
-  t: SerovalNodeType.Sequence;
-  i: number;
-  // Throw at
-  s: number;
-  a: SerovalNode[];
-  // Done at
-  l: number;
-}
-
-export type SerovalSyncNode =
-  | SerovalPrimitiveNode
-  | SerovalIndexedValueNode
-  | SerovalSemiPrimitiveNode
-  | SerovalSetNode
-  | SerovalMapNode
-  | SerovalArrayNode
-  | SerovalObjectNode
-  | SerovalNullConstructorNode
-  | SerovalPromiseNode
-  | SerovalErrorNode
-  | SerovalAggregateErrorNode
-  | SerovalWKSymbolNode
-  | SerovalReferenceNode
-  | SerovalArrayBufferNode
-  | SerovalDataViewNode
-  | SerovalBoxedNode
-  | SerovalPluginNode
-  | SerovalSpecialReferenceNode
-  | SerovalIteratorFactoryNode
-  | SerovalIteratorFactoryInstanceNode
-  | SerovalAsyncIteratorFactoryNode
-  | SerovalAsyncIteratorFactoryInstanceNode
-  | SerovalSequenceNode;
-
-export type SerovalAsyncNode =
-  | SerovalPromiseNode
-  | SerovalPromiseConstructorNode
-  | SerovalPromiseResolveNode
-  | SerovalPromiseRejectNode
-  | SerovalStreamConstructorNode
-  | SerovalStreamNextNode
-  | SerovalStreamThrowNode
-  | SerovalStreamReturnNode;
-
-export type SerovalNode = SerovalSyncNode | SerovalAsyncNode;
-
-export type SerovalNodeWithID = Extract<SerovalNode, { i: number }>;

src/core/utils/error.ts

-import { Feature } from '../compat';
-import { ERROR_CONSTRUCTOR_STRING, ErrorConstructorTag } from '../constants';
-
-type ErrorValue =
-  | Error
-  | AggregateError
-  | EvalError
-  | RangeError
-  | ReferenceError
-  | TypeError
-  | SyntaxError
-  | URIError;
-
-export function getErrorConstructor(error: ErrorValue): ErrorConstructorTag {
-  if (error instanceof EvalError) {
-    return ErrorConstructorTag.EvalError;
-  }
-  if (error instanceof RangeError) {
-    return ErrorConstructorTag.RangeError;
-  }
-  if (error instanceof ReferenceError) {
-    return ErrorConstructorTag.ReferenceError;
-  }
-  if (error instanceof SyntaxError) {
-    return ErrorConstructorTag.SyntaxError;
-  }
-  if (error instanceof TypeError) {
-    return ErrorConstructorTag.TypeError;
-  }
-  if (error instanceof URIError) {
-    return ErrorConstructorTag.URIError;
-  }
-  return ErrorConstructorTag.Error;
-}
-
-function getInitialErrorOptions(
-  error: Error,
-): Record<string, unknown> | undefined {
-  const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
-  // Name has been modified
-  if (error.name !== construct) {
-    return { name: error.name };
-  }
-  if (error.constructor.name !== construct) {
-    // Otherwise, name is overriden because
-    // the Error class is extended
-    return { name: error.constructor.name };
-  }
-  return {};
-}
-
-export function getErrorOptions(
-  error: Error,
-  features: number,
-): Record<string, unknown> | undefined {
-  let options = getInitialErrorOptions(error);
-  const names = Object.getOwnPropertyNames(error);
-  for (let i = 0, len = names.length, name: string; i < len; i++) {
-    name = names[i];
-    if (name !== 'name' && name !== 'message') {
-      if (name === 'stack') {
-        if (features & Feature.ErrorPrototypeStack) {
-          options = options || {};
-          options[name] = error[name as keyof Error];
-        }
-      } else {
-        options = options || {};
-        options[name] = error[name as keyof Error];
-      }
-    }
-  }
-  return options;
-}

src/core/utils/get-identifier.ts

-// Written by https://github.com/DylanPiercey and is distributed under the MIT license.
-const REF_START_CHARS = /* @__PURE__ */ 'hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_'; // Avoids chars that could evaluate to a reserved word.
-const REF_START_CHARS_LEN = /* @__PURE__ */ REF_START_CHARS.length;
-const REF_CHARS =
-  /* @__PURE__ */ 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_';
-const REF_CHARS_LEN = /* @__PURE__ */ REF_CHARS.length;
-
-export default function getIdentifier(index: number): string {
-  let mod = index % REF_START_CHARS_LEN;
-  let ref = REF_START_CHARS[mod];
-  index = (index - mod) / REF_START_CHARS_LEN;
-  while (index > 0) {
-    mod = index % REF_CHARS_LEN;
-    ref += REF_CHARS[mod];
-    index = (index - mod) / REF_CHARS_LEN;
-  }
-  return ref;
-}

src/core/utils/get-object-flag.ts

-import { SerovalObjectFlags } from '../constants';
-
-export function getObjectFlag(obj: unknown): SerovalObjectFlags {
-  if (Object.isFrozen(obj)) {
-    return SerovalObjectFlags.Frozen;
-  }
-  if (Object.isSealed(obj)) {
-    return SerovalObjectFlags.Sealed;
-  }
-  if (Object.isExtensible(obj)) {
-    return SerovalObjectFlags.None;
-  }
-  return SerovalObjectFlags.NonExtensible;
-}

src/core/utils/is-valid-identifier.ts

-const IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;
-
-export function isValidIdentifier(name: string): boolean {
-  const char = name[0];
-  return (
-    (char === '$' ||
-      char === '_' ||
-      (char >= 'A' && char <= 'Z') ||
-      (char >= 'a' && char <= 'z')) &&
-    IDENTIFIER_CHECK.test(name)
-  );
-}

src/core/utils/promise-to-result.ts

-export default async function promiseToResult(
-  current: Promise<unknown>,
-): Promise<[0 | 1, unknown]> {
-  try {
-    return [1, await current];
-  } catch (e) {
-    return [0, e];
-  }
-}

src/core/utils/typed-array.ts

-import { SerovalUnknownTypedArrayError } from '../errors';
-
-type TypedArrayConstructor =
-  | Int8ArrayConstructor
-  | Int16ArrayConstructor
-  | Int32ArrayConstructor
-  | Uint8ArrayConstructor
-  | Uint16ArrayConstructor
-  | Uint32ArrayConstructor
-  | Uint8ClampedArrayConstructor
-  | Float32ArrayConstructor
-  | Float64ArrayConstructor
-  | BigInt64ArrayConstructor
-  | BigUint64ArrayConstructor;
-
-export type TypedArrayValue =
-  | Int8Array
-  | Int16Array
-  | Int32Array
-  | Uint8Array
-  | Uint16Array
-  | Uint32Array
-  | Uint8ClampedArray
-  | Float32Array
-  | Float64Array;
-
-export type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;
-
-export function getTypedArrayConstructor(name: string): TypedArrayConstructor {
-  switch (name) {
-    case 'Int8Array':
-      return Int8Array;
-    case 'Int16Array':
-      return Int16Array;
-    case 'Int32Array':
-      return Int32Array;
-    case 'Uint8Array':
-      return Uint8Array;
-    case 'Uint16Array':
-      return Uint16Array;
-    case 'Uint32Array':
-      return Uint32Array;
-    case 'Uint8ClampedArray':
-      return Uint8ClampedArray;
-    case 'Float32Array':
-      return Float32Array;
-    case 'Float64Array':
-      return Float64Array;
-    case 'BigInt64Array':
-      return BigInt64Array;
-    case 'BigUint64Array':
-      return BigUint64Array;
-    default:
-      throw new SerovalUnknownTypedArrayError(name);
-  }
-}

src/core/utils/valid-properties.ts

-import {
-  SYM_ASYNC_ITERATOR,
-  SYM_IS_CONCAT_SPREADABLE,
-  SYM_ITERATOR,
-  SYM_TO_STRING_TAG,
-} from '../symbols';
-
-export function isValidKey(key: string): boolean {
-  switch (key) {
-    case 'constructor':
-    case '__proto__':
-    case 'prototype':
-    case '__defineGetter__':
-    case '__defineSetter__':
-    case '__lookupGetter__':
-    case '__lookupSetter__':
-      // case 'then':
-      return false;
-    default:
-      return true;
-  }
-}
-
-export function isValidSymbol(symbol: symbol): boolean {
-  switch (symbol) {
-    case SYM_ASYNC_ITERATOR:
-    case SYM_IS_CONCAT_SPREADABLE:
-    case SYM_TO_STRING_TAG:
-    case SYM_ITERATOR:
-      return true;
-    default:
-      return false;
-  }
-}

src/index.ts

-export { Feature } from './core/compat';
-export type {
-  AsyncParsePluginContext,
-  AsyncParserContextOptions,
-} from './core/context/async-parser';
-export type {
-  BaseDeserializerContextOptions,
-  CrossDeserializerContextOptions,
-  DeserializePluginContext,
-  VanillaDeserializerContextOptions,
-} from './core/context/deserializer';
-export type { BaseParserContextOptions } from './core/context/parser';
-export type {
-  BaseSerializerContextOptions,
-  CrossContextOptions,
-  CrossSerializerContextOptions,
-  SerializePluginContext,
-  VanillaSerializerContextOptions,
-} from './core/context/serializer';
-export type {
-  StreamParsePluginContext,
-  StreamParserContextOptions,
-  SyncParsePluginContext,
-  SyncParserContextOptions,
-} from './core/context/sync-parser';
-export * from './core/cross';
-export * from './core/errors';
-export { getCrossReferenceHeader } from './core/keys';
-export { OpaqueReference } from './core/opaque-reference';
-export * from './core/plugin';
-export { createReference } from './core/reference';
-export { default as Serializer } from './core/Serializer';
-export { createStream } from './core/stream';
-export type { Stream, StreamListener } from './core/stream';
-export * from './core/tree';
-export type { SerovalNode } from './core/types';

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Fixed alerts

Potential vulnerability

Supply chain risk

Initial human review suggests the presence of a vulnerability in this package. It is pending further analysis and confirmation.

Found 3 instances

AI-detected potential code anomaly

Supply chain risk

AI has identified unusual behaviors that may pose a security risk.

Minified code

Quality

This package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.

Improved metrics

Number of low quality alerts

0

-100%

Number of low supply chain risk alerts

1

-50%

Number of medium supply chain risk alerts

1

-66.67%

Worsened metrics

Total package byte prevSize

127587

-88.22%

Dev dependency count

9

28.57%

Number of package files

5

-95.5%

Lines of code

3687

-77.46%

No dependency changes