1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into webref
// (https://github.com/w3c/webref)
// Source: WebAssembly JavaScript Interface (https://webassembly.github.io/spec/js-api/)
dictionary WebAssemblyInstantiatedSource {
required Module module;
required Instance instance;
};
dictionary WebAssemblyCompileOptions {
USVString? importedStringConstants;
sequence<USVString> builtins;
};
[Exposed=*]
namespace WebAssembly {
boolean validate(BufferSource bytes, optional WebAssemblyCompileOptions options = {});
Promise<Module> compile(BufferSource bytes, optional WebAssemblyCompileOptions options = {});
Promise<WebAssemblyInstantiatedSource> instantiate(
BufferSource bytes, optional object importObject, optional WebAssemblyCompileOptions options = {});
Promise<Instance> instantiate(
Module moduleObject, optional object importObject);
readonly attribute Tag JSTag;
};
enum ImportExportKind {
"function",
"table",
"memory",
"global",
"tag"
};
enum AddressType {
"i32",
"i64",
};
typedef any AddressValue;
dictionary ModuleExportDescriptor {
required USVString name;
required ImportExportKind kind;
// Note: Other fields such as signature may be added in the future.
};
dictionary ModuleImportDescriptor {
required USVString module;
required USVString name;
required ImportExportKind kind;
};
[LegacyNamespace=WebAssembly, Exposed=*]
interface Module {
constructor(BufferSource bytes, optional WebAssemblyCompileOptions options = {});
static sequence<ModuleExportDescriptor> exports(Module moduleObject);
static sequence<ModuleImportDescriptor> imports(Module moduleObject);
static sequence<ArrayBuffer> customSections(Module moduleObject, DOMString sectionName);
};
[LegacyNamespace=WebAssembly, Exposed=*]
interface Instance {
constructor(Module module, optional object importObject);
readonly attribute object exports;
};
dictionary MemoryDescriptor {
required AddressValue initial;
AddressValue maximum;
AddressType address;
};
[LegacyNamespace=WebAssembly, Exposed=*]
interface Memory {
constructor(MemoryDescriptor descriptor);
AddressValue grow(AddressValue delta);
ArrayBuffer toFixedLengthBuffer();
ArrayBuffer toResizableBuffer();
readonly attribute ArrayBuffer buffer;
};
enum TableKind {
"externref",
"anyfunc",
// Note: More values may be added in future iterations,
// e.g., typed function references, typed GC references
};
dictionary TableDescriptor {
required TableKind element;
required AddressValue initial;
AddressValue maximum;
AddressType address;
};
[LegacyNamespace=WebAssembly, Exposed=*]
interface Table {
constructor(TableDescriptor descriptor, optional any value);
AddressValue grow(AddressValue delta, optional any value);
any get(AddressValue index);
undefined set(AddressValue index, optional any value);
readonly attribute AddressValue length;
};
enum ValueType {
"i32",
"i64",
"f32",
"f64",
"v128",
"externref",
"anyfunc",
};
dictionary GlobalDescriptor {
required ValueType value;
boolean mutable = false;
};
[LegacyNamespace=WebAssembly, Exposed=*]
interface Global {
constructor(GlobalDescriptor descriptor, optional any v);
any valueOf();
attribute any value;
};
dictionary TagType {
required sequence<ValueType> parameters;
};
[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
interface Tag {
constructor(TagType type);
};
dictionary ExceptionOptions {
boolean traceStack = false;
};
[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
interface Exception {
constructor(Tag exceptionTag, sequence<any> payload, optional ExceptionOptions options = {});
any getArg([EnforceRange] unsigned long index);
boolean is(Tag exceptionTag);
readonly attribute (DOMString or undefined) stack;
};
|
