kotlin-web/web.assembly

Package-level declarations

Types

AddressType

sealed interface AddressType

AddressValue

typealias AddressValue = Int

CompileError

class CompileError(message: String = definedExternally) : JsError

Exception

open class Exception(exceptionTag: Tag, payload: ReadonlyArray<*>, options: ExceptionOptions = definedExternally)

The WebAssembly.Exception object represents a runtime exception thrown from WebAssembly to JavaScript, or thrown from JavaScript to a WebAssembly exception handler.

ExceptionOptions

interface ExceptionOptions

Exports

typealias Exports = ReadonlyRecord<JsString, ExportValue>

ExportValue

typealias ExportValue = JsAny

Global

open class Global<T : JsAny?>(descriptor: GlobalDescriptor<T>, v: T = definedExternally)

A WebAssembly.Global object represents a global variable instance, accessible from both JavaScript and importable/exportable across one or more WebAssembly.Module instances. This allows dynamic linking of multiple modules.

GlobalDescriptor

interface GlobalDescriptor<T : JsAny?>

ImportExportKind

sealed interface ImportExportKind

Imports

typealias Imports = ReadonlyRecord<JsString, ModuleImports>

ImportValue

typealias ImportValue = JsAny

Instance

open class Instance(module: Module, importObject: Imports = definedExternally)

A WebAssembly.Instance object is a stateful, executable instance of a WebAssembly.Module. Instance objects contain all the Exported WebAssembly functions that allow calling into WebAssembly code from JavaScript.

LinkError

class LinkError(message: String = definedExternally) : JsError

Memory

open class Memory(descriptor: MemoryDescriptor)

The WebAssembly.Memory object is a resizable ArrayBuffer or SharedArrayBuffer that holds raw bytes of memory accessed by a WebAssembly.Instance.

MemoryDescriptor

interface MemoryDescriptor

Module

open class Module(bytes: BufferSource, options: WebAssemblyCompileOptions = definedExternally)

A WebAssembly.Module object contains stateless WebAssembly code that has already been compiled by the browser — this can be efficiently shared with Workers, and instantiated multiple times.

ModuleExportDescriptor

interface ModuleExportDescriptor

ModuleImportDescriptor

interface ModuleImportDescriptor

ModuleImports

typealias ModuleImports = ReadonlyRecord<JsString, ImportValue>

RuntimeError

class RuntimeError(message: String = definedExternally) : JsError

Table

open class Table(descriptor: TableDescriptor, value: JsAny? = definedExternally)

The WebAssembly.Table object is a JavaScript wrapper object — an array-like structure representing a WebAssembly table, which stores homogeneous references. A table created by JavaScript or in WebAssembly code will be accessible and mutable from both JavaScript and WebAssembly.

TableDescriptor

interface TableDescriptor

TableKind

sealed interface TableKind

Tag

open class Tag(type: TagType)

The WebAssembly.Tag object defines a type of a WebAssembly exception that can be thrown to/from WebAssembly code.

TagType

interface TagType

ValueType

sealed interface ValueType<T : JsAny?>

WebAssemblyCompileOptions

interface WebAssemblyCompileOptions

WebAssemblyInstantiatedSource

interface WebAssemblyInstantiatedSource

Properties

anyfunc

val TableKind.Companion.anyfunc: TableKind

val ValueType.Companion.anyfunc: ValueType<JsFunction<*, *>>

externref

val TableKind.Companion.externref: TableKind

val ValueType.Companion.externref: ValueType<JsAny?>

f32

val ValueType.Companion.f32: ValueType<JsFloat>

f64

val ValueType.Companion.f64: ValueType<JsDouble>

function

val ImportExportKind.Companion.function: ImportExportKind

global

val ImportExportKind.Companion.global: ImportExportKind

i32

val AddressType.Companion.i32: AddressType

val ValueType.Companion.i32: ValueType<JsInt>

i64

val AddressType.Companion.i64: AddressType

val ValueType.Companion.i64: ValueType<BigInt>

JSTag

external val JSTag: Tag

memory

val ImportExportKind.Companion.memory: ImportExportKind

table

val ImportExportKind.Companion.table: ImportExportKind

tag

val ImportExportKind.Companion.tag: ImportExportKind

v128

val ValueType.Companion.v128: ValueType<Void?>

Functions

compile

inline suspend fun compile(bytes: BufferSource): Module

inline suspend fun compile(bytes: BufferSource, options: WebAssemblyCompileOptions?): Module

compileAsync

external fun compileAsync(bytes: BufferSource, options: WebAssemblyCompileOptions? = definedExternally): Promise<Module>

MDN Reference

compileStreaming

inline suspend fun compileStreaming(source: PromiseLike<Response>): Module

inline suspend fun compileStreaming(source: Response): Module

inline suspend fun compileStreaming(source: PromiseLike<Response>, options: WebAssemblyCompileOptions?): Module

inline suspend fun compileStreaming(source: Response, options: WebAssemblyCompileOptions?): Module

compileStreamingAsync

external fun compileStreamingAsync(source: PromiseLike<Response>, options: WebAssemblyCompileOptions? = definedExternally): Promise<Module>

external fun compileStreamingAsync(source: Response, options: WebAssemblyCompileOptions? = definedExternally): Promise<Module>

MDN Reference

instantiate

inline suspend fun instantiate(bytes: BufferSource): WebAssemblyInstantiatedSource

inline suspend fun instantiate(moduleObject: Module): Instance

inline suspend fun instantiate(bytes: BufferSource, importObject: Imports): WebAssemblyInstantiatedSource

inline suspend fun instantiate(moduleObject: Module, importObject: Imports): Instance

inline suspend fun instantiate(bytes: BufferSource, importObject: Imports, options: WebAssemblyCompileOptions?): WebAssemblyInstantiatedSource

instantiateAsync

external fun instantiateAsync(moduleObject: Module, importObject: Imports = definedExternally): Promise<Instance>

external fun instantiateAsync(bytes: BufferSource, importObject: Imports = definedExternally, options: WebAssemblyCompileOptions? = definedExternally): Promise<WebAssemblyInstantiatedSource>

MDN Reference

instantiateStreaming

inline suspend fun instantiateStreaming(source: PromiseLike<Response>): WebAssemblyInstantiatedSource

inline suspend fun instantiateStreaming(source: Response): WebAssemblyInstantiatedSource

inline suspend fun instantiateStreaming(source: PromiseLike<Response>, importObject: Imports): WebAssemblyInstantiatedSource

inline suspend fun instantiateStreaming(source: Response, importObject: Imports): WebAssemblyInstantiatedSource

inline suspend fun instantiateStreaming(source: PromiseLike<Response>, importObject: Imports, options: WebAssemblyCompileOptions?): WebAssemblyInstantiatedSource

inline suspend fun instantiateStreaming(source: Response, importObject: Imports, options: WebAssemblyCompileOptions?): WebAssemblyInstantiatedSource

instantiateStreamingAsync

external fun instantiateStreamingAsync(source: PromiseLike<Response>, importObject: Imports = definedExternally, options: WebAssemblyCompileOptions? = definedExternally): Promise<WebAssemblyInstantiatedSource>

external fun instantiateStreamingAsync(source: Response, importObject: Imports = definedExternally, options: WebAssemblyCompileOptions? = definedExternally): Promise<WebAssemblyInstantiatedSource>

MDN Reference

validate

external fun validate(bytes: BufferSource, options: WebAssemblyCompileOptions? = definedExternally): Boolean

MDN Reference