devalue

constructor

constructor(message: string, keys: string[], value?: any, root?: any);

• Parameter message

  Parameter keys

  Parameter value

  The value that failed to be serialized

  Parameter root

  The root value being serialized

property path

path: string;

property root

root: any;

property value

value: any;

method addEntry

addEntry: (map: Map<any, any>, key: any, value: any) => void;

method addValue

addValue: (set: Set<any>, value: any) => void;

method box

box: (value: any) => object;

method createArray

createArray: (length: number) => any[];

method createMap

createMap: () => Map<any, any>;

method createNullPrototypeObject

createNullPrototypeObject: () => Record<string, any>;

method createObject

createObject: () => Record<string, any>;

method createSet

createSet: () => Set<any>;

method createSparseArray

createSparseArray: (length: number) => any[];

method fromArrayBuffer

fromArrayBuffer: (buffer: ArrayBuffer) => ArrayBuffer;

method fromISOString

fromISOString: (iso: string) => Date;

method fromPrimitive

fromPrimitive: (
    primitive: string | number | boolean | bigint | null | undefined
) => string | number | boolean | bigint | null | undefined;

method fromRegExpInfo

fromRegExpInfo: (source: string, flags: string | undefined) => RegExp;

method fromStringValue

fromStringValue: (
    tag: StringValueTag,
    text: string
) => URL | URLSearchParams | object;

method fromViewInfo

fromViewInfo: (
    tag: ViewTag,
    buffer: ArrayBufferLike,
    byteOffset: number | undefined,
    length: number | undefined
) => TypedArray | DataView;

method entriesOf

entriesOf: (map: Map<any, any>) => Map<any, any>;

method identify

identify: (value: any) => any;

method indicesOf

indicesOf: (array: any[]) => string[];

method lengthOf

lengthOf: (array: any[]) => number;

method regExpInfo

regExpInfo: (regexp: RegExp) => { source: string; flags: string };

method toArrayBuffer

toArrayBuffer: (buffer: ArrayBuffer) => ArrayBuffer;

method toISOString

toISOString: (date: Date) => string;

method toPrimitive

toPrimitive: (
    value: undefined | null | boolean | number | bigint | string
) => undefined | null | boolean | number | bigint | string;

method valuesOf

valuesOf: (set: Set<any>) => Set<any>;

method viewInfo

viewInfo: (view: any) => {
    buffer: ArrayBufferLike;
    byteOffset: number;
    byteLength: number;
    length?: number;
    bufferByteLength: number;
};

call signature

(strings: TemplateStringsArray, ...values: unknown[]): JavaScriptFragment;

method addEntry

addEntry: (map: any, key: any, value: any) => void;

• Adds an entry to a Map created by createMap. The inverse of entriesOf.

method addValue

addValue: (set: any, value: any) => void;

• Adds a value to a Set created by createSet. The inverse of valuesOf.

method box

box: (value: any) => any;

• Creates a boxed primitive object (Number, String, Boolean, BigInt wrapper) around an already-revived inner primitive. The inverse of unbox. Equivalent to Object(value).

method createArray

createArray: (length: number) => any;

• Creates an array of the given length, to be populated with set. The length is bounded by the size of the input, so it is safe to allocate eagerly. Indices that are never set must remain holes.

method createMap

createMap: () => any;

• Creates an empty Map, to be populated with addEntry.

method createNullPrototypeObject

createNullPrototypeObject: () => any;

• Creates an empty null-prototype object, to be populated with set. Equivalent to Object.create(null).

method createObject

createObject: () => any;

• Creates an empty object, to be populated with set.

method createSet

createSet: () => any;

• Creates an empty Set, to be populated with addValue.

method createSparseArray

createSparseArray: (length: number) => any;

• Creates a sparse array of the given length, to be populated with set. Unlike createArray, the length comes from the input rather than being bounded by it, so implementations must not allocate storage proportional to it.

method fromArrayBuffer

fromArrayBuffer: (buffer: ArrayBuffer) => any;

• Creates an ArrayBuffer from a host ArrayBuffer holding the decoded bytes. The inverse of toArrayBuffer. Default: the buffer itself. Foreign-runtime implementations should copy the bytes into the target runtime.

method fromISOString

fromISOString: (iso: string) => any;

• Creates a Date from an ISO string. The inverse of toISOString. An empty string represents an invalid date (as produced for new Date(NaN)).

method fromPrimitive

fromPrimitive: (
    primitive: string | number | boolean | bigint | null | undefined
) => any;

• Wraps a host primitive (string, number, boolean, bigint, null, undefined, and the special values NaN, ±Infinity, -0) into the representation the other operations expect. The inverse of toPrimitive. Default: the value itself.

method fromRegExpInfo

fromRegExpInfo: (source: string, flags: string | undefined) => any;

• Creates a RegExp from its source and flags. The inverse of regExpInfo. flags is undefined when the pattern had no flags.

method fromStringValue

fromStringValue: (tag: StringValueTag, text: string) => any;

• Creates a URL, URLSearchParams or Temporal.* value from its string form — the same tags toStringValue serializes, and its inverse. tag distinguishes them (e.g. 'URL', 'Temporal.Instant').

method fromViewInfo

fromViewInfo: (
    tag: ViewTag,
    buffer: any,
    byteOffset: number | undefined,
    length: number | undefined
) => any;

• Creates a typed array or DataView over an already-revived buffer. The inverse of viewInfo. tag is the constructor name (e.g. 'Uint8Array', 'DataView'). byteOffset and length are undefined when the view spans the whole buffer; otherwise length is the element count for typed arrays and the byte length for DataView, matching the constructor signatures.

  Implementations must validate that buffer represents a genuine backing buffer, since custom revivers can return other values. In particular, passing a number or array-like value to a native typed array constructor can allocate storage unrelated to the size of the serialized input.

method set

set: (target: any, key: string | number, value: any) => void;

• Sets an element or property on a value created by createArray, createSparseArray, createObject or createNullPrototypeObject. The inverse of get, which likewise serves both arrays and objects.

property operations

operations?: Partial<ParseOperations>;

• Overrides for the construction operations used while reviving. Omitted members fall back to defaultParseOperations.

method entriesOf

entriesOf: (map: any) => Iterable<[any, any]>;

• Returns an iterable over the [key, value] entries of a Map value. The iterable is consumed on the host; keys/values may be foreign values/handles.

method get

get: (value: any, key: string | number) => any;

• Reads a property from an Array or plain-object value. Equivalent to value[key]. Hardened implementations can read through property descriptors to control what happens for accessor properties.

method hasOwn

hasOwn: (value: any, key: string | number) => boolean;

• Returns true if a value has an own property at key. Same contract as Object.hasOwn(value, key).

method identify

identify: (value: any) => unknown;

• Returns the key used for deduplication and cycle detection (compared with Map key semantics). Two values that represent the same logical object must return the same key. Default: the value itself.

  Override this when serializing through handles, where two distinct handle objects may refer to the same underlying value.

  Keys are compared across *every* value in the payload, including primitives, so an implementation that derives keys for objects must make sure they cannot collide with a primitive that appears in the same payload — returning e.g. the string '42' as an object's key would alias it to the string '42' elsewhere in the payload and emit a wrong back-reference. Prefer keys that are unforgeable, such as the underlying object itself, a symbol, or a wrapper object.

method indicesOf

indicesOf: (array: any) => string[];

• Returns the populated indices of a (sparse) Array value as strings, in ascending order.

  Implementations that already have the value's own enumerable string keys — as a foreign-runtime implementation typically does — should pass them through the exported filterArrayIndices helper rather than reimplementing the filtering, which encodes the sparse-array heuristic.

  Equivalent to Object.keys(array) filtered to valid array indices.

method isThenable

isThenable: (value: any) => boolean;

• Returns true if the object value should be treated as a thenable.

method lengthOf

lengthOf: (array: any) => number;

• Returns the length of an Array value.

method regExpInfo

regExpInfo: (regexp: any) => { source: string; flags: string };

• Returns the source and flags of a RegExp value.

method shapeOf

shapeOf: (
    value: any
) =>
    | { kind: 'plain' | 'null-proto'; keys: string[] }
    | { kind: 'not-plain' }
    | { kind: 'symbol-keys' };

• Classifies a plain-object candidate: - { kind: 'plain' | 'null-proto', keys } — a serializable POJO and its own enumerable string keys - { kind: 'not-plain' } — a non-POJO (stringify throws) - { kind: 'symbol-keys' } — a POJO with enumerable symbol keys (stringify throws)

method tagOf

tagOf: (value: any) => string;

• Returns the brand of an object value — the strings produced by Object.prototype.toString without the wrapping ('Date', 'Array', 'Map', 'Object', 'Temporal.Instant', …). This decides which serialization strategy is used, so hardened implementations should use engine-level brand checks rather than (spoofable, getter-invoking) Symbol.toStringTag lookups.

method toArrayBuffer

toArrayBuffer: (buffer: any) => ArrayBuffer;

• Returns a host ArrayBuffer with the bytes of an ArrayBuffer value. Default: the value itself. Foreign-runtime implementations should copy the bytes into a host buffer.

method toISOString

toISOString: (date: any) => string;

• Returns the ISO string for a Date value, or '' for an invalid date. Equivalent to date.toISOString().

method toPrimitive

toPrimitive: (
    value: any
) => undefined | null | boolean | number | bigint | string;

• Extracts the host-JavaScript primitive from a value whose typeOf is 'null', 'boolean', 'number', 'bigint' or 'string'. Default: the value itself (it already is the primitive).

method toPromise

toPromise: (thenable: any) => Promise<any>;

• Converts a thenable into a native promise, whose settled value is then serialized. The returned promise may reject, in which case stringifyAsync rejects. Only called from stringifyAsync, for values where isThenable returned true.

method toStringValue

toStringValue: (value: any) => string;

• Returns the string form of a URL, URLSearchParams or Temporal.* value. Equivalent to value.toString().

method typeOf

typeOf: (
    value: any
) =>
    | 'undefined'
    | 'null'
    | 'boolean'
    | 'number'
    | 'bigint'
    | 'string'
    | 'symbol'
    | 'function'
    | 'object';

• Classifies a value. Same contract as the typeof operator, except null must be reported as 'null' (not 'object').

method unbox

unbox: (boxed: any) => any;

• Extracts the inner value of a boxed primitive (Number, String, Boolean, BigInt objects). Equivalent to boxed.valueOf(). The result is serialized recursively, so it may be a foreign value/handle.

method valuesOf

valuesOf: (set: any) => Iterable<any>;

• Returns an iterable over the elements of a Set value. The iterable is consumed on the host; elements may be foreign values/handles.

method viewInfo

viewInfo: (view: any) => {
    buffer: any;
    byteOffset: number;
    byteLength: number;
    length?: number;
    bufferByteLength: number;
};

• Returns the view metadata of a typed array or DataView value. length is only meaningful for typed arrays. buffer is serialized recursively in full, so it may be a foreign value/handle. The default copies Node Buffers into an exact-sized backing buffer with byteOffset 0 to avoid exposing unrelated bytes from Node's shared pool. Overrides must take equivalent care with pooled views.

property operations

operations?: Partial<StringifyOperations>;

• Overrides for the introspection/extraction operations used while serializing. Omitted members fall back to defaultStringifyOperations.