seroval 0.12.4 → 0.13.0

package/src/core/cross/index.ts

@@ -1,7 +1,10 @@
+import type { SerovalNode } from '../types';
 import type { CrossAsyncParserContextOptions } from './async';
 import AsyncCrossParserContext from './async';
-import type { CrossContextOptions } from './cross-parser';
-import CrossSerializerContext from './serialize';
+import type { CrossDeserializerContextOptions } from './deserializer';
+import CrossDeserializerContext from './deserializer';
+import type { CrossContextOptions, CrossParserContextOptions } from './parser';
+import CrossSerializerContext from './serializer';
 import type { CrossStreamParserContextOptions } from './stream';
 import StreamCrossParserContext from './stream';
 import type { CrossSyncParserContextOptions } from './sync';
@@ -53,51 +56,33 @@ export async function crossSerializeAsync<T>(
   return serial.serializeTop(tree);
 }
 
-// export interface SerovalCrossJSON {
-//   t: SerovalNode;
-//   f: number;
-// }
-
-// export function toCrossJSON<T>(
-//   source: T,
-//   options?: CrossParserContextOptions,
-// ): SerovalCrossJSON {
-//   const ctx = createCrossParserContext(options);
-//   return {
-//     t: parseSync(ctx, source),
-//     f: ctx.features,
-//   };
-// }
-
-// export async function toCrossJSONAsync<T>(
-//   source: T,
-//   options?: CrossParserContextOptions,
-// ): Promise<SerovalCrossJSON> {
-//   const ctx = createCrossParserContext(options);
-//   return {
-//     t: await parseAsync(ctx, source),
-//     f: ctx.features,
-//   };
-// }
-
-// export function compileCrossJSON(source: SerovalCrossJSON): string {
-//   const serial = createCrossSerializerContext({
-//     features: source.f,
-//   });
-//   const result = crossSerializeTree(serial, source.t);
-//   return finalize(
-//     serial,
-//     source.t.i,
-//     result,
-//   );
-// }
-
-// export function fromJSON<T>(source: SerovalJSON): T {
-//   const serial = createDeserializerContext({
-//     markedRefs: source.m,
-//   });
-//   return deserializeTree(serial, source.t) as T;
-// }
+export type ToCrossJSONOptions = CrossParserContextOptions;
+
+export function toCrossJSON<T>(
+  source: T,
+  options: CrossParserContextOptions = {},
+): SerovalNode {
+  const ctx = new SyncCrossParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs,
+  });
+  return ctx.parse(source);
+}
+
+export type ToCrossJSONAsyncOptions = CrossParserContextOptions;
+
+export async function toCrossJSONAsync<T>(
+  source: T,
+  options: CrossParserContextOptions = {},
+): Promise<SerovalNode> {
+  const ctx = new AsyncCrossParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs,
+  });
+  return ctx.parse(source);
+}
 
 export interface CrossSerializeStreamOptions
   extends Omit<CrossStreamParserContextOptions, 'onParse'>, CrossContextOptions {
@@ -109,6 +94,7 @@ export function crossSerializeStream<T>(
   options: CrossSerializeStreamOptions,
 ): () => void {
   const ctx = new StreamCrossParserContext({
+    plugins: options.plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
     onParse(node, initial): void {
@@ -145,3 +131,38 @@ export function crossSerializeStream<T>(
     ctx.destroy();
   };
 }
+
+export type ToCrossJSONStreamOptions = CrossStreamParserContextOptions;
+
+export function toCrossJSONStream<T>(
+  source: T,
+  options: ToCrossJSONStreamOptions,
+): () => void {
+  const ctx = new StreamCrossParserContext({
+    plugins: options.plugins,
+    refs: options.refs,
+    disabledFeatures: options.disabledFeatures,
+    onParse: options.onParse,
+    onError: options.onError,
+    onDone: options.onDone,
+  });
+
+  ctx.start(source);
+
+  return () => {
+    ctx.destroy();
+  };
+}
+
+export type FromCrossJSONOptions = CrossDeserializerContextOptions;
+
+export function fromCrossJSON<T>(
+  source: SerovalNode,
+  options: FromCrossJSONOptions,
+): T {
+  const ctx = new CrossDeserializerContext({
+    plugins: options.plugins,
+    refs: options.refs,
+  });
+  return ctx.deserialize(source) as T;
+}

package/src/core/cross/parser.ts

@@ -0,0 +1,7 @@
+import type { BaseParserContextOptions } from '../context/parser';
+
+export type CrossParserContextOptions = BaseParserContextOptions
+
+export interface CrossContextOptions {
+  scopeId?: string;
+}

package/src/core/cross/{serialize.ts → serializer.ts}

@@ -7,6 +7,7 @@ import type {
   SerovalReadableStreamErrorNode,
   SerovalReadableStreamConstructorNode,
   SerovalNode,
+  SerovalAsyncIteratorFactoryNode,
 } from '../types';
 import {
   GLOBAL_CONTEXT_PROMISE_REJECT,
@@ -14,15 +15,16 @@ import {
   GLOBAL_CONTEXT_PROMISE_CONSTRUCTOR,
   GLOBAL_CONTEXT_REFERENCES,
   GLOBAL_CONTEXT_STREAM_CONSTRUCTOR,
-  GLOBAL_CONTEXT_STREAM_EMIT,
+  GLOBAL_CONTEXT_STREAM_ENQUEUE,
+  GLOBAL_CONTEXT_STREAM_CLOSE,
+  GLOBAL_CONTEXT_STREAM_ERROR,
   GLOBAL_CONTEXT_API,
 } from '../keys';
-import type { BaseSerializerContextOptions } from '../serializer-context.old';
-import BaseSerializerContext from '../serializer-context.old';
+import type { BaseSerializerContextOptions } from '../context/serializer';
+import BaseSerializerContext from '../context/serializer';
 import type { SerovalMode } from '../plugin';
-import { Feature } from '../compat';
 import { serializeString } from '../string';
-import type { CrossContextOptions } from './cross-parser';
+import type { CrossContextOptions } from './parser';
 
 export interface CrossSerializerContextOptions
   extends BaseSerializerContextOptions, CrossContextOptions {
@@ -79,19 +81,39 @@ export default class CrossSerializerContext extends BaseSerializerContext {
   protected serializeReadableStreamEnqueue(
     node: SerovalReadableStreamEnqueueNode,
   ): string {
-    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_EMIT + '(' + this.getRefParam(node.i) + ',0,' + this.serialize(node.f) + ')';
+    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_ENQUEUE + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.f) + ')';
   }
 
   protected serializeReadableStreamError(
     node: SerovalReadableStreamErrorNode,
   ): string {
-    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_EMIT + '(' + this.getRefParam(node.i) + ',1,' + this.serialize(node.f) + ')';
+    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_ERROR + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.f) + ')';
   }
 
   protected serializeReadableStreamClose(
     node: SerovalReadableStreamCloseNode,
   ): string {
-    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_EMIT + '(' + this.getRefParam(node.i) + ',2)';
+    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_CLOSE + '(' + this.getRefParam(node.i) + ')';
+  }
+
+  protected serializeAsyncIteratorFactory(node: SerovalAsyncIteratorFactoryNode): string {
+    return this.assignIndexedValue(
+      node.i,
+      this.createFunction(
+        ['s'],
+        this.createFunction(
+          ['b', 't'],
+          '(b=s.tee(),s=b[0],b=b[1].getReader(),t={[' + this.serialize(node.f) + ']:' + this.createFunction([], 't') + ','
+          + 'next:' + this.createFunction(
+            [],
+            'b.read().then(' + this.createEffectfulFunction(
+              ['d'],
+              'if(d.done)return{done:!0,value:void 0};d=d.value;if(d[0]===1)throw d[1];return{done:d[0]===2,value:d[1]}',
+            ) + ')',
+          ) + '})',
+        ),
+      ),
+    );
   }
 
   serializeTop(tree: SerovalNode): string {
@@ -109,9 +131,6 @@ export default class CrossSerializerContext extends BaseSerializerContext {
     }
     const args = this.scopeId == null ? '()' : '(' + GLOBAL_CONTEXT_REFERENCES + '["' + serializeString(this.scopeId) + '"])';
     const body = mainBody + (patches ? ref : '');
-    if (this.features & Feature.ArrowFunction) {
-      return '(' + params + '=>(' + body + '))' + args;
-    }
-    return '(function(' + params + '){return ' + body + '})' + args;
+    return '(' + this.createFunction([params], body) + ')' + args;
   }
 }

package/src/core/cross/stream.ts

@@ -1,5 +1,5 @@
-import type { BaseStreamParserContextOptions } from '../base/stream';
-import BaseStreamParserContext from '../base/stream';
+import type { BaseStreamParserContextOptions } from '../context/parser/stream';
+import BaseStreamParserContext from '../context/parser/stream';
 import type { SerovalMode } from '../plugin';
 
 export type CrossStreamParserContextOptions = BaseStreamParserContextOptions

package/src/core/cross/sync.ts

@@ -1,6 +1,6 @@
-import BaseSyncParserContext from '../base/sync';
+import BaseSyncParserContext from '../context/parser/sync';
 import type { SerovalMode } from '../plugin';
-import type { CrossParserContextOptions } from './cross-parser';
+import type { CrossParserContextOptions } from './parser';
 
 export type CrossSyncParserContextOptions = CrossParserContextOptions
 

package/src/core/is-serializable.new.ts

@@ -2,7 +2,7 @@ import { ALL_ENABLED, BIGINT_FLAG, Feature } from './compat';
 import { INV_SYMBOL_REF, UNIVERSAL_SENTINEL } from './constants';
 import type { Plugin, PluginAccessOptions } from './plugin';
 import { hasReferenceID } from './reference';
-import { getErrorOptions } from './shared';
+import { getErrorOptions } from './utils/error';
 
 export type SerializationMode = 'sync' | 'async' | 'stream';
 

package/src/core/keys.ts

@@ -21,7 +21,11 @@ export const LOCAL_CONTEXT_STREAM_CONTROLLER = 'c';
 
 export const GLOBAL_CONTEXT_STREAM_CONSTRUCTOR = 'S';
 
-export const GLOBAL_CONTEXT_STREAM_EMIT = 'Se';
+export const GLOBAL_CONTEXT_STREAM_ENQUEUE = 'Se';
+
+export const GLOBAL_CONTEXT_STREAM_ERROR = 'St';
+
+export const GLOBAL_CONTEXT_STREAM_CLOSE = 'Sc';
 
 const GLOBAL_CONTEXT_API_REF = `self.${GLOBAL_CONTEXT_API}`;
 
@@ -31,7 +35,9 @@ export const GLOBAL_CONTEXT_API_SCRIPT = `${GLOBAL_CONTEXT_API_REF}=${GLOBAL_CON
   + `${GLOBAL_CONTEXT_PROMISE_RESOLVE}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_RESOLVE}(d),p.status="success",p.value=d,this.uP(p)},`
   + `${GLOBAL_CONTEXT_PROMISE_REJECT}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_REJECT}(d),p.status="failure",p.value=d,this.uP(p)},`
   + `uS:function(s){delete s.${LOCAL_CONTEXT_STREAM_CONTROLLER}},`
-  + `${GLOBAL_CONTEXT_STREAM_EMIT}:function(s,t,d,c){switch(c=s.${LOCAL_CONTEXT_STREAM_CONTROLLER},t){case 0:return c.enqueue(d);case 1:return(this.uS(s),c.error(d));case 2:return(this.uS(s),c.close())}},`
+  + `${GLOBAL_CONTEXT_STREAM_CLOSE}:function(s){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.close(),this.uS(s)},`
+  + `${GLOBAL_CONTEXT_STREAM_ERROR}:function(s,e){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.error(e),this.uS(s)},`
+  + `${GLOBAL_CONTEXT_STREAM_ENQUEUE}:function(s,d){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.enqueue(d)},`
   + `${GLOBAL_CONTEXT_STREAM_CONSTRUCTOR}:function(s,c){return(s=new ReadableStream({start:function(x){c=x}})).${LOCAL_CONTEXT_STREAM_CONTROLLER}=c,s}`
   + '}';
 

package/src/core/plugin.ts

@@ -1,8 +1,8 @@
-import type BaseAsyncParserContext from './base/async';
-import type BaseStreamParserContext from './base/stream';
-import type BaseSyncParserContext from './base/sync';
-import type BaseSerializerContext from './serializer-context.old';
-import type VanillaDeserializerContext from './tree/deserialize';
+import type BaseAsyncParserContext from './context/parser/async';
+import type BaseStreamParserContext from './context/parser/stream';
+import type BaseSyncParserContext from './context/parser/sync';
+import type BaseSerializerContext from './context/serializer';
+import type BaseDeserializerContext from './context/deserializer';
 
 export type SerovalMode = 'vanilla' | 'cross';
 
@@ -37,10 +37,10 @@ export interface Plugin<Value, Node> {
   ): string;
   deserialize(
     node: Node,
-    ctx: VanillaDeserializerContext,
+    ctx: BaseDeserializerContext,
     data: PluginData,
   ): Value;
-  isIterable?: (value: Value) => boolean;
+  // isIterable?: (value: Value) => boolean;
   // isSerializable?: (value: Value) => boolean;
 }
 

package/src/core/reference.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-restricted-globals */
-import assert from './assert';
+import assert from './utils/assert';
 import { REFERENCES_KEY } from './keys';
 
 const REFERENCE = new Map<unknown, string>();

package/src/core/special-reference.ts

@@ -0,0 +1,9 @@
+export const MAP_SENTINEL = {};
+
+export const ITERATOR = {};
+
+export const ASYNC_ITERATOR = {};
+
+export const READABLE_STREAM = {};
+
+export const UNIVERSAL_SENTINEL = {};

package/src/core/tree/async.ts

@@ -1,5 +1,5 @@
-import BaseAsyncParserContext from '../base/async';
-import type { BaseParserContextOptions } from '../parser-context';
+import BaseAsyncParserContext from '../context/parser/async';
+import type { BaseParserContextOptions } from '../context/parser';
 import type { SerovalMode } from '../plugin';
 
 export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>

package/src/core/tree/deserializer.ts

@@ -0,0 +1,31 @@
+import BaseDeserializerContext from '../context/deserializer';
+import type { BaseDeserializerOptions } from '../context/deserializer';
+import type { SerovalMode } from '../plugin';
+
+export interface VanillaDeserializerContextOptions extends Omit<BaseDeserializerOptions, 'refs'> {
+  markedRefs: number[] | Set<number>;
+}
+
+export default class VanillaDeserializerContext extends BaseDeserializerContext {
+  readonly mode: SerovalMode = 'vanilla';
+
+  marked: Set<number>;
+
+  constructor(options: VanillaDeserializerContextOptions) {
+    super({
+      plugins: options.plugins,
+      refs: undefined,
+    });
+    this.marked = new Set(options.markedRefs);
+  }
+
+  assignIndexedValue<T>(
+    index: number,
+    value: T,
+  ): T {
+    if (this.marked.has(index)) {
+      this.refs.set(index, value);
+    }
+    return value;
+  }
+}

package/src/core/tree/index.ts

@@ -2,8 +2,8 @@ import type { PluginAccessOptions } from '../plugin';
 import type { SerovalNode } from '../types';
 import type { AsyncParserContextOptions } from './async';
 import AsyncParserContext from './async';
-import VanillaDeserializerContext from './deserialize';
-import VanillaSerializerContext from './serialize';
+import VanillaDeserializerContext from './deserializer';
+import VanillaSerializerContext from './serializer';
 import type { SyncParserContextOptions } from './sync';
 import SyncParserContext from './sync';
 

package/src/core/tree/{serialize.ts → serializer.ts}

@@ -8,11 +8,10 @@ import type {
   SerovalReadableStreamEnqueueNode,
   SerovalReadableStreamErrorNode,
 } from '../types';
-import type { BaseSerializerContextOptions } from '../serializer-context.old';
-import BaseSerializerContext from '../serializer-context.old';
-import getIdentifier from '../get-identifier';
+import type { BaseSerializerContextOptions } from '../context/serializer';
+import BaseSerializerContext from '../context/serializer';
+import getIdentifier from '../utils/get-identifier';
 import type { SerovalMode } from '../plugin';
-import { Feature } from '../compat';
 import { SerovalNodeType } from '../constants';
 
 export type VanillaSerializerContextOptions = BaseSerializerContextOptions
@@ -30,7 +29,7 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
    * Variables
    * @private
    */
-  vars: (string | undefined)[] = [];
+  vars: string[] = [];
 
   /**
    * Increments the number of references the referenced value has
@@ -131,17 +130,7 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
           body = index + '=' + body;
         }
       }
-      let params = this.vars.length > 1
-        ? this.vars.join(',')
-        : this.vars[0];
-      // Source is probably already assigned
-      if (this.features & Feature.ArrowFunction) {
-        params = this.vars.length > 1 || this.vars.length === 0
-          ? '(' + params + ')'
-          : params;
-        return '(' + params + '=>(' + body + '))()';
-      }
-      return '(function(' + params + '){return ' + body + '})()';
+      return '(' + this.createFunction(this.vars, '(' + body + ')') + ')()';
     }
     if (tree.t === SerovalNodeType.Object) {
       return '(' + result + ')';

package/src/core/tree/sync.ts

@@ -1,5 +1,5 @@
-import BaseSyncParserContext from '../base/sync';
-import type { BaseParserContextOptions } from '../parser-context';
+import BaseSyncParserContext from '../context/parser/sync';
+import type { BaseParserContextOptions } from '../context/parser';
 import type { SerovalMode } from '../plugin';
 
 export type SyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;

package/src/core/types.ts

@@ -33,13 +33,9 @@ export interface SerovalBaseNode {
   o: SerovalObjectFlags | undefined;
 }
 
-export const enum SerovalObjectRecordSpecialKey {
-  SymbolIterator = 0,
-}
-
 export type SerovalObjectRecordKey =
   | string
-  | SerovalObjectRecordSpecialKey;
+  | SerovalNode;
 
 export interface SerovalPlainRecordNode {
   k: string[];
@@ -166,6 +162,7 @@ export interface SerovalMapNode extends SerovalBaseNode {
   i: number;
   // key/value pairs
   e: SerovalMapRecordNode;
+  f: SerovalMapSentinelNode | SerovalIndexedValueNode;
 }
 
 export interface SerovalArrayNode extends SerovalBaseNode {
@@ -392,6 +389,53 @@ export interface SerovalPluginNode extends SerovalBaseNode {
   c: string;
 }
 
+export interface SerovalMapSentinelNode extends SerovalBaseNode {
+  t: SerovalNodeType.MapSentinel;
+  i: number;
+}
+
+export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.IteratorFactory;
+  i: number;
+  f: SerovalNode;
+}
+
+export interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
+  t: SerovalNodeType.IteratorFactoryInstance;
+  a: [
+    instance: SerovalNode,
+    sequence: SerovalNode,
+  ];
+}
+
+export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.AsyncIteratorFactory;
+  i: number;
+  f: SerovalNode;
+}
+
+export interface SerovalAsyncIteratorFactoryInstanceNode extends SerovalBaseNode {
+  t: SerovalNodeType.AsyncIteratorFactoryInstance;
+  a: [
+    instance: SerovalNode,
+    sequence: SerovalNode,
+  ];
+}
+
+export interface SerovalReadableStreamNode extends SerovalBaseNode {
+  t: SerovalNodeType.ReadableStream;
+  i: number;
+  a: [
+    instance: SerovalNode,
+    sequence: SerovalNode,
+  ];
+}
+
+export interface SerovalReadableStreamFactoryNode extends SerovalBaseNode {
+  t: SerovalNodeType.ReadableStreamFactory;
+  i: number;
+}
+
 export type SerovalSyncNode =
   | SerovalPrimitiveNode
   | SerovalIndexedValueNode
@@ -418,7 +462,12 @@ export type SerovalSyncNode =
   | SerovalEventNode
   | SerovalCustomEventNode
   | SerovalDOMExceptionNode
-  | SerovalPluginNode;
+  | SerovalPluginNode
+  | SerovalMapSentinelNode
+  | SerovalIteratorFactoryNode
+  | SerovalIteratorFactoryInstanceNode
+  | SerovalAsyncIteratorFactoryNode
+  | SerovalAsyncIteratorFactoryInstanceNode;
 
 export type SerovalAsyncNode =
   | SerovalPromiseNode
@@ -432,8 +481,12 @@ export type SerovalAsyncNode =
   | SerovalReadableStreamCloseNode
   | SerovalReadableStreamErrorNode
   | SerovalRequestNode
-  | SerovalResponseNode;
+  | SerovalResponseNode
+  | SerovalReadableStreamNode
+  | SerovalReadableStreamFactoryNode;
 
 export type SerovalNode =
   | SerovalSyncNode
   | SerovalAsyncNode;
+
+export type SerovalNodeWithID = Extract<SerovalNode, { i: number }>;

package/src/core/utils/deferred.ts

@@ -0,0 +1,49 @@
+export interface Deferred {
+  promise: Promise<unknown>;
+  resolve(value: unknown): void;
+  reject(value: unknown): void;
+}
+
+export function createDeferred(): Deferred {
+  let resolve: Deferred['resolve'];
+  let reject: Deferred['reject'];
+  return {
+    promise: new Promise<unknown>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    }),
+    resolve(value): void {
+      resolve(value);
+    },
+    reject(value): void {
+      reject(value);
+    },
+  };
+}
+
+export interface DeferredStream {
+  stream: ReadableStream;
+  close(): void;
+  enqueue(chunk?: unknown): void;
+  error(e?: any): void;
+}
+
+export function createDeferredStream(): DeferredStream {
+  let controller: ReadableStreamDefaultController;
+  return {
+    stream: new ReadableStream({
+      start(current): void {
+        controller = current;
+      },
+    }),
+    close(): void {
+      controller.close();
+    },
+    enqueue(data): void {
+      controller.enqueue(data);
+    },
+    error(e): void {
+      controller.error(e);
+    },
+  };
+}

package/src/core/{shared.ts → utils/error.ts}

@@ -1,12 +1,11 @@
 import type {
   ErrorValue,
-} from '../types';
-import { Feature } from './compat';
+} from '../../types';
+import { Feature } from '../compat';
 import {
   ERROR_CONSTRUCTOR_STRING,
   ErrorConstructorTag,
-  SerovalObjectFlags,
-} from './constants';
+} from '../constants';
 
 export function getErrorConstructor(error: ErrorValue): ErrorConstructorTag {
   if (error instanceof EvalError) {
@@ -30,62 +29,6 @@ export function getErrorConstructor(error: ErrorValue): ErrorConstructorTag {
   return ErrorConstructorTag.Error;
 }
 
-type TypedArrayConstructor =
-  | Int8ArrayConstructor
-  | Int16ArrayConstructor
-  | Int32ArrayConstructor
-  | Uint8ArrayConstructor
-  | Uint16ArrayConstructor
-  | Uint32ArrayConstructor
-  | Uint8ClampedArrayConstructor
-  | Float32ArrayConstructor
-  | Float64ArrayConstructor
-  | BigInt64ArrayConstructor
-  | BigUint64ArrayConstructor;
-
-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 Error(`Unknown TypedArray "${name}"`);
-  }
-}
-
-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);
-}
-
-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;
-}
-
 export function getErrorOptions(
   error: Error,
   features: number,