Module mozjs::jsapi[][src]

Modules

JS
Scalar
__gnu_cxx
__pstl
dbg
detail
detail
gc
gcstats
glue
jit
js
mozilla
oom
shadow
std

Structs

AbstractGeneratorObject
AllCompartments
AllFrames

Capture all frames.

AllocPolicyBase
AllocationMetadataBuilder
AllocationMetadataBuilder__bindgen_vtable
AtomicRefCounted
AutoAssertGCCallback

Assert that code is only ever called from a GC callback, disable the static rooting hazard analysis and assert if any allocation that could potentially trigger a GC occurs while this guard object is live.

AutoAssertNoContentJS
AutoAssertNoGC

Diagnostic assert (see MOZ_DIAGNOSTIC_ASSERT) that GC cannot occur while this class is live. This class does not disable the static rooting hazard analysis.

AutoCheckCannotGC
AutoClearTracingContext
AutoDebuggerJobQueueInterruption

[SMDOC] Protecting the debuggee’s job/microtask queue from debugger activity.

AutoDisableGenerationalGC

Ensure that generational GC is disabled within some scope.

AutoEnterCycleCollection
AutoEnterOOMUnsafeRegion
AutoEnterPolicy
AutoEnterPolicy__bindgen_vtable
AutoFilename
AutoGCRooter
AutoGeckoProfilerEntry
AutoHideScriptedCaller
AutoHoldPrincipals
AutoRequireNoGC

Pass a subclass of this “abstract” class to callees to require that they never GC. Subclasses can use assertions or the hazard analysis to ensure no GC happens.

AutoSaveExceptionState

Save and later restore the current exception state of a given JSContext. This is useful for implementing behavior in C++ that’s like try/catch or try/finally in JS.

AutoSetAsyncStackForNewCalls

Supply an alternative stack to incorporate into captured SavedFrame backtraces as the imputed caller of asynchronous JavaScript calls, like async function resumptions and DOM callbacks.

AutoSuppressGCAnalysis
AutoSuppressWarningReporter

A simple RAII class that clears the registered warning reporter on construction and restores it on destruction.

AutoTracingDetails
AutoTracingIndex
AutoTracingName
AutoWaivePolicy
BarrierMethods
BarrieredBase
BaseProxyHandler
BaseProxyHandler__bindgen_vtable
BaseScript
BaseShape
BigInt
BufferIterator
CallArgs
CallArgsBase
CallbackTracer
ClassExtension
ClassInfo
ClassSpec
ClippedTime
CloneDataPolicy
CodeSizes

Data for tracking JIT-code memory usage.

Compartment
CompartmentFilter
CompartmentFilter__bindgen_vtable
CompartmentTransplantCallback
CompartmentTransplantCallback__bindgen_vtable
CompileOptions

Compilation options stored on the stack. An instance of this type simply holds references to dynamically allocated resources (element; filename; source map URL) that are owned by something else. If you create an instance of this type, it’s up to you to guarantee that everything you store in it will outlive it.

ConstLatin1Chars
ConstTwoByteChars
ConstUTF8CharsZ
ContextOptions
CustomAutoRooter

Custom rooting behavior for internal and external clients.

CustomAutoRooter__bindgen_vtable
DefineComparisonOps
DeletePolicy
Dispatchable

The Dispatchable interface allows the embedding to call SpiderMonkey on a JSContext thread when requested via DispatchToEventLoopCallback.

Dispatchable__bindgen_vtable
ElementAdder
Error

Type representing a JS error or exception. At the moment this only “represents” an error in a rather abstract way.

ErrorReportBuilder
ExceptionStack
ExpandoAndGeneration
FallbackOverload
FirstSubsumedFrame

Capture the first frame with the given principals. By default, do not consider self-hosted frames with the given principals as satisfying the stack capture.

ForOfIterator

A convenience class for imitating a JS for-of loop. Typical usage:

FreePolicy
GCCellPtr

A GC pointer, tagged with the trace kind.

GCDescription
GCPointerPolicy
GCPolicy
GCSizes

Data for tracking GC memory usage.

GeckoProfilerBaselineOSRMarker
GeckoProfilerEntryMarker
GeckoProfilerThread
GenericTracer
GenericTracer__bindgen_vtable
GlobalStats

Measurements that not associated with any individual runtime.

Handle

Reference to a T that has been rooted elsewhere. This is most useful as a parameter type, which guarantees that the T lvalue is properly rooted. See “Move GC Stack Rooting” above.

HandleBase
HandleObjectVector
HandleValueArray

A generic handle to an array of rooted values.

HeapBase
HelperThreadStats
IgnoreGCPolicy
IncludeUsedRval
InefficientNonFlatteningStringHashPolicy

This hash policy avoids flattening ropes (which perturbs the site being measured and requires a JSContext) at the expense of doing a FULL ROPE COPY on every hash and match! Beware.

IsBaseTraceType
IsHeapConstructibleType
IterImpl
JSAtom
JSAtomState
JSAutoNullableRealm
JSAutoRealm
JSAutoStructuredCloneBuffer

The C-style API calls to read and write structured clones are fragile – they rely on the caller to properly handle ownership of the clone data, and the handling of the input data as well as the interpretation of the contents of the clone buffer are dependent on the callbacks passed in. If you serialize and deserialize with different callbacks, the results are questionable.

JSClass
JSClassOps
JSConstScalarSpec
JSContext
JSDOMCallbacks
JSErrorBase

Base class that implements parts shared by JSErrorReport and JSErrorNotes::Note.

JSErrorFormatString
JSErrorInterceptor

Callback used to intercept JavaScript errors.

JSErrorInterceptor__bindgen_vtable
JSErrorNotes

Notes associated with JSErrorReport.

JSErrorNotes_Note
JSErrorNotes_iterator
JSErrorReport

Describes a single error or warning that occurs in the execution of script.

JSExternalStringCallbacks

Each external string has a pointer to JSExternalStringCallbacks. Embedders can use this to implement custom finalization or memory reporting behavior.

JSExternalStringCallbacks__bindgen_vtable
JSFreeOp
JSFunction
JSFunctionSpec
JSFunctionSpecWithHelp
JSJitGetterCallArgs

A class, expected to be passed by value, which represents the CallArgs for a JSJitGetterOp.

JSJitInfo

This struct contains metadata passed from the DOM to the JS Engine for JIT optimizations on DOM property accessors.

JSJitMethodCallArgs
JSJitMethodCallArgsTraits
JSJitSetterCallArgs

A class, expected to be passed by value, which represents the CallArgs for a JSJitSetterOp.

JSLinearString
JSNativeWrapper

Wrapper to relace JSNative for JSPropertySpecs and JSFunctionSpecs. This will allow us to pass one JSJitInfo per function with the property/function spec, without additional field overhead.

JSObject
JSPrincipals
JSPrincipals__bindgen_vtable
JSPropertySpec

Description of a property. JS_DefineProperties and JS_InitClass take arrays of these and define many properties at once. JS_PSG, JS_PSGS and JS_PS_END are helper macros for defining such arrays.

JSPropertySpec_AccessorsOrValue_Accessors
JSPropertySpec_SelfHostedWrapper
JSPropertySpec_ValueWrapper
JSRuntime
JSScript
JSSecurityCallbacks
JSString
JSStructuredCloneCallbacks
JSStructuredCloneData

JSStructuredCloneData represents structured clone data together with the information needed to read/write/transfer/free the records within it, in the form of a set of callbacks.

JSStructuredCloneReader
JSStructuredCloneWriter
JSTimers

Timing information for telemetry purposes

JSTracer
JSTypedMethodJitInfo
JSWrapObjectCallbacks
JobQueue

Abstract base class for an ECMAScript Job Queue: https://www.ecma-international.org/ecma-262/9.0/index.html#sec-jobs-and-job-queues

JobQueue_SavedJobQueue

A saved job queue, represented however the JobQueue implementation pleases. Use AutoDebuggerJobQueueInterruption rather than trying to construct one of these directly; see documentation there.

JobQueue_SavedJobQueue__bindgen_vtable
JobQueue__bindgen_vtable
Latin1Chars
Latin1CharsZ
MallocAllocPolicy
MapTypeToRootKind
MapTypeToTraceKind
MaxFrames

Capture at most this many frames.

MovableCellHasher
MutableHandle

Similar to a handle, but the underlying storage can be changed. This is useful for outparams.

MutableHandleBase
MutableHandleIdVector
MutableHandleObjectVector
MutableValueOperations
MutableWrappedPtrOperations
NoUsedRval
NonGCPointerPolicy
NotableClassInfo

Holds data about a notable class (one whose combined object and shape instances use more than a certain amount of memory) so we can report it individually.

NotableScriptSourceInfo

Holds data about a notable script source file (one whose combined script sources use more than a certain amount of memory) so we can report it individually.

NotableStringInfo

Holds data about a notable string (one which, counting all duplicates, uses more than a certain amount of memory) so we can report it individually.

NurseryDecommitTask
OOM
Object

This layout is shared by all native objects. For non-native objects, the shape may always be accessed safely, and other members may be as well, depending on the object’s specific layout.

ObjectOpResult

Per ES6, the [[DefineOwnProperty]] internal method has three different possible outcomes:

ObjectOps
ObjectPrivateVisitor
ObjectPrivateVisitor__bindgen_vtable
OffThreadToken
OptimizedEncodingListener
OptimizedEncodingListener__bindgen_vtable
OwningCompileOptions

Compilation options, with dynamic lifetime. An instance of this type makes a copy of / holds / roots all dynamically allocated resources (principals; elements; strings) that it refers to. Its destructor frees / drops / unroots them. This is heavier than CompileOptions, below, but unlike CompileOptions, it can outlive any given stack frame.

PersistentRooted

A copyable, assignable global GC root type with arbitrary lifetime, an infallible constructor, and automatic unrooting on destruction.

PersistentRootedBase
PersistentRootedVector
PreferredOverload
ProfilingCategoryPairInfo
ProfilingStack
ProfilingStackFrame
PropertyDescriptor

A structure that represents a property on an object, or the absence of a property. Use {,Mutable}Handle to interact with instances of this structure rather than interacting directly with member fields.

PropertyKey
PropertyResult
ProxyDataLayout
ProxyOptions
ProxyReservedSlots
ProxyValueArray
PtrBarrierMethodsBase
ReadOnlyCompileOptions

The class representing a full set of compile options.

ReadableStreamUnderlyingSource

Abstract base class for external underlying sources.

ReadableStreamUnderlyingSource__bindgen_vtable
Realm
RealmBehaviors

RealmBehaviors specifies behaviors of a realm that can be changed after the realm’s been created.

RealmBehaviors_Override
RealmCreationOptions

RealmCreationOptions specifies options relevant to creating a new realm, that are either immutable characteristics of that realm or that are discarded after the realm has been created.

RealmOptions

RealmOptions specifies realm characteristics: both those that can’t be changed on a realm once it’s been created (RealmCreationOptions), and those that can be changed on an existing realm (RealmBehaviors).

RealmStats
RefCounted
RefPtr
RefPtr_ConstRemovingRefPtrTraits
RefPtr_Proxy
RegExpFlag

Regular expression flag values, suitable for initializing a collection of regular expression flags as defined below in |RegExpFlags|. Flags are listed in alphabetical order by syntax – /d, /g, /i, /m, /s, /u, /y.

RegExpFlags

A collection of regular expression flags. Individual flag values may be combined into a collection using bitwise operators.

RegExpShared
RootListEntry
RootedBase
RootedGCThingTraits
RootedTraceable
RootedTraceableTraits
Rooted_CtorDispatcher
RootingContext
RunnableTask
RunnableTask__bindgen_vtable
Runtime
RuntimeSizes

These measurements relate directly to the JSRuntime, and not to zones, compartments, and realms within it.

RuntimeStats
RuntimeStats__bindgen_vtable
SavedFrame
Scope
ScriptEnvironmentPreparer

PrepareScriptEnvironmentAndInvoke asserts the embedder has registered a ScriptEnvironmentPreparer and then it calls the preparer’s ‘invoke’ method with the given |closure|, with the assumption that the preparer will set up any state necessary to run script in |global|, invoke |closure| with a valid JSContext*, report any exceptions thrown from the closure, and return.

ScriptEnvironmentPreparer_Closure
ScriptEnvironmentPreparer_Closure__bindgen_vtable
ScriptEnvironmentPreparer__bindgen_vtable
ScriptSource
ScriptSourceInfo

This class holds information about the memory taken up by script sources from a particular file.

ServoSizes

These are the measurements used by Servo.

Shape
ShapeInfo
SharedArrayRawBuffer
SharedArrayRawBufferRefs
SingleCompartment
SourceText
StackGCVector
StreamConsumer
StreamConsumer__bindgen_vtable
StringInfo

This class holds information about the memory taken up by identical copies of a particular string. Multiple JSStrings may have their sizes aggregated together into one StringInfo object. Note that two strings with identical chars will not be aggregated together if one is a short string and the other is not.

StructGCPolicy
Symbol
SystemAllocPolicy
TabSizes
TempAllocPolicy
TenuredHeap

The TenuredHeap class is similar to the Heap class above in that it encapsulates the GC concerns of an on-heap reference to a JS object. However, it has two important differences:

TraceOptions
TracingContext
TracingContext_Functor
TracingContext_Functor__bindgen_vtable
TranscodeSource
TransitiveCompileOptions

The common base class for the CompileOptions hierarchy.

TransitiveCompileOptions__bindgen_vtable
TwoByteChars
TwoByteCharsZ
TypeIsGCThing
UTF8Chars
UTF8CharsZ
UniqueSelector
UnusedGCThingSizes
UnusedZero
Value

[SMDOC] JS::Value type

VirtualTraceable
VirtualTraceable__bindgen_vtable
WasmModule

The WasmModule interface allows the embedding to hold a reference to the underying C++ implementation of a JS WebAssembly.Module object for purposes of efficient postMessage() and (de)serialization from a random thread.

WasmModule__bindgen_vtable
WeakMapTracer
WeakMapTracer__bindgen_vtable
WrappedPtrOperations
Wrapper
WritableStreamUnderlyingSink
WritableStreamUnderlyingSink__bindgen_vtable
Zone
ZoneStats
_IO_FILE
_IO_codecvt
_IO_marker
_IO_wide_data
__BindgenBitfieldUnit
__va_list_tag
_bindgen_ty_73
nsISupports

Enums

AllocFunction
AsmJSOption
AutoGCRooterKind
AutoGCRooter_Kind
AutoSetAsyncStackForNewCalls_AsyncCallKind
BaseProxyHandler__bindgen_ty_1
CompartmentIterResult
CompartmentSpecifier

Specification for which compartment/zone a newly created realm should use.

CompletionKind
DOMProxyShadowsResult
Dispatchable_MaybeShuttingDown
DynamicImportStatus

Passed to FinishDynamicModuleImport to indicate the result of the dynamic import operation.

ESClass

Enumeration describing possible values of the [[Class]] internal property value of objects.

ElementAdder_GetBehavior
ErrorReportBuilder_SniffingBehavior
Error_ErrorKind
ExceptionStackBehavior
ForOfIterator_NonIterableBehavior
GCNurseryProgress

Describes the progress of an observed nursery collection.

GCProgress
GCReason
Handle_CallerIdentity
Handle_Disambiguator
HeapState
IdTraceAction
InitState
IsArrayAnswer

The answer to a successful query as to whether an object is an Array per ES6’s internal |IsArray| operation (as exposed by |Array.isArray|).

JSErrNum
JSExnType

Possible exception types. These types are part of a JSErrorFormatString structure. They define which error to throw in case of a runtime error.

JSFinalizeStatus
JSGCInvocationKind

Kinds of js_GC invocation.

JSGCParamKey
JSGCStatus
JSJitCompilerOption
JSJitInfo_AliasSet

An enum that describes what this getter/setter/method aliases. This determines what things can be hoisted past this call, and if this call is movable what it can be hoisted past.

JSJitInfo_ArgType
JSJitInfo_OpType
JSPropertySpec_ValueWrapper_Type
JSProtoKey
JSType
JSValueShiftedTag
JSValueTag
JSValueType
JSWhyMagic
MemoryUse
MimeType
NukeReferencesFromTarget
NukeReferencesToWindow
ObjectOpResult_SpecialCodes
OnNewGlobalHookOption

During global creation, we fire notifications to callbacks registered via the Debugger API. These callbacks are arbitrary script, and can touch the global in arbitrary ways. When that happens, the global should not be in a half-baked state. But this creates a problem for consumers that need to set slots on the global to put it in a consistent state.

OwnTransferablePolicy
ProfilingCategory
ProfilingCategoryPair
ProfilingStackFrame_Flags
PromiseRejectionHandlingState
PromiseState
PromiseUserInputEventHandlingState
PropertyResult_Kind
ReadableStreamMode
ReadableStreamReaderMode
RealmBehaviors_Override_Mode
RootKind
SavedFrameResult
SavedFrameSelfHosted
ServoSizes_Kind
SmallestEncoding
SourceOwnership
StackFormat
StackKind
StructuredCloneScope

Indicates the “scope of validity” of serialized data.

SymbolCode
TabSizes_Kind
TenuredHeap__bindgen_ty_1
ThreadType
TraceKind
TracerKind
TranscodeResult
TransferableOwnership
Type
ValueType
WeakEdgeTraceAction
WeakMapTraceAction
WeakRefSpecifier

Specification for whether weak refs should be enabled and if so whether the FinalizationRegistry.cleanupSome method should be present.

Constants

BaseProxyHandler_CALL
BaseProxyHandler_ENUMERATE
BaseProxyHandler_GET
BaseProxyHandler_GET_PROPERTY_DESCRIPTOR
BaseProxyHandler_NONE
BaseProxyHandler_SET
ClassSpec_DontDefineConstructor
ClassSpec_ProtoKeyMask
ClassSpec_ProtoKeyWidth
ForOfIterator_NOT_ARRAY
JSCLASS_BACKGROUND_FINALIZE
JSCLASS_CACHED_PROTO_MASK
JSCLASS_CACHED_PROTO_SHIFT
JSCLASS_DELAY_METADATA_BUILDER
JSCLASS_EMULATES_UNDEFINED
JSCLASS_FOREGROUND_FINALIZE
JSCLASS_GLOBAL_APPLICATION_SLOTS
JSCLASS_GLOBAL_FLAGS
JSCLASS_GLOBAL_SLOT_COUNT
JSCLASS_HAS_PRIVATE
JSCLASS_HAS_XRAYED_CONSTRUCTOR
JSCLASS_HIGH_FLAGS_SHIFT
JSCLASS_INTERNAL_FLAG1
JSCLASS_INTERNAL_FLAG2
JSCLASS_IS_DOMJSCLASS
JSCLASS_IS_GLOBAL
JSCLASS_IS_PROXY
JSCLASS_IS_WRAPPED_NATIVE
JSCLASS_PRIVATE_IS_NSISUPPORTS
JSCLASS_RESERVED_SLOTS_MASK
JSCLASS_RESERVED_SLOTS_SHIFT
JSCLASS_RESERVED_SLOTS_WIDTH
JSCLASS_SKIP_NURSERY_FINALIZE
JSCLASS_USERBIT1
JSCLASS_USERBIT2
JSCLASS_USERBIT3
JSClass_NON_NATIVE
JSFUN_CONSTRUCTOR
JSFUN_FLAGS_MASK
JSITER_FORAWAITOF
JSITER_HIDDEN
JSITER_OWNONLY
JSITER_PRIVATE
JSITER_SYMBOLS
JSITER_SYMBOLSONLY
JSJitInfo_AliasSetBits
JSJitInfo_OpTypeBits
JSJitInfo_ReturnTypeBits
JSJitInfo_SlotIndexBits
JSJitInfo_maxSlotIndex
JSJitMethodCallArgsTraits_offsetOfArgc
JSJitMethodCallArgsTraits_offsetOfArgv
JSPROP_ENUMERATE
JSPROP_FLAGS_MASK
JSPROP_GETTER
JSPROP_IGNORE_ENUMERATE
JSPROP_IGNORE_PERMANENT
JSPROP_IGNORE_READONLY
JSPROP_IGNORE_VALUE
JSPROP_PERMANENT
JSPROP_READONLY
JSPROP_RESOLVING
JSPROP_SETTER
JSStructuredCloneData_kStandardCapacity
JS_64BIT
JS_BITS_PER_WORD
JS_CODEGEN_X64
JS_DEFAULT_JITREPORT_GRANULARITY
JS_HAS_INTL_API
JS_PUNBOX64
JS_SCERR_DUP_TRANSFERABLE
JS_SCERR_NOT_CLONABLE
JS_SCERR_NOT_CLONABLE_WITH_COOP_COEP
JS_SCERR_RECURSION
JS_SCERR_SHMEM_TRANSFERABLE
JS_SCERR_TRANSFERABLE
JS_SCERR_TYPED_ARRAY_DETACHED
JS_SCERR_UNSUPPORTED_TYPE
JS_SCERR_WASM_NO_TRANSFER
JS_STANDALONE
JS_STRUCTURED_CLONE_VERSION
JS_WITHOUT_NSPR
NotableStringInfo_MAX_SAVED_CHARS
ProfilingStackFrame_NullPCOffset
RegExpFlag_AllFlags
RegExpFlag_DotAll
RegExpFlag_Global
RegExpFlag_HasIndices
RegExpFlag_IgnoreCase
RegExpFlag_Multiline
RegExpFlag_NoFlags
RegExpFlag_Sticky
RegExpFlag_Unicode
TenuredHeap_flagsMask
TenuredHeap_maskBits

Statics

AutoEnterOOMUnsafeRegion_annotateOOMSizeCallback
JS_NULL_CLASS_EXT
JS_NULL_CLASS_OPS
JS_NULL_CLASS_SPEC
JS_NULL_OBJECT_OPS
NullHandleValue
ProxyClass
ProxyClassExtension
ProxyClassOps
ProxyObjectOps
TracingContext_InvalidIndex
TrueHandleValue
UndefinedHandleValue

Functions

AbortIncrementalGC

If IsIncrementalGCInProgress(cx), this call aborts the ongoing collection and performs whatever work needs to be done to return the collector to its idle state. This may take an arbitrarily long time. When this function returns, IsIncrementalGCInProgress(cx) will always be false.

AddAssociatedMemory

Advise the GC of external memory owned by a JSObject. This is used to determine when to collect zones. Calls must be matched by calls to RemoveAssociatedMemory() when the memory is deallocated or no longer owned by the object.

AddPersistentRoot
AddPersistentRoot1
AddPromiseReactions

Unforgeable, optimized version of the JS builtin Promise.prototype.then.

AddPromiseReactionsIgnoringUnhandledRejection

Unforgeable, optimized version of the JS builtin Promise.prototype.then.

AddRawValueRoot
AddServoSizeOf
AddSizeOfTab
AllowNewWrapper
AppendUnique
AreGCGrayBitsValid
ArrayBufferHasData

Return true if the ArrayBuffer |obj| contains any data, i.e. it is not a detached ArrayBuffer. (ArrayBuffer.prototype is not an ArrayBuffer.)

AssertHeapIsIdle
AssertJSStringBufferInCorrectArena
AssertObjectBelongsToCurrentThread

Asserts (in debug and release builds) that obj belongs to the current thread’s context.

AssertSameCompartment
AssertSameCompartment1
AtomToLinearString
BuildStackString

Given a SavedFrame JSObject stack, stringify it in the same format as Error.prototype.stack. The stringified stack out parameter is placed in the cx’s compartment. Defaults to the empty string.

Call
CallMethodIfWrapped
CallOriginalPromiseReject

Calls the current compartment’s original Promise.reject on the original Promise constructor, with resolutionValue passed as an argument.

CallOriginalPromiseResolve

Calls the current compartment’s original Promise.resolve on the original Promise constructor, with resolutionValue passed as an argument.

CallOriginalPromiseThen

Create a Promise with the given fulfill/reject handlers, that will be fulfilled/rejected with the value/reason that the promise promise is fulfilled/rejected with.

CanCompileOffThread
CanDecodeOffThread
CancelMultiOffThreadScriptsDecoder
CancelOffThreadModule
CancelOffThreadScript
CancelOffThreadScriptDecoder
CaptureCurrentStack

Capture the current call stack as a chain of SavedFrame JSObjects, and set |stackp| to the SavedFrame for the youngest stack frame, or nullptr if there are no JS frames on the stack.

CheckCompileOptionsMatch
CheckRegExpSyntax

Check whether the given source is a valid regexp. If the regexp parses successfully, returns true and sets |error| to undefined. If the regexp has a syntax error, returns true, sets |error| to that error object, and clears the exception. Returns false on OOM or over-recursion.

ClearKeptObjects

Clear kept alive objects in JS WeakRef. https://tc39.es/proposal-weakrefs/#sec-clear-kept-objects

ClearRegExpStatics
CloneAndExecuteScript

Like the above, but handles a cross-compartment script. If the script is cross-compartment, it is cloned into the current compartment before executing.

CloneAndExecuteScript1

Like CloneAndExecuteScript above, but allows executing under a non-syntactic environment chain.

CollectGlobalStats
CollectRuntimeStats
CompartmentHasLiveGlobal
Compile

Compile the provided script using the given options. Return the script on success, or return null on failure (usually with an error reported).

Compile1

Compile the provided script using the given options. Return the script on success, or return null on failure (usually with an error reported).

CompileAndStartIncrementalEncoding

Compile the provided script using the given options, and register an encoder on is script source, such that all functions can be encoded as they are parsed. This strategy is used to avoid blocking the main thread in a non-interruptible way.

CompileAndStartIncrementalEncoding1
CompileFunction

Compile a function with envChain plus the global as its scope chain. envChain must contain objects in the current compartment of cx. The actual scope chain used for the function will consist of With wrappers for those objects, followed by the current global of the compartment cx is in. This global must not be explicitly included in the scope chain.

CompileFunction1

Compile a function with envChain plus the global as its scope chain. envChain must contain objects in the current compartment of cx. The actual scope chain used for the function will consist of With wrappers for those objects, followed by the current global of the compartment cx is in. This global must not be explicitly included in the scope chain.

CompileFunctionUtf8

Identical to the CompileFunction overload above for UTF-8, but with Rust-friendly ergonomics.

CompileModule

Parse the given source buffer as a module in the scope of the current global of cx and return a source text module record.

CompileModule1

Parse the given source buffer as a module in the scope of the current global of cx and return a source text module record. An error is reported if a UTF-8 encoding error is encountered.

CompileOffThread
CompileOffThread1
CompileOffThreadModule
CompileOffThreadModule1
CompileUtf8File

Compile the UTF-8 contents of the given file into a script. It is an error if the file contains invalid UTF-8. Return the script on success, or return null on failure (usually with an error reported).

CompileUtf8Path

Compile the UTF-8 contents of the file at the given path into a script. (The path itself is in the system encoding, not [necessarily] UTF-8.) It is an error if the file’s contents are invalid UTF-8. Return the script on success, or return null on failure (usually with an error reported).

ComputeThis
Construct

Invoke a constructor. This is the C++ equivalent of rval = Reflect.construct(fun, args, newTarget).

Construct1

Invoke a constructor. This is the C++ equivalent of rval = new fun(...args).

ContextOptionsRef
ConvertSavedFrameToPlainObject

Given a SavedFrame object, convert it and its transitive parents to plain objects. Because SavedFrame objects store their properties on the prototype, they cannot be usefully stringified to JSON. Assigning their properties to plain objects allow those objects to be stringified and the saved frame stack can be encoded as a string.

CopyArrayBuffer

Create a new ArrayBuffer, whose bytes are set to the values of the bytes in the provided ArrayBuffer.

CopyAsyncStack
CreateError
CreateMappedArrayBufferContents

Create memory mapped ArrayBuffer contents. Caller must take care of closing fd after calling this function.

CurrentGlobalOrNull

Get the current realm’s global. Returns nullptr if no realm has been entered.

CurrentThreadCanAccessRuntime
CurrentThreadCanAccessZone
DateGetMsecSinceEpoch
DateIsValid

Detect whether the internal date value is NaN.

DayFromTime
DayFromYear
DayWithinYear
DecodeMultiOffThreadScripts
DecodeOffThreadScript
DecodeOffThreadScript1
DecodeScript
DecodeScript1
DecodeScriptAndStartIncrementalEncoding
DecodeScriptMaybeStencil
DefineFunctionWithReserved
DeflateStringToUTF8Buffer
DeleteOwningCompileOptions
DeleteRealmOptions
DescribeScriptedCaller

Return the current filename, line number and column number of the most currently running frame. Returns true if a scripted frame was found, false otherwise.

DetachArrayBuffer

Detach an ArrayBuffer, causing all associated views to no longer refer to the ArrayBuffer’s original attached memory.

DisableIncrementalGC

Incremental GC defaults to enabled, but may be disabled for testing or in embeddings that have not yet implemented barriers on their native classes. There is not currently a way to re-enable incremental GC once it has been disabled on the runtime.

DisableNurseryBigInts
DisableNurseryStrings
DisableWasmHugeMemory

Attempt to disable Wasm’s usage of reserving a large virtual memory allocation to avoid bounds checking overhead. This must be called before any Wasm module or memory is created in this process, or else this function will fail.

EnableContextProfilingStack
EnableNurseryBigInts
EnableNurseryStrings
EncodeScript
EnqueueJob

Enqueue |job| on the internal job queue.

EnterRealm

NB: This API is infallible; a nullptr return value does not indicate error.

Evaluate

Evaluate the given source buffer in the scope of the current global of cx, and return the completion value in |rval|.

Evaluate1

As above, but providing an explicit scope chain. envChain must not include the global object on it; that’s implicit. It needs to contain the other objects that should end up on the script’s scope chain.

Evaluate2

Evaluate the provided UTF-8 data in the scope of the current global of |cx|, and return the completion value in |rval|. If the data contains invalid UTF-8, an error is reported.

EvaluateUtf8Path

Evaluate the UTF-8 contents of the file at the given path, and return the completion value in |rval|. (The path itself is in the system encoding, not [necessarily] UTF-8.) If the contents contain any malformed UTF-8, an error is reported.

ExceptionStackOrNull

If the given object is an exception object (or an unwrappable cross-compartment wrapper for one), return the stack for that exception, if any. Will return null if the given object is not an exception object (including if it’s null or a security wrapper that can’t be unwrapped) or if the exception has no stack.

ExecuteInFrameScriptEnvironment
ExecuteRegExp
ExecuteRegExpNoStatics
ExplainGCReason

Get a statically allocated C string explaining the given GC reason.

ExposeScriptToDebugger
FindSmallestEncoding
FinishDynamicModuleImport

This must be called after a dynamic import operation is complete.

FinishDynamicModuleImport_NoTLA

This must be called after a dynamic import operation is complete.

FinishIncrementalEncoding
FinishIncrementalGC

If IsIncrementalGCInProgress(cx), this call finishes the ongoing collection by performing an arbitrarily long slice. If !IsIncrementalGCInProgress(cx), this is equivalent to NonIncrementalGC. When this function returns, IsIncrementalGCInProgress(cx) will always be false.

FinishMultiOffThreadScriptsDecoder
FinishOffThreadModule
FinishOffThreadScript
FinishOffThreadScriptAndStartIncrementalEncoding
FinishOffThreadScriptDecoder
ForceLexicalInitialization

Set all of the uninitialized lexicals on an object to undefined. Return true if any lexicals were initialized and false otherwise.

ForwardToNative
FromPropertyDescriptor
FunctionHasNativeReserved
GCThingTraceKind
GCTraceKindSize

Returns the base size in bytes of the GC thing of kind |kind|.

GCTraceKindToAscii

Returns a static string equivalent of |kind|.

GetAllocationMetadata

Get the metadata associated with an object.

GetAnyRealmInZone
GetArrayBufferByteLength

Return the available byte length of an ArrayBuffer.

GetArrayBufferData

Return a pointer to the start of the data referenced by a typed array. The data is still owned by the typed array, and should not be modified on another thread. Furthermore, the pointer can become invalid on GC (if the data is small and fits inside the array’s GC header), so callers must take care not to hold on across anything that could GC.

GetArrayBufferLengthAndData
GetArrayBufferViewLengthAndData
GetArrayLength

Store |*lengthp = ToLength(obj.length)| and return true on success, else return false.

GetBuiltinClass

Determine the ECMAScript “class” – Date, String, RegExp, and all the other builtin object types (described in ECMAScript in terms of an objecting having “an [[ArrayBufferData]] internal slot” or similar language for other kinds of object – of the provided object.

GetCurrentRealmOrNull
GetDOMCallbacks
GetDeflatedUTF8StringLength
GetElementsWithAdder
GetErrorMessage

A JSErrorCallback suitable for passing to |JS_ReportErrorNumberASCII| and similar functions in concert with one of the |JSErrNum| error numbers.

GetErrorTypeName

Get an error type name from a JSExnType constant. Returns nullptr for invalid arguments and JSEXN_INTERNALERR

GetFirstArgumentAsTypeHint

If args.get(0) is one of the strings “string”, “number”, or “default”, set result to JSTYPE_STRING, JSTYPE_NUMBER, or JSTYPE_UNDEFINED accordingly and return true. Otherwise, return false with a TypeError pending.

GetFirstGlobalInCompartment
GetFirstSubsumedSavedFrame

Get the first SavedFrame object in this SavedFrame stack whose principals are subsumed by the given |principals|. If there is no such frame, return nullptr.

GetFunctionNativeReserved
GetFunctionRealm
GetGCHeapUsageForObjectZone

This function only reports GC heap memory, and not malloc allocated memory associated with GC things.

GetIsSecureContext
GetJSTimers
GetLinearStringCharAt
GetLinearStringLength
GetModuleDynamicImportHook

Get the HostImportModuleDynamically hook for the runtime.

GetModuleMetadataHook

Get the hook for populating the import.meta metadata object.

GetModulePrivate

Get the private value associated with a source text module record.

GetModuleResolveHook

Get the HostResolveImportedModule hook for the runtime.

GetModuleScript
GetNonCCWObjectGlobal

Get the global object associated with an object’s realm. The object must not be a cross-compartment wrapper (because CCWs are shared by all realms in the compartment).

GetNurseryCellZone
GetObjectAsArrayBuffer

Attempt to unwrap |obj| as an ArrayBuffer.

GetObjectProto
GetObjectRealmOrNull
GetObjectZone
GetObjectZoneFromAnyThread
GetOptimizedEncodingBuildId

Some cached data is, in addition to being build-specific, CPU-specific: the cached data depends on CPU features like a particular level of SSE support.

GetPCCountScriptContents
GetPCCountScriptCount
GetPCCountScriptSummary
GetPendingExceptionStack
GetProfilingCategoryPairInfo
GetPromiseAllocationSite

Returns a js::SavedFrame linked list of the stack that lead to the given Promise’s allocation.

GetPromiseConstructor

Returns the current compartment’s original Promise constructor.

GetPromiseID

Returns the given Promise’s process-unique ID.

GetPromiseIsHandled

Returns whether the given promise’s rejection is already handled or not.

GetPromisePrototype

Returns the current compartment’s original Promise.prototype.

GetPromiseResolutionSite
GetPromiseResult

Returns the given Promise’s result: either the resolution value for fulfilled promises, or the rejection reason for rejected ones.

GetPromiseState

Returns the given Promise’s state as a JS::PromiseState enum value.

GetPromiseUserInputEventHandlingState

Returns the given Promise’s activation behavior state flag per above as a JS::PromiseUserInputEventHandlingState value. All promises are created with the DontCare state by default.

GetPropertyKeys

Add some or all property keys of obj to the id vector *props.

GetRealmArrayPrototype
GetRealmErrorPrototype
GetRealmFunctionPrototype
GetRealmGlobalOrNull
GetRealmIteratorPrototype
GetRealmObjectPrototype
GetRealmOriginalEval
GetRealmPrincipals
GetRealmPrivate
GetRealmWeakMapKey
GetRealmZone
GetRegExpFlags

Given a RegExp object (or a wrapper around one), return the set of all JS::RegExpFlag::* for it.

GetRegExpSource

Return the source text for a RegExp object (or a wrapper around one), or null on failure.

GetRequestedModuleSourcePos
GetRequestedModuleSpecifier
GetRequestedModules
GetSCOffset
GetSavedFrameAsyncCause

Given a SavedFrame JSObject, get its asyncCause string. Defaults to nullptr.

GetSavedFrameAsyncParent

Given a SavedFrame JSObject, get its asyncParent SavedFrame object or nullptr if there is no asyncParent. The asyncParentp out parameter is NOT guaranteed to be in the cx’s compartment. Defaults to nullptr.

GetSavedFrameColumn

Given a SavedFrame JSObject, get its column property. Defaults to 0.

GetSavedFrameFunctionDisplayName

Given a SavedFrame JSObject, get its functionDisplayName string, or nullptr if SpiderMonkey was unable to infer a name for the captured frame’s function. Defaults to nullptr.

GetSavedFrameLine

Given a SavedFrame JSObject, get its line property. Defaults to 0.

GetSavedFrameParent

Given a SavedFrame JSObject, get its parent SavedFrame object or nullptr if it is the oldest frame in the stack. The parentp out parameter is NOT guaranteed to be in the cx’s compartment. Defaults to nullptr.

GetSavedFrameSource

Given a SavedFrame JSObject, get its source property. Defaults to the empty string.

GetSavedFrameSourceId

Given a SavedFrame JSObject, get an ID identifying its ScriptSource. Defaults to 0.

GetScriptPrivate

Get the private value associated with a script. Note that this value is shared by all nested scripts compiled from a single source file.

GetScriptTranscodingBuildId

Script bytecode is dependent on the buildId and a few other things.

GetScriptedCallerGlobal
GetScriptedCallerPrivate
GetSelfHostedFunction
GetStackFormat
GetStaticPrototype
GetSymbolCode

Return the SymbolCode telling what sort of symbol symbol is.

GetSymbolDescription

Get the [[Description]] attribute of the given symbol.

GetSymbolFor

Symbol.for as specified in ES6.

GetTestingFunctions
GetWaitForAllPromise

Unforgeable version of the JS builtin Promise.all.

GetWarningReporter
GetWasmModule
GetWeakMapEntry
GetWellKnownSymbol

Get one of the well-known symbols defined by ES6. A single set of well-known symbols is shared by all compartments in a JSRuntime.

GlobalHasInstrumentation

Return whether a global object’s realm has had instrumentation enabled by a Debugger.

HeapBigIntPostWriteBarrier
HeapBigIntWriteBarriers
HeapObjectPostWriteBarrier
HeapObjectWriteBarriers
HeapScriptWriteBarriers
HeapStringPostWriteBarrier
HeapStringWriteBarriers
HeapValuePostWriteBarrier
HeapValueWriteBarriers
HideScriptedCaller

Informs the JS engine that the scripted caller should be hidden. This can be used by the embedding to maintain an override of the scripted caller in its calculations, by hiding the scripted caller in the JS engine and pushing data onto a separate stack, which it inspects when DescribeScriptedCaller returns null.

IdentifyStandardConstructor
IdentifyStandardInstance
IdentifyStandardInstanceOrPrototype
IdentifyStandardPrototype
IncrementalGCHasForegroundWork

Return whether an incremental GC has work to do on the foreground thread and would make progress if a slice was run now. If this returns false then the GC is waiting for background threads to finish their work and a slice started now would return immediately.

IncrementalGCSlice

Perform a slice of an ongoing incremental collection. When this function returns, the collection may not be complete. It must be called repeatedly until !IsIncrementalGCInProgress(cx).

IncrementalPreWriteBarrier
IncrementalPreWriteBarrier1
InformalValueTypeName
InitConsumeStreamCallback
InitDispatchToEventLoop
InitMallocAllocator
InitPipeToHandling

Dictate embedder-specific details necessary to implement certain aspects of the |ReadableStream.prototype.pipeTo| function. This should be performed exactly once, for a single context associated with a |JSRuntime|.

InitRealmStandardClasses
InitSelfHostedCode

Initialize the runtime’s self-hosted code. Embeddings should call this exactly once per runtime/context, before the first JS_NewGlobalObject call.

InitWithFailureDiagnostic
InstanceofOperator
InternalGCReason

Return true if the GC reason is internal to the JS engine.

IsArgumentsObject
IsArray

ES6 7.2.2.

IsArray1

Identical to IsArray above, but the nature of the object (if successfully determined) is communicated via |*answer|. In particular this method returns true and sets |*answer = IsArrayAnswer::RevokedProxy| when called on a revoked proxy.

IsArrayBufferObject
IsArrayObject

Determine whether |value| is an Array object or a wrapper around one. (An ES6 proxy whose target is an Array object, e.g. |var target = [], handler = {}; Proxy.revocable(target, handler).proxy|, is not considered to be an Array.)

IsArrayObject1

Determine whether |obj| is an Array object or a wrapper around one. (An ES6 proxy whose target is an Array object, e.g. |var target = [], handler = {}; Proxy.revocable(target, handler).proxy|, is not considered to be an Array.)

IsAsyncStackCaptureEnabledForRealm

Returns true if capturing stack trace data to associate with an asynchronous operation is currently enabled for the current context realm.

IsCallable

Return true if the given object is callable. In ES6 terms, an object is callable if it has a [Call] internal method.

IsCompartmentZoneSweepingOrCompacting
IsConstructor

Return true if the given object is a constructor. In ES6 terms, an object is a constructor if it has a [Construct] internal method. The expression new obj() throws a TypeError if obj is not a constructor.

IsDetachedArrayBufferObject

Check whether the obj is a detached ArrayBufferObject. Note that this may return false if a security wrapper is encountered that denies the unwrapping.

IsFunctionObject
IsGCPoisoning

Whether we are poisoning unused/released data for error detection. Governed by the JS_GC_ALLOW_EXTRA_POISONING #ifdef as well as the $JSGC_EXTRA_POISONING environment variable.

IsGCScheduled

Returns true if any zone in the system has been scheduled for GC with one of the functions above or by the JS engine.

IsGenerationalGCEnabled

Returns true if generational allocation and collection is currently enabled on the given runtime.

IsIdleGCTaskNeeded
IsIncrementalBarrierNeeded
IsIncrementalGCEnabled

Returns true if incremental GC is enabled. Simply having incremental GC enabled is not sufficient to ensure incremental collections are happening. See the comment “Incremental GC” above for reasons why incremental GC may be suppressed. Inspection of the “nonincremental reason” field of the GCDescription returned by GCSliceCallback may help narrow down the cause if collections are not happening incrementally when expected.

IsIncrementalGCInProgress

Returns true while an incremental GC is ongoing, both when actively collecting and between slices.

IsIncrementalGCInProgress1

Returns true while an incremental GC is ongoing, both when actively collecting and between slices.

IsLargeArrayBufferView
IsMapObject

On success, returns true, setting |*isMap| to true if |obj| is a Map object or a wrapper around one, or to false if not. Returns false on failure.

IsMappedArrayBufferObject

Check whether the obj is ArrayBufferObject and memory mapped. Note that this may return false if a security wrapper is encountered that denies the unwrapping.

IsMaybeWrappedSavedFrame

Return true iff the given object is either a SavedFrame object or wrapper around a SavedFrame object, and it is not the SavedFrame.prototype object.

IsObjectInContextCompartment
IsProfileTimelineRecordingEnabled
IsPromiseObject

Returns true if the given object is an unwrapped PromiseObject, false otherwise.

IsReadableStream

Returns true if the given object is a ReadableStream object or an unwrappable wrapper for one, false otherwise.

IsReadableStreamDefaultReader

Returns true if the given object is a ReadableStreamDefaultReader object or an unwrappable wrapper for one, false otherwise.

IsReadableStreamReader

Returns true if the given object is a ReadableStreamDefaultReader or ReadableStreamBYOBReader object or an unwrappable wrapper for one, false otherwise.

IsSavedFrame
IsSetObject

On success, returns true, setting |*isSet| to true if |obj| is a Set object or a wrapper around one, or to false if not. Returns false on failure.

IsSharableCompartment
IsSystemCompartment
IsSystemRealm
IsSystemZone
IsUnwrappedSavedFrame

Return true iff the given object is a SavedFrame object and not the SavedFrame.prototype object.

IsWasmModuleObject
IsWeakMapObject
IsWindowProxy

Returns true iff obj has the WindowProxy Class (see SetWindowProxyClass).

IsWindowSlow
IterateGrayObjects

Invoke cellCallback on every gray JSObject in the given zone.

IterateRealms

This function calls |realmCallback| on every realm. Beware that there is no guarantee that the realm will survive after the callback returns. Also, barriers are disabled via the TraceSession.

IterateRealmsInCompartment

Like IterateRealms, but only iterates realms in |compartment|.

IterateRealmsWithPrincipals

Like IterateRealms, but only call the callback for realms using |principals|.

JS_AbortIfWrongThread

A JS context always has an “owner thread”. The owner thread is set when the context is created (to the current thread) and practically all entry points into the JS engine check that a context (or anything contained in the context: runtime, compartment, object, etc) is only touched by its owner thread. Embeddings may check this invariant outside the JS engine by calling JS_AbortIfWrongThread (which will abort if not on the owner thread, even for non-debug builds).

JS_AddExtraGCRootsTracer

Register externally maintained GC roots.

JS_AddFinalizeCallback
JS_AddInterruptCallback
JS_AddWeakPointerCompartmentCallback
JS_AddWeakPointerZonesCallback
JS_AlreadyHasOwnElement
JS_AlreadyHasOwnProperty
JS_AlreadyHasOwnPropertyById
JS_AlreadyHasOwnUCProperty
JS_AsShadowZone
JS_Assert
JS_AssignObject

Equivalent to Object.assign(target, src): Copies the properties from the src object (which must not be null) to target (which also must not be null).

JS_AtomizeAndPinJSString
JS_AtomizeAndPinString
JS_AtomizeAndPinStringN
JS_AtomizeAndPinUCString
JS_AtomizeAndPinUCStringN
JS_AtomizeString
JS_AtomizeStringN
JS_AtomizeUCString
JS_AtomizeUCStringN
JS_CallArgsFromVp
JS_CallFunction
JS_CallFunctionName

Perform the method call rval = obj[name](args).

JS_CallFunctionValue

Call a function, passing a this-value and arguments. This is the C++ equivalent of rval = Reflect.apply(fun, obj, args).

JS_CharsToId

Convert chars into a jsid.

JS_CheckForInterrupt
JS_ClearPendingException
JS_CloneObject
JS_CompareStrings
JS_ConcatStrings

Concatenate two strings, possibly resulting in a rope. See above for thread safety comments.

JS_CopyOwnPropertiesAndPrivateFields

Copies all own properties and private fields from |obj| to |target|. Both |obj| and |target| must not be cross-compartment wrappers because we have to enter their realms.

JS_CopyStringChars
JS_CopyStringCharsZ

Copies the string’s characters to a null-terminated char16_t buffer.

JS_DecodeBytes

For JS_DecodeBytes, set *dstlenp to the size of the destination buffer before the call; on return, *dstlenp contains the number of characters actually stored. To determine the necessary destination buffer size, make a sizing call that passes nullptr for dst.

JS_DecompileFunction
JS_DecompileScript
JS_DeepFreezeObject

Freeze obj, and all objects it refers to, recursively. This will not recurse through non-extensible objects, on the assumption that those are already deep-frozen.

JS_DefineDebuggerObject
JS_DefineElement
JS_DefineElement1
JS_DefineElement2
JS_DefineElement3
JS_DefineElement4
JS_DefineElement5
JS_DefineElement6
JS_DefineFunction
JS_DefineFunctionById
JS_DefineFunctions
JS_DefineFunctionsWithHelp
JS_DefineObject

Other property-defining functions

JS_DefineProfilingFunctions

Add various profiling-related functions as properties of the given object. Defined in builtin/Profilers.cpp.

JS_DefineProperties
JS_DefineProperty
JS_DefineProperty1
JS_DefineProperty2
JS_DefineProperty3
JS_DefineProperty4
JS_DefineProperty5
JS_DefineProperty6
JS_DefineProperty7
JS_DefinePropertyById

Define a property on obj.

JS_DefinePropertyById1

Define a property on obj, throwing a TypeError if the attempt fails. This is the C++ equivalent of Object.defineProperty(obj, id, desc).

JS_DefinePropertyById2
JS_DefinePropertyById3
JS_DefinePropertyById4
JS_DefinePropertyById5
JS_DefinePropertyById6
JS_DefinePropertyById7
JS_DefinePropertyById8
JS_DefinePropertyById9
JS_DefineUCFunction
JS_DefineUCProperty
JS_DefineUCProperty1
JS_DefineUCProperty2
JS_DefineUCProperty3
JS_DefineUCProperty4
JS_DefineUCProperty5
JS_DefineUCProperty6
JS_DefineUCProperty7
JS_DefineUCProperty8
JS_DeleteElement
JS_DeleteElement1
JS_DeleteProperty
JS_DeleteProperty1
JS_DeletePropertyById

Delete a property. This is the C++ equivalent of result = Reflect.deleteProperty(obj, id).

JS_DeletePropertyById1

Delete a property, ignoring strict failures. This is the C++ equivalent of the JS delete obj[id] in non-strict mode code.

JS_DeleteUCProperty
JS_DeprecatedStringHasLatin1Chars

DO NOT USE, only present for Rust bindings as a temporary hack

JS_DestroyContext
JS_DisableInterruptCallback
JS_DoubleIsInt32
JS_DropPrincipals
JS_EncodeStringToASCII

DEPRECATED

JS_EncodeStringToBuffer

Encode string into a buffer. The function does not stores an additional zero byte. The function returns (size_t) -1 if the string can not be encoded into bytes with no error reported. Otherwise it returns the number of bytes that are necessary to encode the string. If that exceeds the length parameter, the string will be cut and only length bytes will be written into the buffer.

JS_EncodeStringToLatin1

DEPRECATED

JS_EncodeStringToUTF8

DEPRECATED

JS_EncodeStringToUTF8BufferPartial

Encode as many scalar values of the string as UTF-8 as can fit into the caller-provided buffer replacing unpaired surrogates with the REPLACEMENT CHARACTER.

JS_EnsureLinearString
JS_Enumerate

Get an array of the non-symbol enumerable properties of obj. This function is roughly equivalent to:

JS_EnumerateStandardClasses
JS_ErrorFromException

If the given object is an exception object, the exception will have (or be able to lazily create) an error report struct, and this function will return the address of that struct. Otherwise, it returns nullptr. The lifetime of the error report struct that might be returned is the same as the lifetime of the exception object.

JS_ExecuteScript

Evaluate a script in the scope of the current global of cx.

JS_ExecuteScript1
JS_ExecuteScript2

As above, but providing an explicit scope chain. envChain must not include the global object on it; that’s implicit. It needs to contain the other objects that should end up on the script’s scope chain.

JS_ExecuteScript3
JS_ExpandErrorArgumentsASCII
JS_ExtensibleLexicalEnvironment
JS_FindCompilationScope
JS_FireOnNewGlobalObject
JS_ForOfIteratorInit
JS_ForOfIteratorNext
JS_ForwardGetElementTo
JS_ForwardGetPropertyTo

Get the value of the property obj[id], or undefined if no such property exists. This is the C++ equivalent of vp = Reflect.get(obj, id, receiver).

JS_ForwardSetPropertyTo

Perform the same property assignment as Reflect.set(obj, id, v, receiver).

JS_FreezeObject

Freezes an object; see ES5’s Object.freeze(obj) method.

JS_GC
JS_GetArrayBufferViewBuffer

Return the ArrayBuffer or SharedArrayBuffer underlying an ArrayBufferView. This may return a detached buffer. |obj| must be an object that would return true for JS_IsArrayBufferViewObject().

JS_GetArrayBufferViewByteLength

More generic name for JS_GetTypedArrayByteLength to cover DataViews as well

JS_GetArrayBufferViewByteOffset

More generic name for JS_GetTypedArrayByteOffset to cover DataViews as well

JS_GetArrayBufferViewData

Same as above, but for any kind of ArrayBufferView. Prefer the type-specific versions when possible.

JS_GetArrayBufferViewFixedData

Return a “fixed” pointer (one that will not move during a GC) to the ArrayBufferView’s data. Note that this will not keep the object alive; the holding object should be rooted or traced. If the view is storing the data inline, this will copy the data to the provided buffer, returning nullptr if bufSize is inadequate.

JS_GetArrayBufferViewType
JS_GetBoundFunctionTarget
JS_GetClassObject
JS_GetClassPrototype
JS_GetCompartmentPrivate
JS_GetConstructor
JS_GetContextPrivate
JS_GetElement
JS_GetEmptyString
JS_GetEmptyStringValue

Don’t want to export data, so provide accessors for non-inline Values.

JS_GetErrorInterceptorCallback
JS_GetErrorType
JS_GetExternalStringCallbacks

Return the ‘callbacks’ arg passed to JS_NewExternalString or JS_NewMaybeExternalString.

JS_GetFloat32ArrayData
JS_GetFloat64ArrayData
JS_GetFunctionArity
JS_GetFunctionDisplayId

Return a function’s display name. This is the defined name if one was given where the function was defined, or it could be an inferred name by the JS engine in the case that the function was defined to be anonymous. This can still return nullptr if a useful display name could not be inferred. The same restrictions on rooting as those in JS_GetFunctionId apply.

JS_GetFunctionId

Return the function’s identifier as a JSString, or null if fun is unnamed. The returned string lives as long as fun, so you don’t need to root a saved reference to it if fun is well-connected or rooted, and provided you bound the use of the saved reference by fun’s lifetime.

JS_GetFunctionLength
JS_GetFunctionObject
JS_GetFunctionScript
JS_GetGCParameter
JS_GetGlobalFromScript
JS_GetGlobalJitCompilerOption
JS_GetImplementationVersion
JS_GetInstancePrivate
JS_GetInt8ArrayData
JS_GetInt16ArrayData
JS_GetInt32ArrayData
JS_GetLatin1StringCharsAndLength
JS_GetObjectAsArrayBufferView
JS_GetObjectAsFloat32Array
JS_GetObjectAsFloat64Array
JS_GetObjectAsInt8Array
JS_GetObjectAsInt16Array
JS_GetObjectAsInt32Array
JS_GetObjectAsUint8Array
JS_GetObjectAsUint8ClampedArray
JS_GetObjectAsUint16Array
JS_GetObjectAsUint32Array
JS_GetObjectFunction
JS_GetOwnPropertyDescriptor
JS_GetOwnPropertyDescriptorById

Get a description of one of obj’s own properties. If no such property exists on obj, return true with desc.object() set to null.

JS_GetOwnUCPropertyDescriptor
JS_GetParentRuntime
JS_GetPendingException
JS_GetProperty
JS_GetPropertyById

Get the value of the property obj[id], or undefined if no such property exists. The result is stored in vp.

JS_GetPropertyDescriptor
JS_GetPropertyDescriptorById

Like JS_GetOwnPropertyDescriptorById, but also searches the prototype chain if no own property is found directly on obj. The object on which the property is found is returned in desc.object(). If the property is not found on the prototype chain, this returns true with desc.object() set to null.

JS_GetPrototype

Get the prototype of |obj|, storing it in |proto|.

JS_GetPrototypeIfOrdinary

If |obj| (underneath any functionally-transparent wrapper proxies) has as its [[GetPrototypeOf]] trap the ordinary [[GetPrototypeOf]] behavior defined for ordinary objects, set |*isOrdinary = true| and store |obj|’s prototype in |result|. Otherwise set |*isOrdinary = false|. In case of error, both outparams have unspecified value.

JS_GetRuntime
JS_GetScriptBaseLineNumber
JS_GetScriptFilename
JS_GetScriptPrincipals
JS_GetSecurityCallbacks
JS_GetStringCharAt
JS_GetStringEncodingLength

Get number of bytes in the string encoding (without accounting for a terminating zero bytes. The function returns (size_t) -1 if the string can not be encoded into bytes and reports an error using cx accordingly.

JS_GetStringLength
JS_GetStructuredCloneScope
JS_GetTwoByteExternalStringChars
JS_GetTwoByteStringCharsAndLength
JS_GetTypedArrayByteLength

Return the byte length of a typed array.

JS_GetTypedArrayByteOffset

Return the byte offset from the start of an ArrayBuffer to the start of a typed array view.

JS_GetTypedArrayLength

Return the number of elements in a typed array.

JS_GetTypedArraySharedness

Return the isShared flag of a typed array, which denotes whether the underlying buffer is a SharedArrayBuffer.

JS_GetUCProperty
JS_GetUCPropertyDescriptor
JS_GetUint8ArrayData
JS_GetUint8ClampedArrayData
JS_GetUint16ArrayData
JS_GetUint32ArrayData
JS_GetZoneUserData
JS_GlobalLexicalEnvironment
JS_GlobalObjectTraceHook

Spidermonkey does not have a good way of keeping track of what compartments should be marked on their own. We can mark the roots unconditionally, but marking GC things only relevant in live compartments is hard. To mitigate this, we create a static trace hook, installed on each global object, from which we can be sure the compartment is relevant, and mark it.

JS_HasElement
JS_HasExtensibleLexicalEnvironment
JS_HasInstance
JS_HasOwnProperty
JS_HasOwnPropertyById

Determine whether obj has an own property with the key id.

JS_HasProperty
JS_HasPropertyById

Compute the expression id in obj.

JS_HasUCProperty
JS_HoldPrincipals
JS_IdToProtoKey
JS_IdToValue
JS_IndexToId

Convert a uint32_t index into a jsid.

JS_Init
JS_InitClass
JS_InitDestroyPrincipalsCallback
JS_InitPrivate
JS_InitReadPrincipalsCallback
JS_InitReflectParse

Add ‘Reflect.parse’, a SpiderMonkey extension, to the Reflect object on the given global.

JS_InitReservedSlot
JS_InitializePropertiesFromCompatibleNativeObject

Copy the own properties of src to dst in a fast way. src and dst must both be native and must be in the compartment of cx. They must have the same class, the same parent, and the same prototype. Class reserved slots will NOT be copied.

JS_InstanceOf
JS_IsArrayBufferViewObject

Check whether obj supports JS_GetArrayBufferView* APIs. Note that this may return false if a security wrapper is encountered that denies the unwrapping. If this test or one of the more specific tests succeeds, then it is safe to call the various ArrayBufferView accessor JSAPI calls defined below.

JS_IsBuiltinEvalFunction

True iff fun is the global eval function.

JS_IsBuiltinFunctionConstructor

True iff fun is the Function constructor.

JS_IsConstructor

Return whether the given function is a valid constructor.

JS_IsDeadWrapper

Determine whether the given object is backed by a DeadObjectProxy.

JS_IsExceptionPending
JS_IsExtensible

Determine whether obj is extensible. Extensible objects can have new properties defined on them. Inextensible objects can’t, and their [[Prototype]] slot is fixed as well.

JS_IsFloat32Array
JS_IsFloat64Array
JS_IsFunctionBound
JS_IsGlobalObject
JS_IsIdentifier

Test if the given string is a valid ECMAScript identifier

JS_IsIdentifier1

Test whether the given chars + length are a valid ECMAScript identifier. This version is infallible, so just returns whether the chars are an identifier.

JS_IsInt8Array
JS_IsInt16Array
JS_IsInt32Array
JS_IsNative
JS_IsNativeFunction
JS_IsThrowingOutOfMemory
JS_IsTypedArrayObject

Check whether obj supports JS_GetTypedArray* APIs. Note that this may return false if a security wrapper is encountered that denies the unwrapping. If this test or one of the JS_Is*Array tests succeeds, then it is safe to call the various accessor JSAPI calls defined below.

JS_IsUint8Array
JS_IsUint8ClampedArray
JS_IsUint16Array
JS_IsUint32Array
JS_IterateCompartments

This function calls |compartmentCallback| on every compartment until either all compartments have been iterated or CompartmentIterResult::Stop is returned. Beware that there is no guarantee that the compartment will survive after the callback returns. Also, barriers are disabled via the TraceSession.

JS_IterateCompartmentsInZone

This function calls |compartmentCallback| on every compartment in the given zone until either all compartments have been iterated or CompartmentIterResult::Stop is returned. Beware that there is no guarantee that the compartment will survive after the callback returns. Also, barriers are disabled via the TraceSession.

JS_LinearStringEqualsAscii
JS_LinearStringEqualsAscii1
JS_LinkConstructorAndPrototype

Set up ctor.prototype = proto and proto.constructor = ctor with the right property flags.

JS_MarkCrossZoneId

Mark a jsid after entering a new compartment. Different zones separately mark the ids in a runtime, and this must be used any time an id is obtained from one compartment and then used in another compartment, unless the two compartments are guaranteed to be in the same zone.

JS_MarkCrossZoneIdValue

If value stores a jsid (an atomized string or symbol), mark that id as for JS_MarkCrossZoneId.

JS_MaxMovableTypedArraySize

If the bufSize passed to JS_GetArrayBufferViewFixedData is at least this many bytes, then any copied data is guaranteed to fit into the provided buffer.

JS_MayResolveStandardClass
JS_MaybeGC
JS_NewBigInt64ArrayWithBuffer
JS_NewBigUint64ArrayWithBuffer
JS_NewContext
JS_NewDataView

Create a new DataView using the given buffer for storage. The given buffer must be an ArrayBuffer or SharedArrayBuffer (or a cross-compartment wrapper of either type), and the offset and length must fit within the bounds of the buffer. Currently, nullptr will be returned and an exception will be thrown if these conditions do not hold, but do not depend on that behavior.

JS_NewDeadWrapper

Creates a new dead wrapper object in the given scope. To be used when attempting to wrap objects from scopes which are already dead.

JS_NewDependentString

Create a dependent string, i.e., a string that owns no character storage, but that refers to a slice of another string’s chars. Dependent strings are mutable by definition, so the thread safety comments above apply.

JS_NewEnumerateStandardClasses

Fill “properties” with a list of standard class names that have not yet been resolved on “obj”. This can be used as (part of) a newEnumerate class hook on a global. Already-resolved things are excluded because they might have been deleted by script after being resolved and enumeration considers already-defined properties anyway.

JS_NewEnumerateStandardClassesIncludingResolved

Fill “properties” with a list of standard class names. This can be used for proxies that want to define behavior that looks like enumerating a global without touching the global itself.

JS_NewExternalString

Create a new JSString whose chars member refers to external memory, i.e., memory requiring application-specific finalization.

JS_NewFloat32Array
JS_NewFloat32ArrayFromArray
JS_NewFloat32ArrayWithBuffer
JS_NewFloat64Array
JS_NewFloat64ArrayFromArray
JS_NewFloat64ArrayWithBuffer
JS_NewFunction
JS_NewGlobalObject
JS_NewInt8Array
JS_NewInt8ArrayFromArray
JS_NewInt8ArrayWithBuffer
JS_NewInt16Array
JS_NewInt16ArrayFromArray
JS_NewInt16ArrayWithBuffer
JS_NewInt32Array
JS_NewInt32ArrayFromArray
JS_NewInt32ArrayWithBuffer
JS_NewLatin1String
JS_NewMaybeExternalString

Create a new JSString whose chars member may refer to external memory. If a new external string is allocated, |*allocatedExternal| is set to true. Otherwise the returned string is either not an external string or an external string allocated by a previous call and |*allocatedExternal| is set to false. If |*allocatedExternal| is false, |fin| won’t be called.

JS_NewObject
JS_NewObjectForConstructor

A constructor can request that the JS engine create a default new ‘this’ object of the given class, using the callee to determine parentage and [[Prototype]].

JS_NewObjectWithGivenProto

Unlike JS_NewObject, JS_NewObjectWithGivenProto does not compute a default proto. If proto is nullptr, the JS object will have null as [[Prototype]].

JS_NewObjectWithoutMetadata

Allocate an object in exactly the same way as JS_NewObjectWithGivenProto, but without invoking the metadata callback on it. This allows creation of internal bookkeeping objects that are guaranteed to not have metadata attached to them.

JS_NewOwningCompileOptions
JS_NewPlainObject

Creates a new plain object, like new Object(), with Object.prototype as [[Prototype]].

JS_NewRealmOptions
JS_NewStringCopyN
JS_NewStringCopyUTF8N
JS_NewStringCopyUTF8Z
JS_NewStringCopyZ
JS_NewUCString
JS_NewUCStringCopyN
JS_NewUCStringCopyZ
JS_NewUCStringDontDeflate
JS_NewUint8Array
JS_NewUint8ArrayFromArray
JS_NewUint8ArrayWithBuffer
JS_NewUint8ClampedArray
JS_NewUint8ClampedArrayFromArray
JS_NewUint8ClampedArrayWithBuffer
JS_NewUint16Array
JS_NewUint16ArrayFromArray
JS_NewUint16ArrayWithBuffer
JS_NewUint32Array
JS_NewUint32ArrayFromArray
JS_NewUint32ArrayWithBuffer
JS_NondeterministicGetWeakMapKeys
JS_NondeterministicGetWeakSetKeys
JS_Now

Microseconds since the epoch, midnight, January 1, 1970 UTC.

JS_ObjectIsFunction

Infallible predicate to test whether obj is a function object (faster than comparing obj’s class name to “Function”, but equivalent unless someone has overwritten the “Function” identifier with a different constructor and then created instances using that constructor that might be passed in as obj).

JS_ObjectNotWritten
JS_PCToLineNumber
JS_ParseJSON

Performs the JSON.parse operation as specified by ECMAScript.

JS_ParseJSON1

Performs the JSON.parse operation as specified by ECMAScript.

JS_ParseJSONWithReviver

Performs the JSON.parse operation as specified by ECMAScript, using the given |reviver| argument as the corresponding optional argument to that function.

JS_ParseJSONWithReviver1

Performs the JSON.parse operation as specified by ECMAScript, using the given |reviver| argument as the corresponding optional argument to that function.

JS_PreventExtensions

Attempt to make |obj| non-extensible.

JS_PutEscapedLinearString
JS_PutEscapedString
JS_ReadBytes
JS_ReadStructuredClone

Implements StructuredDeserialize and StructuredDeserializeWithTransfer.

JS_ReadTypedArray
JS_ReadUint32Pair
JS_RefreshCrossCompartmentWrappers
JS_RemoveExtraGCRootsTracer

Undo a call to JS_AddExtraGCRootsTracer.

JS_RemoveFinalizeCallback
JS_RemoveWeakPointerCompartmentCallback
JS_RemoveWeakPointerZonesCallback
JS_ReportAllocationOverflow

Complain when an allocation size overflows the maximum supported limit.

JS_ReportErrorASCII

Report an exception represented by the sprintf-like conversion of format and its arguments.

JS_ReportErrorLatin1
JS_ReportErrorNumberASCII
JS_ReportErrorNumberASCIIVA
JS_ReportErrorNumberLatin1
JS_ReportErrorNumberLatin1VA
JS_ReportErrorNumberUC
JS_ReportErrorNumberUCArray
JS_ReportErrorNumberUTF8
JS_ReportErrorNumberUTF8Array
JS_ReportErrorNumberUTF8VA
JS_ReportErrorUTF8
JS_ReportOutOfMemory

Complain when out of memory.

JS_RequestInterruptCallback
JS_RequestInterruptCallbackCanWait
JS_ResetGCParameter
JS_ResetInterruptCallback
JS_ResolveStandardClass

Resolve id, which must contain either a string or an int, to a standard class name in obj if possible, defining the class’s constructor and/or prototype and storing true in *resolved. If id does not name a standard class or a top-level property induced by initializing a standard class, store false in *resolved and just return true. Return false on error, as usual for bool result-typed API entry points.

JS_ScriptHasMutedErrors
JS_SetAllNonReservedSlotsToUndefined

Assign ‘undefined’ to all of the object’s non-reserved slots. Note: this is done for all slots, regardless of the associated property descriptor.

JS_SetCompartmentPrivate
JS_SetContextPrivate
JS_SetDestroyCompartmentCallback
JS_SetDestroyZoneCallback
JS_SetElement
JS_SetElement1
JS_SetElement2
JS_SetElement3
JS_SetElement4
JS_SetElement5
JS_SetErrorInterceptorCallback
JS_SetFutexCanWait
JS_SetGCCallback
JS_SetGCParameter
JS_SetGCParametersBasedOnAvailableMemory
JS_SetGlobalJitCompilerOption
JS_SetGrayGCRootsTracer
JS_SetICUMemoryFunctions

This function can be used to track memory used by ICU. If it is called, it must be called before JS_Init. Don’t use it unless you know what you’re doing!

JS_SetImmutablePrototype

Attempt to make the [[Prototype]] of |obj| immutable, such that any attempt to modify it will fail. If an error occurs during the attempt, return false (with a pending exception set, depending upon the nature of the error). If no error occurs, return true with |*succeeded| set to indicate whether the attempt successfully made the [[Prototype]] immutable.

JS_SetNativeStackQuota

Set the size of the native stack that should not be exceed. To disable stack size checking pass 0.

JS_SetObjectsTenuredCallback
JS_SetOffthreadIonCompilationEnabled
JS_SetParallelParsingEnabled
JS_SetPendingException
JS_SetProperty
JS_SetPropertyById

Perform the assignment obj[id] = v.

JS_SetPrototype

Change the prototype of obj.

JS_SetReservedSlot
JS_SetSecurityCallbacks
JS_SetSizeOfIncludingThisCompartmentCallback
JS_SetTrustedPrincipals
JS_SetUCProperty
JS_SetWrapObjectCallbacks
JS_SetZoneUserData
JS_ShutDown

Destroy free-standing resources allocated by SpiderMonkey, not associated with any runtime, context, or other structure.

JS_StackCapture_AllFrames
JS_StackCapture_FirstSubsumedFrame
JS_StackCapture_MaxFrames
JS_StringEqualsAscii
JS_StringEqualsAscii1
JS_StringHasBeenPinned
JS_StringIsLinear
JS_StringToId
JS_Stringify

Performs the JSON.stringify operation, as specified by ECMAScript, except writing stringified data by repeated calls of |callback|, with each such call passed |data| as argument.

JS_StructuredClone
JS_StructuredCloneHasTransferables
JS_TraceObjectGroupCycleCollectorChildren
JS_TraceShapeCycleCollectorChildren
JS_TransplantObject
JS_TypeOfValue
JS_UpdateWeakPointerAfterGC
JS_UpdateWeakPointerAfterGCUnbarriered
JS_Utf8BufferIsCompilableUnit

Given a buffer, return false if the buffer might become a valid JavaScript script with the addition of more lines, or true if the validity of such a script is conclusively known (because it’s the prefix of a valid script – and possibly the entirety of such a script).

JS_ValueIsBoolean
JS_ValueIsDouble
JS_ValueIsInt32
JS_ValueIsNull
JS_ValueIsNumber
JS_ValueIsUndefined
JS_ValueSetBoolean
JS_ValueSetDouble
JS_ValueSetInt32
JS_ValueSetNull
JS_ValueToBoolean
JS_ValueToConstructor
JS_ValueToDouble
JS_ValueToFunction
JS_ValueToId
JS_ValueToInt32
JS_ValueToNumber
JS_ValueToObject
JS_ValueToSource
JS_WrapObject
JS_WrapPropertyDescriptor
JS_WrapValue
JS_WriteBytes
JS_WriteString
JS_WriteStructuredClone

Implements StructuredSerialize, StructuredSerializeForStorage, and StructuredSerializeWithTransfer.

JS_WriteTypedArray
JS_WriteUint32Pair
JS_free

A wrapper for |js_free(p)| that may delay |js_free(p)| invocation as a performance optimization. |cx| may be nullptr.

JS_freeop

A wrapper for |js_free(p)| that may delay |js_free(p)| invocation as a performance optimization as specified by the given JSFreeOp instance.

JS_malloc
JS_realloc
JS_string_free
JS_string_malloc

Same as above, but for buffers that will be used with the BYOB (Bring Your Own Buffer) JSString creation functions, such as JS_NewLatin1String and JS_NewUCString

JS_string_realloc
JobQueueIsEmpty

Inform the runtime that the job queue is empty and the embedding is going to execute its last promise job. The runtime may now choose to skip creating promise jobs for asynchronous execution and instead continue execution synchronously. More specifically, this optimization is used to skip the standard job queuing behavior for await operations in async functions.

JobQueueMayNotBeEmpty

Inform the runtime that job queue is no longer empty. The runtime can now no longer skip creating promise jobs for asynchronous execution, because pending jobs in the job queue must be executed first to preserve the FIFO (first in - first out) property of the queue. This effectively undoes JobQueueIsEmpty and re-enables the standard job queuing behavior.

LeaveRealm
LooselyEqual

Store |v1 == v2| to |*equal| – loose equality, which may perform user-modifiable conversions on |v1| or |v2|.

LossyTwoByteCharsToNewLatin1CharsZ
LossyUTF8CharsToNewLatin1CharsZ
LossyUTF8CharsToNewTwoByteCharsZ
LossyUTF8CharsToNewTwoByteCharsZ1
MakeDate
MakeDate1
MapClear
MapDelete
MapEntries
MapForEach
MapGet
MapHas
MapKeys
MapSet
MapSize
MapValues
MaybeGetScriptPrivate

Get the script private value associated with an object, if any.

MemoryReportingSundriesThreshold

In memory reporting, we have concept of “sundries”, line items which are too small to be worth reporting individually. Under some circumstances, a memory reporter gets tossed into the sundries bucket if it’s smaller than MemoryReportingSundriesThreshold() bytes.

MinorGcToJSON
ModuleEvaluate
ModuleInstantiate
MonthFromTime
NewArrayBuffer

Create a new ArrayBuffer with the given byte length.

NewArrayBufferWithContents

Create a new ArrayBuffer with the given |contents|, which may be null only if |nbytes == 0|. |contents| must be allocated compatible with deallocation by |JS_free|.

NewArrayBufferWithUserOwnedContents

Create a new ArrayBuffer with the given non-null |contents|.

NewArrayObject

Create an Array from the current realm with the given contents.

NewArrayObject1

Create an Array from the current realm with the given length and allocate memory for all its elements. (The elements nonetheless will not exist as properties on the returned array until values have been assigned to them.)

NewDateObject
NewDateObject1

Create a new Date object for a year/month/day-of-month/hour/minute/second.

NewExternalArrayBuffer

Create a new ArrayBuffer with the given contents. The contents must not be modified by any other code, internal or external.

NewFunctionByIdWithReserved
NewFunctionFromSpec

Create a new function based on the given JSFunctionSpec, *fs. id is the result of a successful call to PropertySpecNameToId(cx, fs->name, &id) or PropertySpecNameToPermanentId(cx, fs->name, &id).

NewFunctionFromSpec1

Same as above, but without an id arg, for callers who don’t have the id already.

NewFunctionWithReserved
NewMapObject
NewMappedArrayBufferWithContents

Create a new mapped ArrayBuffer with the given memory mapped contents. It must be legal to free the contents pointer by unmapping it. On success, ownership is transferred to the new mapped ArrayBuffer.

NewPromiseObject

Returns a new instance of the Promise builtin class in the current compartment, with the right slot layout.

NewProxyObject
NewReadableDefaultStreamObject

Returns a new instance of the ReadableStream builtin class in the current compartment, configured as a default stream. If a |proto| is passed, that gets set as the instance’s [[Prototype]] instead of the original value of |ReadableStream.prototype|.

NewReadableExternalSourceStreamObject

Returns a new instance of the ReadableStream builtin class in the current compartment.

NewRegExpObject

Create a new RegExp for the given Latin-1-encoded bytes and flags.

NewSetObject
NewSymbol

Create a new Symbol with the given description. This function never returns a Symbol that is in the Runtime-wide symbol registry.

NewUCRegExpObject

Create a new RegExp for the given source and flags.

NewWeakMapObject
NonIncrementalGC

Performs a non-incremental collection of all selected zones.

NoteIntentionalCrash

Hint that we expect a crash. Currently, the only thing that cares is the breakpad injector, which (if loaded) will suppress minidump generation.

NotifyAnimationActivity
NotifyGCRootsRemoved
NukeCrossCompartmentWrappers
NukeNonCCWProxy
NukeRemovedCrossCompartmentWrapper
NukedObjectRealm
NumberToString

Store in |out| the null-terminated, base-10 result of |ToString| applied to |d| per https://tc39.es/ecma262/#sec-tostring-applied-to-the-number-type. (This will produce “NaN”, “-Infinity”, or “Infinity” for non-finite |d|.)

ObjectIsDate

On success, returns true, setting |*isDate| to true if |obj| is a Date object or a wrapper around one, or to false if not. Returns false on failure.

ObjectIsRegExp

On success, returns true, setting |*isRegExp| to true if |obj| is a RegExp object or a wrapper around one, or to false if not. Returns false on failure.

ObjectToCompletePropertyDescriptor
OrdinaryHasInstance
OrdinaryToPrimitive

ES6 draft 20141224, 7.1.1, second algorithm.

PeakSizeOfTemporary
PrepareForFullGC

Schedule all zones to be collected in the next GC.

PrepareForIncrementalGC

When performing an incremental GC, the zones that were selected for the previous incremental slice must be selected in subsequent slices as well. This function selects those slices automatically.

PrepareScriptEnvironmentAndInvoke
PrepareZoneForGC

Schedule the given zone to be collected as part of the next GC.

PrintError
PrintError1
PropertySpecNameEqualsId
PropertySpecNameToPermanentId

Create a jsid that does not need to be marked for GC.

ProtoKeyToClass
ProtoKeyToId
PurgePCCounts
ReadableStreamCancel

Cancels the given ReadableStream with the given reason and returns a Promise resolved according to the result.

ReadableStreamClose

Close the given ReadableStream. This is equivalent to controller.close() in JS.

ReadableStreamDefaultReaderRead

C++ equivalent of the reader.read() method on default readers (https://streams.spec.whatwg.org/#default-reader-read).

ReadableStreamEnqueue

Enqueues the given chunk in the given ReadableStream.

ReadableStreamError

Errors the given ReadableStream, causing all future interactions to fail with the given error value.

ReadableStreamGetDesiredSize

Retrieves the desired combined size of additional chunks to fill the given ReadableStream’s queue. Stores the result in |value| and sets |hasValue| to true on success, returns false on failure.

ReadableStreamGetExternalUnderlyingSource

Returns the embedding-provided underlying source of the given |stream|.

ReadableStreamGetMode

Returns the stream’s ReadableStreamMode. If the mode is |Byte| or |ExternalSource|, it’s possible to acquire a BYOB reader for more optimized operations.

ReadableStreamGetReader

Creates a reader of the type specified by the mode option and locks the stream to the new reader.

ReadableStreamIsDisturbed

Returns true if the given ReadableStream is disturbed, false if not.

ReadableStreamIsLocked

Returns true if the given ReadableStream is locked, false if not.

ReadableStreamIsReadable

Returns true if the given ReadableStream is readable, false if not.

ReadableStreamReaderCancel

C++ equivalent of reader.cancel(reason) (both https://streams.spec.whatwg.org/#default-reader-cancel and https://streams.spec.whatwg.org/#byob-reader-cancel).

ReadableStreamReaderIsClosed

Returns true if the given ReadableStream reader is locked, false otherwise.

ReadableStreamReaderReleaseLock

C++ equivalent of reader.releaseLock() (both https://streams.spec.whatwg.org/#default-reader-release-lock and https://streams.spec.whatwg.org/#byob-reader-release-lock).

ReadableStreamReleaseCCObject

Break the cycle between this object and the nsISupportsObject_alreadyAddreffed passed in NewReadableExternalSourceStreamObject().

ReadableStreamReleaseExternalUnderlyingSource

Releases the embedding-provided underlying source of the given |stream|, returning the stream into an unlocked state.

ReadableStreamTee

Tees the given ReadableStream and stores the two resulting streams in outparams. Returns false if the operation fails, e.g. because the stream is locked.

ReadableStreamUpdateDataAvailableFromSource

Update the amount of data available at the underlying source of the given |stream|.

RealmBehaviorsRef
RealmBehaviorsRef1
RealmCreationOptionsRef
RealmCreationOptionsRef1
RegisterContextProfilingEventMarker
RejectPromise

Rejects the given promise with the given rejectionValue.

ReleaseMappedArrayBufferContents

Release the allocated resource of mapped ArrayBuffer contents before the object is created. If a new object has been created by JS::NewMappedArrayBufferWithContents() with this content, then JS::DetachArrayBuffer() should be used instead to release the resource used by the object.

RemapRemoteWindowProxies
RemoveAssociatedMemory

Advise the GC that external memory reported by JS::AddAssociatedMemory() is no longer owned by a JSObject. Calls must match those to AddAssociatedMemory().

RemoveRawValueRoot
RenewProxyObject
ReportBadValueTypeAndCrash
ReportIsNotFunction
ReportOutOfMemory
ReportSourceTooLong
ResetTimeZone

Re-query the system to determine the current time zone adjustment from UTC, including any component due to DST. If the time zone has changed, this will cause all Date object non-UTC methods and formatting functions to produce appropriately adjusted results.

ResolvePromise

Resolves the given Promise with the given resolutionValue.

RunIdleTimeGCTask
RunJobs
RuntimeHeapState
SameValue

Stores |SameValue(v1, v2)| to |*equal| – using the SameValue operation defined in ECMAScript, initially exposed to script as |Object.is|. SameValue behaves identically to strict equality, except that it equates two NaN values and does not equate differently-signed zeroes. It performs no conversions on |v1| or |v2| before comparing.

SetAdd
SetAllocationMetadataBuilder

Specify a callback to invoke when creating each JS object in the current compartment, which may return a metadata object to associate with the object.

SetArrayLength

Perform |obj.length = length| as if in strict mode code, with a fast path for the case where |obj| is an Array.

SetClear
SetContextProfilingStack
SetDOMCallbacks
SetDOMProxyInformation
SetDelete
SetDestroyRealmCallback
SetDoCycleCollectionCallback

The purge gray callback is called after any COMPARTMENT_REVIVED GC in which the majority of compartments have been marked gray.

SetEntries
SetFilenameValidationCallback
SetForEach
SetFunctionNativeReserved
SetGCNurseryCollectionCallback

Set the nursery collection callback for the given runtime. When set, it will be called at the start and end of every nursery collection.

SetGCSliceCallback

The GC slice callback is called at the beginning and end of each slice. This callback may be used for GC notifications as well as to perform additional marking.

SetGetElementCallback
SetHas
SetHostCleanupFinalizationRegistryCallback
SetJobQueue

Tell SpiderMonkey to use queue to schedule promise reactions.

SetKeys
SetLargeArrayBuffersEnabled

Enable or disable support for large (>= 2 GB) ArrayBuffers on 64-bit builds. Has no effect on 32-bit builds.

SetLowMemoryState
SetModuleDynamicImportHook

Set the HostImportModuleDynamically hook for the runtime to the given function.

SetModuleMetadataHook

Set the hook for populating the import.meta metadata object to the given function.

SetModulePrivate

Set a private value associated with a source text module record.

SetModuleResolveHook

Set the HostResolveImportedModule hook for the runtime to the given function.

SetOutOfMemoryCallback
SetPendingExceptionStack
SetPreserveWrapperCallbacks
SetPrivate

Set the private value for |obj|.

SetProcessBuildIdOp

Embedder hook to set the buildId-generating function.

SetProcessLargeAllocationFailureCallback
SetProfileTimelineRecordingEnabled

Tell JS engine whether Profile Timeline Recording is enabled or not. If Profile Timeline Recording is enabled, data shown there like stack won’t be optimized out. This is global state and not associated with specific runtime or context.

SetProfilingThreadCallbacks
SetPromiseRejectionTrackerCallback

Sets the callback that’s invoked whenever a Promise is rejected without a rejection handler, and when a Promise that was previously rejected without a handler gets a handler attached.

SetPromiseUserInputEventHandlingState

Sets the given Promise’s activation behavior state flag per above as a JS::PromiseUserInputEventHandlingState value.

SetPropertyIgnoringNamedGetter

Helper function for HTMLDocument and HTMLFormElement.

SetRealmNameCallback
SetRealmNonLive
SetRealmPrincipals
SetRealmPrivate
SetReduceMicrosecondTimePrecisionCallback
SetRegExpInput
SetReservedSlotWithBarrier
SetScriptEnvironmentPreparer
SetScriptPrivate

Set a private value associated with a script. Note that this value is shared by all nested scripts compiled from a single source file.

SetScriptPrivateReferenceHooks

Set the script private finalize hook for the runtime to the given function.

SetSettledPromiseIsHandled
SetSize
SetStackFormat
SetTimeResolutionUsec
SetUseOffThreadParseGlobal
SetValueInProxy
SetValues
SetWaitCallback
SetWarningReporter
SetWeakMapEntry
SetWindowProxy

Associates a WindowProxy with a Window (global object). windowProxy must have the Class set by SetWindowProxyClass.

SetWindowProxyClass

Tell the JS engine which Class is used for WindowProxy objects. Used by the functions below.

ShouldIgnorePropertyDefinition
ShutDownMallocAllocator
ShutdownAsyncTasks

When a JSRuntime is destroyed it implicitly cancels all async tasks in progress, releasing any roots held by the task. However, this is not soon enough for cycle collection, which needs to have roots dropped earlier so that the cycle collector can transitively remove roots for a future GC. For these and other cases, the set of pending async tasks can be canceled with this call earlier than JSRuntime destruction.

SkipZoneForGC

Undoes the effect of the Prepare methods above. The given zone will not be collected in the next GC.

StartIncrementalGC

Begin an incremental collection and perform one slice worth of work. When this function returns, the collection may not be complete. IncrementalGCSlice() must be called repeatedly until !IsIncrementalGCInProgress(cx).

StartPCCountProfiling
StealArrayBufferContents

Steal the contents of the given ArrayBuffer. The ArrayBuffer has its length set to 0 and its contents array cleared. The caller takes ownership of the return value and must free it or transfer ownership via JS::NewArrayBufferWithContents when done using it.

StealPendingExceptionStack
StopDrainingJobQueue

Instruct the runtime to stop draining the internal job queue.

StopPCCountProfiling
StrictlyEqual

Store |v1 === v2| to |*equal| – strict equality, which performs no conversions on |v1| or |v2| before comparing.

StringIsASCII
StringIsASCII1
StringIsArrayIndex

Determine whether the given string is an array index in the sense of https://tc39.github.io/ecma262/#array-index.

StringIsArrayIndex1

Overload of StringIsArrayIndex taking a (char16_t*,length) pair. Behaves the same as the JSLinearString version.

StringToLinearStringSlow
SystemCompartmentCount
SystemRealmCount
ThrowOnModuleEvaluationFailure
ToBooleanSlow
ToInt8Slow
ToInt16Slow
ToInt32Slow
ToInt64Slow
ToJSONMaybeSafely

An API akin to JS_Stringify but with the goal of not having observable side-effects when the stringification is performed. This means it does not allow a replacer or a custom space and has the following constraints on its input:

ToNumberSlow
ToObjectSlow
ToPrimitive

Convert obj to a primitive value. On success, store the result in vp and return true.

ToStringSlow
ToUint8Slow
ToUint16Slow
ToUint32Slow
ToUint64Slow
ToWindowIfWindowProxy

If obj is a WindowProxy, get its associated Window (the compartment’s global), else return obj. This function is infallible and never returns nullptr.

ToWindowProxyIfWindowSlow
TraceChildren
TraceGrayWrapperTargets
TraceValueArray
TraceWeakMaps
UTF8CharsToNewLatin1CharsZ
UTF8CharsToNewTwoByteCharsZ
UTF8CharsToNewTwoByteCharsZ1
Unbox
UnhideScriptedCaller
UninlinedIsCrossCompartmentWrapper
UnmarkGrayGCThingRecursively

Unsets the gray bit for anything reachable from |thing|. |kind| should not be JS::TraceKind::Shape. |thing| should be non-null. The return value indicates if anything was unmarked.

UnsafeTraceManuallyBarrieredEdge
UnsafeTraceRoot
UnsafeTraceRoot1
UnsafeTraceRoot2
UnsafeTraceRoot3
UnsafeTraceRoot4
UnsafeTraceRoot5
UnsafeTraceRoot6
UnsafeTraceRoot7
UnsafeTraceRoot8
UnsafeTraceRoot9
UnsafeTraceRoot10
UnsafeTraceRoot11
UnwrapArrayBuffer
UnwrapArrayBufferView
UnwrapBigInt64Array
UnwrapBigUint64Array
UnwrapFloat32Array
UnwrapFloat64Array
UnwrapInt8Array
UnwrapInt16Array
UnwrapInt32Array
UnwrapReadableStream
UnwrapUint8Array
UnwrapUint8ClampedArray
UnwrapUint16Array
UnwrapUint32Array
UseInternalJobQueues

Use the runtime’s internal handling of job queues for Promise jobs.

UseOffThreadParseGlobal
UserCompartmentCount
UserRealmCount
Utf8ToOneUcs4Char
WarnASCII

Report a warning represented by the sprintf-like conversion of ASCII format filled from trailing ASCII arguments.

WarnLatin1

Report a warning represented by the sprintf-like conversion of Latin-1 format filled from trailing Latin-1 arguments.

WarnUTF8

Report a warning represented by the sprintf-like conversion of UTF-8 format filled from trailing UTF-8 arguments.

WasIncrementalGC

Returns true if the most recent GC ran incrementally.

YearFromTime
ZoneGlobalsAreAllGray
ZoneIsCollecting

Type Definitions

AbortSignalIsAborted

The signature of a function that, when passed an |AbortSignal| instance, will return the value of its “aborted” flag.

AfterWaitCallback
AutoEnterOOMUnsafeRegion_AnnotateOOMAllocationSizeCallback
AutoEnterPolicy_Action
AutoRooterListHeads
BaseProxyHandler_Action
BeforeWaitCallback
BufferContentsFreeFunc
BuildIdCharVector

Vector of characters used for holding build ids.

BuildIdOp

Return the buildId (represented as a sequence of characters) associated with the currently-executing build. If the JS engine is embedded such that a single cache entry can be observed by different compiled versions of the JS engine, it is critical that the buildId shall change for each new build of the JS engine.

CanTransferStructuredCloneOp

Called when the transferring objects are checked. If this function returns false, the serialization ends throwing a DataCloneError exception.

ClassObjectCreationOp

Callback for the creation of constructor and prototype objects.

ConstCharPtr
ConstLatin1Chars_Base
ConstLatin1Chars_CharT
ConstTwoByteChars_Base
ConstTwoByteChars_CharT
ConstUTF8CharsZ_CharT
ConsumeStreamCallback
DOMCallbacks
DOMInstanceClassHasProtoAtDepth
DOMProxyShadowsCheck
DefaultHasher
DefinePropertyOp
DeletePropertyOp
DestroyRealmCallback
DispatchToEventLoopCallback

Callback to dispatch a JS::Dispatchable to a JSContext’s thread’s event loop.

DoCycleCollectionCallback
FILE
FilenameValidationCallback

Install a process-wide callback to validate script filenames. The JS engine will invoke this callback for each JS script it parses or XDR decodes.

FinishClassInitOp

Callback for custom post-processing after class initialization via ClassSpec.

FreeTransferStructuredCloneOp

Called when freeing an unknown transferable object. Note that it should never trigger a garbage collection (and will assert in a debug build if it does.)

GCNurseryCollectionCallback

A nursery collection callback receives the progress of the nursery collection and the reason for the collection.

GCSliceCallback
GCVector_ElementType
GetElementsOp
GetOwnPropertyOp
GetPropertyOp
HandleBigInt
HandleFunction
HandleId
HandleIdVector
HandleObject
HandleScript
HandleString
HandleSymbol
HandleValue
HandleValueVector
Handle_ElementType
HasPropertyOp
HasReleasedWrapperCallback
HashMap
HashNumber
HashSet
Heap
Heap_ElementType
IdVector
InefficientNonFlatteningStringHashPolicy_Lookup
IsAcceptableThis
IterateGCThingCallback
IterateRealmCallback
JSAddPropertyOp

Add a property named by id to obj.

JSCSPEvalChecker
JSConstDoubleSpec
JSConstIntegerSpec
JSDeletePropertyOp

Delete a property named by id in obj.

JSDestroyCompartmentCallback
JSDestroyPrincipalsOp
JSDestroyZoneCallback
JSEnumerateOp

The old-style JSClass.enumerate op should define all lazy properties not yet reflected in obj.

JSErrorCallback
JSErrorNotes_iterator_difference_type
JSErrorNotes_iterator_iterator_category
JSErrorNotes_iterator_pointer
JSErrorNotes_iterator_reference
JSErrorNotes_iterator_value_type
JSFinalizeCallback
JSFinalizeOp

Finalize obj, which the garbage collector has determined to be unreachable from other live objects or from GC roots. Obviously, finalizers must never store a reference to obj.

JSFunToStringOp

The type of ObjectOps::funToString. This callback allows an object to provide a custom string to use when Function.prototype.toString is invoked on that object. A null return value means OOM.

JSFunctionSpec_Name
JSGCCallback
JSGetElementCallback
JSGetterOp

Get a property named by id in obj. Note the jsid id type – id may be a string (Unicode property identifier) or an int (element index). The *vp out parameter, on success, is the new property value after the action.

JSHasInstanceOp

Check whether v is an instance of obj. Return false on error or exception, true on success with true in *bp if v is an instance of obj, false in *bp otherwise.

JSHostCleanupFinalizationRegistryCallback
JSInterruptCallback
JSIterateCompartmentCallback
JSJitGetterOp
JSJitMethodCallArgs_Base
JSJitMethodOp
JSJitSetterOp
JSMayResolveOp

A class with a resolve hook can optionally have a mayResolve hook. This hook must have no side effects and must return true for a given id if the resolve hook may resolve this id. This is useful when we’re doing a “pure” lookup: if mayResolve returns false, we know we don’t have to call the effectful resolve hook.

JSNative
JSNewEnumerateOp

The type of ObjectOps::enumerate. This callback overrides a portion of SpiderMonkey’s default [[Enumerate]] internal method. When an ordinary object is enumerated, that object and each object on its prototype chain is tested for an enumerate op, and those ops are called in order. The properties each op adds to the ‘properties’ vector are added to the set of values the for-in loop will iterate over. All of this is nonstandard.

JSONWriteCallback
JSObjectMovedOp
JSObjectsTenuredCallback
JSPreWrapCallback

Callback used by the wrap hook to ask the embedding to prepare an object for wrapping in a context. This might include unwrapping other wrappers or even finding a more suitable object for the new compartment. If |origObj| is non-null, then it is the original object we are going to swap into during a transplant.

JSReadPrincipalsOp
JSResolveOp

Resolve a lazy property named by id in obj by defining it directly in obj. Lazy properties are those reflected from some peer native property space (e.g., the DOM attributes for a given node reflected as obj) on demand.

JSSetterOp

Set a property named by id in obj, treating the assignment as strict mode code if strict is true. Note the jsid id type – id may be a string (Unicode property identifier) or an int (element index).

JSSizeOfIncludingThisCompartmentCallback
JSStructuredCloneData_BufferList
JSStructuredCloneData_Iterator
JSSubsumesOp
JSTraceDataOp
JSTraceOp

Function type for trace operation of the class called to enumerate all traceable things reachable from obj’s private data structure. For each such thing, a trace implementation must call JS::TraceEdge on the thing’s location.

JSWeakPointerCompartmentCallback
JSWeakPointerZonesCallback
JSWrapObjectCallback

Callback used to ask the embedding for the cross compartment wrapper handler that implements the desired prolicy for this kind of object in the destination compartment. |obj| is the object to be wrapped. If |existing| is non-nullptr, it will point to an existing wrapper object that should be re-used if possible. |existing| is guaranteed to be a cross-compartment wrapper with a lazily-defined prototype and the correct global. It is guaranteed not to wrap a function.

JS_ICUAllocFn
JS_ICUFreeFn
JS_ICUReallocFn
LargeAllocationFailureCallback

If a large allocation fails when calling pod_{calloc,realloc}CanGC, the JS engine may call the large-allocation-failure callback, if set, to allow the embedding to flush caches, possibly perform shrinking GCs, etc. to make some room. The allocation will then be retried (and may still fail.) This callback can be called on any thread and must be set at most once in a process.

Latin1Char
Latin1CharsZ_Base
Latin1CharsZ_CharT
Latin1Chars_Base
Latin1Chars_CharT
LookupPropertyOp
MallocSizeOf
ModuleDynamicImportHook
ModuleMetadataHook
ModuleResolveHook
MovableCellHasher_Key
MovableCellHasher_Lookup
MozExternalRefCountType
MozRefCountType

MozRefCountType is Mozilla’s reference count type.

MutableHandleBigInt
MutableHandleFunction
MutableHandleId
MutableHandleObject
MutableHandleScript
MutableHandleString
MutableHandleSymbol
MutableHandleValue
MutableHandleValueVector
MutableHandle_ElementType
NativeImpl
ObjectPrivateVisitor_GetISupportsFun
OffThreadCompileCallback
OptimizedEncodingBytes

The ConsumeStreamCallback is called from an active JSContext, passing a StreamConsumer that wishes to consume the given host object as a stream of bytes with the given MIME type. On failure, the embedding must report the appropriate error on ‘cx’. On success, the embedding must call consumer->consumeChunk() repeatedly on any thread until exactly one of:

OutOfMemoryCallback

Unlike the error reporter, which is only called if the exception for an OOM bubbles up and is not caught, the OutOfMemoryCallback is called immediately at the OOM site to allow the embedding to capture the current state of heap allocation before anything is freed. If the large-allocation-failure callback is called at all (not all allocation sites call the large-allocation-failure callback on failure), it is called before the out-of-memory callback; the out-of-memory callback is only called if the allocation still fails after the large-allocation-failure callback has returned.

OverloadSelector
PersistentRootedBigInt
PersistentRootedFunction
PersistentRootedId
PersistentRootedIdVector
PersistentRootedObject
PersistentRootedObjectVector
PersistentRootedScript
PersistentRootedString
PersistentRootedSymbol
PersistentRootedValue
PersistentRootedVector_Base
PersistentRootedVector_Vec
PersistentRooted_ElementType
PersistentRooted_ListBase
PersistentRooted_Ptr
PersistentRooted_PtrTraits
PointerHasher
PreserveWrapperCallback
PromiseRejectionTrackerCallback
ReadStructuredCloneOp

Read structured data from the reader r. This hook is used to read a value previously serialized by a call to the WriteStructuredCloneOp hook.

ReadTransferStructuredCloneOp

This is called when JS_ReadStructuredClone receives a transferable object not known to the engine. If this hook does not exist or returns false, the JS engine calls the reportError op if set, otherwise it throws a DATA_CLONE_ERR DOM Exception. This method is called before any other callback and must return a non-null object in returnObject on success.

RealmNameCallback
RealmStatsVector
RealmStats_ClassesHashMap
ReduceMicrosecondTimePrecisionCallback
RefPtr_Proxy_member_function
RefPtr_element_type
RegExpFlags_Flag
RegisterThreadCallback
ReportStreamErrorCallback
Result

Result is intended to be the return type of JSAPI calls and internal functions that can run JS code or allocate memory from the JS GC heap. Such functions can:

Rooted
RootedBigInt
RootedFunction
RootedId
RootedListHeads
RootedObject
RootedPtr
RootedPtrTraits
RootedScript
RootedString
RootedSymbol
RootedValue
RootedVector_Base
RootedVector_Vec
Rooted_ElementType
Rooted_Ptr
Rooted_PtrTraits
RuntimeSizes_ScriptSourcesHashMap
ScriptPrivateReferenceHook

Hooks called when references to a script private value are created or destroyed. This allows use of a reference counted object as the script private.

ScriptVector
SetPropertyOp
SharedArrayBufferClonedOp

Called when a SharedArrayBuffer (including one owned by a Wasm memory object) has been processed in context cx by structured cloning. If receiving is true then the SAB has been received from a channel and a new SAB object has been created; if false then an existing SAB has been serialized onto a channel.

SourceText_CharT
StackCapture
StackGCVector_Base
StringVector
StructuredCloneErrorOp

This is called when JS_WriteStructuredClone is given an invalid transferable. To follow HTML5, the application must throw a DATA_CLONE_ERR DOMException with error set to one of the JS_SCERR_* values.

TenuredHeap_ElementType
TranscodeBuffer
TranscodeRange
TranscodeSources
TransferStructuredCloneOp

Called when JS_WriteStructuredClone receives a transferable object not handled by the engine. If this hook does not exist or returns false, the JS engine will call the reportError hook or fall back to throwing a DATA_CLONE_ERR DOM Exception. This method is called before any other callback.

TwoByteCharsZ_Base
TwoByteCharsZ_CharT
TwoByteChars_Base
TwoByteChars_CharT
UTF8CharsZ_Base
UTF8CharsZ_CharT
UTF8Chars_Base
UTF8Chars_CharT
UniqueChars
UniqueLatin1Chars
UniqueOptimizedEncodingBytes
UniquePtr
UniqueSelector_SingleObject
UniqueTwoByteChars
UnregisterThreadCallback
UnusedZero_StorageType
ValueVector
Value_PayloadType
Vector
WarningReporter
WriteStructuredCloneOp

Structured data serialization hook. The engine can write primitive values, Objects, Arrays, Dates, RegExps, TypedArrays, ArrayBuffers, Sets, Maps, and SharedTypedArrays. Any other type of object requires application support. This callback must first use the JS_WriteUint32Pair API to write an object header, passing a value greater than JS_SCTAG_USER to the tag parameter. Then it can use the JS_Write* APIs to write any other relevant parts of the value v to the writer w. closure is any value passed to the JS_WriteStructuredClone function.

ZoneStatsVector
ZoneStats_StringsHashMap
_IO_lock_t
__builtin_va_list
__int8_t
__int16_t
__int32_t
__int64_t
__off64_t
__off_t
__uint8_t
__uint16_t
__uint32_t
__uint64_t
arena_id_t
jsbytecode
jsid
uint_fast8_t
va_list

Unions

JSJitInfo__bindgen_ty_1
JSJitInfo__bindgen_ty_2
JSJitInfo__bindgen_ty_3
JSPropertySpec_Accessor
JSPropertySpec_AccessorsOrValue
JSPropertySpec_Name
JSPropertySpec_ValueWrapper__bindgen_ty_1
PropertyResult__bindgen_ty_1
RealmCreationOptions__bindgen_ty_1