@almadar/kernel 18.0.0 → 19.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +27 -7
- package/pkg/orbital_wasm.d.ts +431 -15
- package/pkg/orbital_wasm.js +4198 -391
- package/pkg/orbital_wasm_bg.wasm +0 -0
- package/pkg/orbital_wasm_bg.wasm.d.ts +158 -8
- package/pkg-client/orbital_wasm.d.ts +549 -0
- package/pkg-client/orbital_wasm.js +4634 -0
- package/pkg-client/orbital_wasm_bg.wasm +0 -0
- package/pkg-client/orbital_wasm_bg.wasm.d.ts +195 -0
package/pkg/orbital_wasm.js
CHANGED
|
@@ -1,313 +1,319 @@
|
|
|
1
1
|
/* @ts-self-types="./orbital_wasm.d.ts" */
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
/**
|
|
4
|
+
* The encrypted credential store for a host whose rows answer asynchronously: the host lists its rows and `load`s them,
|
|
5
|
+
* runs an operation, then applies `takeWrites()` to its medium in order. See `credentials::VaultApi`.
|
|
6
|
+
*/
|
|
7
|
+
export class CredentialVault {
|
|
4
8
|
__destroy_into_raw() {
|
|
5
9
|
const ptr = this.__wbg_ptr;
|
|
6
10
|
this.__wbg_ptr = 0;
|
|
7
|
-
|
|
11
|
+
CredentialVaultFinalization.unregister(this);
|
|
8
12
|
return ptr;
|
|
9
13
|
}
|
|
10
14
|
free() {
|
|
11
15
|
const ptr = this.__destroy_into_raw();
|
|
12
|
-
wasm.
|
|
16
|
+
wasm.__wbg_credentialvault_free(ptr, 0);
|
|
13
17
|
}
|
|
14
18
|
/**
|
|
15
|
-
* @param {
|
|
16
|
-
* @
|
|
17
|
-
|
|
19
|
+
* @param {number} ticket
|
|
20
|
+
* @returns {boolean}
|
|
21
|
+
*/
|
|
22
|
+
connectAbandon(ticket) {
|
|
23
|
+
const ret = wasm.credentialvault_connectAbandon(this.__wbg_ptr, ticket);
|
|
24
|
+
if (ret[2]) {
|
|
25
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
26
|
+
}
|
|
27
|
+
return ret[0] !== 0;
|
|
28
|
+
}
|
|
29
|
+
/**
|
|
30
|
+
* @param {string} grant_json
|
|
18
31
|
* @returns {string}
|
|
19
32
|
*/
|
|
20
|
-
|
|
21
|
-
let
|
|
22
|
-
let
|
|
33
|
+
connectBegin(grant_json) {
|
|
34
|
+
let deferred3_0;
|
|
35
|
+
let deferred3_1;
|
|
23
36
|
try {
|
|
24
|
-
const ptr0 = passStringToWasm0(
|
|
37
|
+
const ptr0 = passStringToWasm0(grant_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
25
38
|
const len0 = WASM_VECTOR_LEN;
|
|
26
|
-
|
|
27
|
-
var
|
|
28
|
-
var
|
|
29
|
-
var len2 = WASM_VECTOR_LEN;
|
|
30
|
-
const ret = wasm.kernel_applyServerResponse(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
31
|
-
var ptr4 = ret[0];
|
|
32
|
-
var len4 = ret[1];
|
|
39
|
+
const ret = wasm.credentialvault_connectBegin(this.__wbg_ptr, ptr0, len0);
|
|
40
|
+
var ptr2 = ret[0];
|
|
41
|
+
var len2 = ret[1];
|
|
33
42
|
if (ret[3]) {
|
|
34
|
-
|
|
43
|
+
ptr2 = 0; len2 = 0;
|
|
35
44
|
throw takeFromExternrefTable0(ret[2]);
|
|
36
45
|
}
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
return getStringFromWasm0(
|
|
46
|
+
deferred3_0 = ptr2;
|
|
47
|
+
deferred3_1 = len2;
|
|
48
|
+
return getStringFromWasm0(ptr2, len2);
|
|
40
49
|
} finally {
|
|
41
|
-
wasm.__wbindgen_free(
|
|
50
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
42
51
|
}
|
|
43
52
|
}
|
|
44
53
|
/**
|
|
45
|
-
* @param {
|
|
46
|
-
* @param {
|
|
47
|
-
* @param {string}
|
|
48
|
-
* @param {string | null} [payload_json]
|
|
54
|
+
* @param {number} ticket
|
|
55
|
+
* @param {number} status
|
|
56
|
+
* @param {string} body
|
|
49
57
|
* @returns {string}
|
|
50
58
|
*/
|
|
51
|
-
|
|
52
|
-
let
|
|
53
|
-
let
|
|
59
|
+
connectFinish(ticket, status, body) {
|
|
60
|
+
let deferred3_0;
|
|
61
|
+
let deferred3_1;
|
|
54
62
|
try {
|
|
55
|
-
const ptr0 = passStringToWasm0(
|
|
63
|
+
const ptr0 = passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
56
64
|
const len0 = WASM_VECTOR_LEN;
|
|
57
|
-
|
|
58
|
-
var
|
|
59
|
-
|
|
60
|
-
const len2 = WASM_VECTOR_LEN;
|
|
61
|
-
var ptr3 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
62
|
-
var len3 = WASM_VECTOR_LEN;
|
|
63
|
-
const ret = wasm.kernel_dispatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
64
|
-
var ptr5 = ret[0];
|
|
65
|
-
var len5 = ret[1];
|
|
65
|
+
const ret = wasm.credentialvault_connectFinish(this.__wbg_ptr, ticket, status, ptr0, len0);
|
|
66
|
+
var ptr2 = ret[0];
|
|
67
|
+
var len2 = ret[1];
|
|
66
68
|
if (ret[3]) {
|
|
67
|
-
|
|
69
|
+
ptr2 = 0; len2 = 0;
|
|
68
70
|
throw takeFromExternrefTable0(ret[2]);
|
|
69
71
|
}
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
return getStringFromWasm0(
|
|
72
|
+
deferred3_0 = ptr2;
|
|
73
|
+
deferred3_1 = len2;
|
|
74
|
+
return getStringFromWasm0(ptr2, len2);
|
|
73
75
|
} finally {
|
|
74
|
-
wasm.__wbindgen_free(
|
|
76
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
75
77
|
}
|
|
76
78
|
}
|
|
77
79
|
/**
|
|
78
|
-
* @
|
|
79
|
-
|
|
80
|
-
|
|
80
|
+
* @returns {boolean}
|
|
81
|
+
*/
|
|
82
|
+
get enabled() {
|
|
83
|
+
const ret = wasm.credentialvault_enabled(this.__wbg_ptr);
|
|
84
|
+
return ret !== 0;
|
|
85
|
+
}
|
|
86
|
+
/**
|
|
87
|
+
* @param {string | null} [principal]
|
|
81
88
|
* @returns {string}
|
|
82
89
|
*/
|
|
83
|
-
|
|
84
|
-
let
|
|
85
|
-
let
|
|
90
|
+
entries(principal) {
|
|
91
|
+
let deferred3_0;
|
|
92
|
+
let deferred3_1;
|
|
86
93
|
try {
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
var
|
|
91
|
-
var
|
|
92
|
-
var len2 = WASM_VECTOR_LEN;
|
|
93
|
-
const ret = wasm.kernel_dispatchMount(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
94
|
-
var ptr4 = ret[0];
|
|
95
|
-
var len4 = ret[1];
|
|
94
|
+
var ptr0 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
95
|
+
var len0 = WASM_VECTOR_LEN;
|
|
96
|
+
const ret = wasm.credentialvault_entries(this.__wbg_ptr, ptr0, len0);
|
|
97
|
+
var ptr2 = ret[0];
|
|
98
|
+
var len2 = ret[1];
|
|
96
99
|
if (ret[3]) {
|
|
97
|
-
|
|
100
|
+
ptr2 = 0; len2 = 0;
|
|
98
101
|
throw takeFromExternrefTable0(ret[2]);
|
|
99
102
|
}
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
return getStringFromWasm0(
|
|
103
|
+
deferred3_0 = ptr2;
|
|
104
|
+
deferred3_1 = len2;
|
|
105
|
+
return getStringFromWasm0(ptr2, len2);
|
|
103
106
|
} finally {
|
|
104
|
-
wasm.__wbindgen_free(
|
|
105
|
-
}
|
|
106
|
-
}
|
|
107
|
-
/**
|
|
108
|
-
* `undefined` when the leg carried no rows to fold against.
|
|
109
|
-
* @param {string | null | undefined} carried_json
|
|
110
|
-
* @param {string} seeded_json
|
|
111
|
-
* @param {string | null} [entity_id]
|
|
112
|
-
* @returns {string | undefined}
|
|
113
|
-
*/
|
|
114
|
-
foldBase(carried_json, seeded_json, entity_id) {
|
|
115
|
-
var ptr0 = isLikeNone(carried_json) ? 0 : passStringToWasm0(carried_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
116
|
-
var len0 = WASM_VECTOR_LEN;
|
|
117
|
-
const ptr1 = passStringToWasm0(seeded_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
118
|
-
const len1 = WASM_VECTOR_LEN;
|
|
119
|
-
var ptr2 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
120
|
-
var len2 = WASM_VECTOR_LEN;
|
|
121
|
-
const ret = wasm.kernel_foldBase(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
122
|
-
if (ret[3]) {
|
|
123
|
-
throw takeFromExternrefTable0(ret[2]);
|
|
124
|
-
}
|
|
125
|
-
let v4;
|
|
126
|
-
if (ret[0] !== 0) {
|
|
127
|
-
v4 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
128
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
107
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
129
108
|
}
|
|
130
|
-
return v4;
|
|
131
109
|
}
|
|
132
110
|
/**
|
|
133
|
-
*
|
|
134
|
-
* @param {
|
|
111
|
+
* @param {string} name
|
|
112
|
+
* @param {string | null} [principal]
|
|
135
113
|
* @returns {string | undefined}
|
|
136
114
|
*/
|
|
137
|
-
|
|
138
|
-
const
|
|
115
|
+
label(name, principal) {
|
|
116
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
117
|
+
const len0 = WASM_VECTOR_LEN;
|
|
118
|
+
var ptr1 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
119
|
+
var len1 = WASM_VECTOR_LEN;
|
|
120
|
+
const ret = wasm.credentialvault_label(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
139
121
|
if (ret[3]) {
|
|
140
122
|
throw takeFromExternrefTable0(ret[2]);
|
|
141
123
|
}
|
|
142
|
-
let
|
|
124
|
+
let v3;
|
|
143
125
|
if (ret[0] !== 0) {
|
|
144
|
-
|
|
126
|
+
v3 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
145
127
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
146
128
|
}
|
|
147
|
-
return
|
|
148
|
-
}
|
|
149
|
-
framePause() {
|
|
150
|
-
wasm.kernel_framePause(this.__wbg_ptr);
|
|
151
|
-
}
|
|
152
|
-
frameResume() {
|
|
153
|
-
wasm.kernel_frameResume(this.__wbg_ptr);
|
|
154
|
-
}
|
|
155
|
-
/**
|
|
156
|
-
* @param {string} trait_name
|
|
157
|
-
* @param {string | null} [entity_id]
|
|
158
|
-
* @returns {string}
|
|
159
|
-
*/
|
|
160
|
-
getState(trait_name, entity_id) {
|
|
161
|
-
let deferred3_0;
|
|
162
|
-
let deferred3_1;
|
|
163
|
-
try {
|
|
164
|
-
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
165
|
-
const len0 = WASM_VECTOR_LEN;
|
|
166
|
-
var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
167
|
-
var len1 = WASM_VECTOR_LEN;
|
|
168
|
-
const ret = wasm.kernel_getState(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
169
|
-
deferred3_0 = ret[0];
|
|
170
|
-
deferred3_1 = ret[1];
|
|
171
|
-
return getStringFromWasm0(ret[0], ret[1]);
|
|
172
|
-
} finally {
|
|
173
|
-
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
174
|
-
}
|
|
129
|
+
return v3;
|
|
175
130
|
}
|
|
176
131
|
/**
|
|
177
132
|
* @returns {string}
|
|
178
133
|
*/
|
|
179
|
-
|
|
180
|
-
let
|
|
181
|
-
let
|
|
134
|
+
listing() {
|
|
135
|
+
let deferred2_0;
|
|
136
|
+
let deferred2_1;
|
|
182
137
|
try {
|
|
183
|
-
const ret = wasm.
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
138
|
+
const ret = wasm.credentialvault_listing(this.__wbg_ptr);
|
|
139
|
+
var ptr1 = ret[0];
|
|
140
|
+
var len1 = ret[1];
|
|
141
|
+
if (ret[3]) {
|
|
142
|
+
ptr1 = 0; len1 = 0;
|
|
143
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
144
|
+
}
|
|
145
|
+
deferred2_0 = ptr1;
|
|
146
|
+
deferred2_1 = len1;
|
|
147
|
+
return getStringFromWasm0(ptr1, len1);
|
|
187
148
|
} finally {
|
|
188
|
-
wasm.__wbindgen_free(
|
|
149
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
189
150
|
}
|
|
190
151
|
}
|
|
191
152
|
/**
|
|
192
|
-
* @param {string}
|
|
153
|
+
* @param {string} rows_json
|
|
154
|
+
* @returns {number}
|
|
193
155
|
*/
|
|
194
|
-
|
|
195
|
-
const ptr0 = passStringToWasm0(
|
|
156
|
+
load(rows_json) {
|
|
157
|
+
const ptr0 = passStringToWasm0(rows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
196
158
|
const len0 = WASM_VECTOR_LEN;
|
|
197
|
-
const ret = wasm.
|
|
198
|
-
if (ret[
|
|
199
|
-
throw takeFromExternrefTable0(ret[
|
|
159
|
+
const ret = wasm.credentialvault_load(this.__wbg_ptr, ptr0, len0);
|
|
160
|
+
if (ret[2]) {
|
|
161
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
200
162
|
}
|
|
163
|
+
return ret[0] >>> 0;
|
|
201
164
|
}
|
|
202
165
|
/**
|
|
203
|
-
* @param {string}
|
|
204
|
-
* @param {string}
|
|
166
|
+
* @param {string | null} [master_key]
|
|
167
|
+
* @param {string | null} [previous_key]
|
|
205
168
|
*/
|
|
206
|
-
constructor(
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
const ret = wasm.
|
|
169
|
+
constructor(master_key, previous_key) {
|
|
170
|
+
var ptr0 = isLikeNone(master_key) ? 0 : passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
171
|
+
var len0 = WASM_VECTOR_LEN;
|
|
172
|
+
var ptr1 = isLikeNone(previous_key) ? 0 : passStringToWasm0(previous_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
173
|
+
var len1 = WASM_VECTOR_LEN;
|
|
174
|
+
const ret = wasm.credentialvault_new(ptr0, len0, ptr1, len1);
|
|
212
175
|
if (ret[2]) {
|
|
213
176
|
throw takeFromExternrefTable0(ret[1]);
|
|
214
177
|
}
|
|
215
178
|
this.__wbg_ptr = ret[0];
|
|
216
|
-
|
|
179
|
+
CredentialVaultFinalization.register(this, this.__wbg_ptr, this);
|
|
217
180
|
return this;
|
|
218
181
|
}
|
|
219
182
|
/**
|
|
220
|
-
* @param {string}
|
|
183
|
+
* @param {string} name
|
|
184
|
+
* @param {string} value
|
|
185
|
+
* @param {string | null} [principal]
|
|
186
|
+
* @param {string | null} [label]
|
|
187
|
+
* @returns {string}
|
|
221
188
|
*/
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
189
|
+
persist(name, value, principal, label) {
|
|
190
|
+
let deferred6_0;
|
|
191
|
+
let deferred6_1;
|
|
192
|
+
try {
|
|
193
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
194
|
+
const len0 = WASM_VECTOR_LEN;
|
|
195
|
+
const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
196
|
+
const len1 = WASM_VECTOR_LEN;
|
|
197
|
+
var ptr2 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
198
|
+
var len2 = WASM_VECTOR_LEN;
|
|
199
|
+
var ptr3 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
200
|
+
var len3 = WASM_VECTOR_LEN;
|
|
201
|
+
const ret = wasm.credentialvault_persist(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
202
|
+
var ptr5 = ret[0];
|
|
203
|
+
var len5 = ret[1];
|
|
204
|
+
if (ret[3]) {
|
|
205
|
+
ptr5 = 0; len5 = 0;
|
|
206
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
207
|
+
}
|
|
208
|
+
deferred6_0 = ptr5;
|
|
209
|
+
deferred6_1 = len5;
|
|
210
|
+
return getStringFromWasm0(ptr5, len5);
|
|
211
|
+
} finally {
|
|
212
|
+
wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
|
|
228
213
|
}
|
|
229
214
|
}
|
|
230
215
|
/**
|
|
231
|
-
* @param {string}
|
|
232
|
-
* @param {string | null
|
|
233
|
-
* @param {string} snapshot_json
|
|
216
|
+
* @param {string} name
|
|
217
|
+
* @param {string | null} [principal]
|
|
234
218
|
* @returns {string}
|
|
235
219
|
*/
|
|
236
|
-
|
|
237
|
-
let
|
|
238
|
-
let
|
|
220
|
+
refreshBegin(name, principal) {
|
|
221
|
+
let deferred4_0;
|
|
222
|
+
let deferred4_1;
|
|
239
223
|
try {
|
|
240
|
-
const ptr0 = passStringToWasm0(
|
|
224
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
241
225
|
const len0 = WASM_VECTOR_LEN;
|
|
242
|
-
var ptr1 = isLikeNone(
|
|
226
|
+
var ptr1 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
243
227
|
var len1 = WASM_VECTOR_LEN;
|
|
244
|
-
const
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
var ptr4 = ret[0];
|
|
248
|
-
var len4 = ret[1];
|
|
228
|
+
const ret = wasm.credentialvault_refreshBegin(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
229
|
+
var ptr3 = ret[0];
|
|
230
|
+
var len3 = ret[1];
|
|
249
231
|
if (ret[3]) {
|
|
250
|
-
|
|
232
|
+
ptr3 = 0; len3 = 0;
|
|
251
233
|
throw takeFromExternrefTable0(ret[2]);
|
|
252
234
|
}
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
return getStringFromWasm0(
|
|
235
|
+
deferred4_0 = ptr3;
|
|
236
|
+
deferred4_1 = len3;
|
|
237
|
+
return getStringFromWasm0(ptr3, len3);
|
|
256
238
|
} finally {
|
|
257
|
-
wasm.__wbindgen_free(
|
|
239
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
258
240
|
}
|
|
259
241
|
}
|
|
260
242
|
/**
|
|
261
|
-
* @param {string}
|
|
262
|
-
* @param {string}
|
|
243
|
+
* @param {string} name
|
|
244
|
+
* @param {string | null} [principal]
|
|
245
|
+
* @returns {boolean}
|
|
263
246
|
*/
|
|
264
|
-
|
|
265
|
-
const ptr0 = passStringToWasm0(
|
|
247
|
+
remove(name, principal) {
|
|
248
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
266
249
|
const len0 = WASM_VECTOR_LEN;
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
const ret = wasm.
|
|
270
|
-
if (ret[
|
|
271
|
-
throw takeFromExternrefTable0(ret[
|
|
250
|
+
var ptr1 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
251
|
+
var len1 = WASM_VECTOR_LEN;
|
|
252
|
+
const ret = wasm.credentialvault_remove(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
253
|
+
if (ret[2]) {
|
|
254
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
272
255
|
}
|
|
256
|
+
return ret[0] !== 0;
|
|
273
257
|
}
|
|
274
258
|
/**
|
|
275
|
-
* @param {string}
|
|
259
|
+
* @param {string} name
|
|
260
|
+
* @param {string} value
|
|
261
|
+
* @param {string | null} [principal]
|
|
262
|
+
* @returns {string}
|
|
276
263
|
*/
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
264
|
+
replace(name, value, principal) {
|
|
265
|
+
let deferred5_0;
|
|
266
|
+
let deferred5_1;
|
|
267
|
+
try {
|
|
268
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
269
|
+
const len0 = WASM_VECTOR_LEN;
|
|
270
|
+
const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
271
|
+
const len1 = WASM_VECTOR_LEN;
|
|
272
|
+
var ptr2 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
273
|
+
var len2 = WASM_VECTOR_LEN;
|
|
274
|
+
const ret = wasm.credentialvault_replace(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
275
|
+
var ptr4 = ret[0];
|
|
276
|
+
var len4 = ret[1];
|
|
277
|
+
if (ret[3]) {
|
|
278
|
+
ptr4 = 0; len4 = 0;
|
|
279
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
280
|
+
}
|
|
281
|
+
deferred5_0 = ptr4;
|
|
282
|
+
deferred5_1 = len4;
|
|
283
|
+
return getStringFromWasm0(ptr4, len4);
|
|
284
|
+
} finally {
|
|
285
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
283
286
|
}
|
|
284
287
|
}
|
|
285
288
|
/**
|
|
286
|
-
*
|
|
287
|
-
* @param {
|
|
288
|
-
|
|
289
|
-
setHostFansOut(fans_out) {
|
|
290
|
-
wasm.kernel_setHostFansOut(this.__wbg_ptr, fans_out);
|
|
291
|
-
}
|
|
292
|
-
/**
|
|
293
|
-
* @param {string} mode
|
|
289
|
+
* @param {string} name
|
|
290
|
+
* @param {string | null} [principal]
|
|
291
|
+
* @returns {string | undefined}
|
|
294
292
|
*/
|
|
295
|
-
|
|
296
|
-
const ptr0 = passStringToWasm0(
|
|
293
|
+
resolve(name, principal) {
|
|
294
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
297
295
|
const len0 = WASM_VECTOR_LEN;
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
296
|
+
var ptr1 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
297
|
+
var len1 = WASM_VECTOR_LEN;
|
|
298
|
+
const ret = wasm.credentialvault_resolve(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
299
|
+
if (ret[3]) {
|
|
300
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
301
|
+
}
|
|
302
|
+
let v3;
|
|
303
|
+
if (ret[0] !== 0) {
|
|
304
|
+
v3 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
305
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
301
306
|
}
|
|
307
|
+
return v3;
|
|
302
308
|
}
|
|
303
309
|
/**
|
|
304
310
|
* @returns {string}
|
|
305
311
|
*/
|
|
306
|
-
|
|
312
|
+
rotate() {
|
|
307
313
|
let deferred2_0;
|
|
308
314
|
let deferred2_1;
|
|
309
315
|
try {
|
|
310
|
-
const ret = wasm.
|
|
316
|
+
const ret = wasm.credentialvault_rotate(this.__wbg_ptr);
|
|
311
317
|
var ptr1 = ret[0];
|
|
312
318
|
var len1 = ret[1];
|
|
313
319
|
if (ret[3]) {
|
|
@@ -322,172 +328,187 @@ export class Kernel {
|
|
|
322
328
|
}
|
|
323
329
|
}
|
|
324
330
|
/**
|
|
325
|
-
* @param {string}
|
|
326
|
-
* @param {string}
|
|
327
|
-
* @param {string
|
|
331
|
+
* @param {string} service
|
|
332
|
+
* @param {string} name
|
|
333
|
+
* @param {string} value
|
|
334
|
+
* @param {string | null} [principal]
|
|
335
|
+
* @param {string | null} [label]
|
|
328
336
|
* @returns {string}
|
|
329
337
|
*/
|
|
330
|
-
|
|
331
|
-
let
|
|
332
|
-
let
|
|
338
|
+
set(service, name, value, principal, label) {
|
|
339
|
+
let deferred7_0;
|
|
340
|
+
let deferred7_1;
|
|
333
341
|
try {
|
|
334
|
-
const ptr0 = passStringToWasm0(
|
|
342
|
+
const ptr0 = passStringToWasm0(service, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
335
343
|
const len0 = WASM_VECTOR_LEN;
|
|
336
|
-
const ptr1 = passStringToWasm0(
|
|
344
|
+
const ptr1 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
337
345
|
const len1 = WASM_VECTOR_LEN;
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
var
|
|
342
|
-
var
|
|
346
|
+
const ptr2 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
347
|
+
const len2 = WASM_VECTOR_LEN;
|
|
348
|
+
var ptr3 = isLikeNone(principal) ? 0 : passStringToWasm0(principal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
349
|
+
var len3 = WASM_VECTOR_LEN;
|
|
350
|
+
var ptr4 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
351
|
+
var len4 = WASM_VECTOR_LEN;
|
|
352
|
+
const ret = wasm.credentialvault_set(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
|
|
353
|
+
var ptr6 = ret[0];
|
|
354
|
+
var len6 = ret[1];
|
|
343
355
|
if (ret[3]) {
|
|
344
|
-
|
|
356
|
+
ptr6 = 0; len6 = 0;
|
|
345
357
|
throw takeFromExternrefTable0(ret[2]);
|
|
346
358
|
}
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
return getStringFromWasm0(
|
|
359
|
+
deferred7_0 = ptr6;
|
|
360
|
+
deferred7_1 = len6;
|
|
361
|
+
return getStringFromWasm0(ptr6, len6);
|
|
350
362
|
} finally {
|
|
351
|
-
wasm.__wbindgen_free(
|
|
363
|
+
wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
|
|
352
364
|
}
|
|
353
365
|
}
|
|
354
366
|
/**
|
|
355
|
-
* @returns {
|
|
367
|
+
* @returns {string}
|
|
356
368
|
*/
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
369
|
+
snapshotEnv() {
|
|
370
|
+
let deferred2_0;
|
|
371
|
+
let deferred2_1;
|
|
372
|
+
try {
|
|
373
|
+
const ret = wasm.credentialvault_snapshotEnv(this.__wbg_ptr);
|
|
374
|
+
var ptr1 = ret[0];
|
|
375
|
+
var len1 = ret[1];
|
|
376
|
+
if (ret[3]) {
|
|
377
|
+
ptr1 = 0; len1 = 0;
|
|
378
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
379
|
+
}
|
|
380
|
+
deferred2_0 = ptr1;
|
|
381
|
+
deferred2_1 = len1;
|
|
382
|
+
return getStringFromWasm0(ptr1, len1);
|
|
383
|
+
} finally {
|
|
384
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
385
|
+
}
|
|
360
386
|
}
|
|
361
387
|
/**
|
|
362
|
-
* @
|
|
388
|
+
* @returns {string}
|
|
363
389
|
*/
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
390
|
+
takeWrites() {
|
|
391
|
+
let deferred2_0;
|
|
392
|
+
let deferred2_1;
|
|
393
|
+
try {
|
|
394
|
+
const ret = wasm.credentialvault_takeWrites(this.__wbg_ptr);
|
|
395
|
+
var ptr1 = ret[0];
|
|
396
|
+
var len1 = ret[1];
|
|
397
|
+
if (ret[3]) {
|
|
398
|
+
ptr1 = 0; len1 = 0;
|
|
399
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
400
|
+
}
|
|
401
|
+
deferred2_0 = ptr1;
|
|
402
|
+
deferred2_1 = len1;
|
|
403
|
+
return getStringFromWasm0(ptr1, len1);
|
|
404
|
+
} finally {
|
|
405
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
370
406
|
}
|
|
371
407
|
}
|
|
372
408
|
}
|
|
373
|
-
if (Symbol.dispose)
|
|
409
|
+
if (Symbol.dispose) CredentialVault.prototype[Symbol.dispose] = CredentialVault.prototype.free;
|
|
374
410
|
|
|
375
|
-
|
|
376
|
-
* The server role: `start` a request, answer the I/O it asks for, `resume` the flight until it is done.
|
|
377
|
-
*/
|
|
378
|
-
export class Server {
|
|
411
|
+
export class Kernel {
|
|
379
412
|
__destroy_into_raw() {
|
|
380
413
|
const ptr = this.__wbg_ptr;
|
|
381
414
|
this.__wbg_ptr = 0;
|
|
382
|
-
|
|
415
|
+
KernelFinalization.unregister(this);
|
|
383
416
|
return ptr;
|
|
384
417
|
}
|
|
385
418
|
free() {
|
|
386
419
|
const ptr = this.__destroy_into_raw();
|
|
387
|
-
wasm.
|
|
420
|
+
wasm.__wbg_kernel_free(ptr, 0);
|
|
388
421
|
}
|
|
389
422
|
/**
|
|
390
|
-
* @param {
|
|
391
|
-
* @
|
|
423
|
+
* @param {string} response_json
|
|
424
|
+
* @param {string | null} [already_delivered_json]
|
|
425
|
+
* @param {string | null} [base_json]
|
|
426
|
+
* @returns {string}
|
|
392
427
|
*/
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
428
|
+
applyServerResponse(response_json, already_delivered_json, base_json) {
|
|
429
|
+
let deferred5_0;
|
|
430
|
+
let deferred5_1;
|
|
431
|
+
try {
|
|
432
|
+
const ptr0 = passStringToWasm0(response_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
433
|
+
const len0 = WASM_VECTOR_LEN;
|
|
434
|
+
var ptr1 = isLikeNone(already_delivered_json) ? 0 : passStringToWasm0(already_delivered_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
435
|
+
var len1 = WASM_VECTOR_LEN;
|
|
436
|
+
var ptr2 = isLikeNone(base_json) ? 0 : passStringToWasm0(base_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
437
|
+
var len2 = WASM_VECTOR_LEN;
|
|
438
|
+
const ret = wasm.kernel_applyServerResponse(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
439
|
+
var ptr4 = ret[0];
|
|
440
|
+
var len4 = ret[1];
|
|
441
|
+
if (ret[3]) {
|
|
442
|
+
ptr4 = 0; len4 = 0;
|
|
443
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
444
|
+
}
|
|
445
|
+
deferred5_0 = ptr4;
|
|
446
|
+
deferred5_1 = len4;
|
|
447
|
+
return getStringFromWasm0(ptr4, len4);
|
|
448
|
+
} finally {
|
|
449
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
397
450
|
}
|
|
398
|
-
return ret[0] !== 0;
|
|
399
451
|
}
|
|
400
452
|
/**
|
|
401
|
-
* @param {string}
|
|
402
|
-
* @param {string | null} [entity_id]
|
|
453
|
+
* @param {string} side
|
|
403
454
|
* @returns {string}
|
|
404
455
|
*/
|
|
405
|
-
|
|
456
|
+
bootMounts(side) {
|
|
406
457
|
let deferred3_0;
|
|
407
458
|
let deferred3_1;
|
|
408
459
|
try {
|
|
409
|
-
const ptr0 = passStringToWasm0(
|
|
460
|
+
const ptr0 = passStringToWasm0(side, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
410
461
|
const len0 = WASM_VECTOR_LEN;
|
|
411
|
-
|
|
412
|
-
var
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
462
|
+
const ret = wasm.kernel_bootMounts(this.__wbg_ptr, ptr0, len0);
|
|
463
|
+
var ptr2 = ret[0];
|
|
464
|
+
var len2 = ret[1];
|
|
465
|
+
if (ret[3]) {
|
|
466
|
+
ptr2 = 0; len2 = 0;
|
|
467
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
468
|
+
}
|
|
469
|
+
deferred3_0 = ptr2;
|
|
470
|
+
deferred3_1 = len2;
|
|
471
|
+
return getStringFromWasm0(ptr2, len2);
|
|
417
472
|
} finally {
|
|
418
473
|
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
419
474
|
}
|
|
420
475
|
}
|
|
421
476
|
/**
|
|
422
|
-
* @
|
|
423
|
-
*/
|
|
424
|
-
inFlight() {
|
|
425
|
-
const ret = wasm.server_inFlight(this.__wbg_ptr);
|
|
426
|
-
return ret >>> 0;
|
|
427
|
-
}
|
|
428
|
-
/**
|
|
477
|
+
* @param {string} query_json
|
|
429
478
|
* @returns {string}
|
|
430
479
|
*/
|
|
431
|
-
|
|
432
|
-
let
|
|
433
|
-
let
|
|
480
|
+
contractQuery(query_json) {
|
|
481
|
+
let deferred3_0;
|
|
482
|
+
let deferred3_1;
|
|
434
483
|
try {
|
|
435
|
-
const
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
484
|
+
const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
485
|
+
const len0 = WASM_VECTOR_LEN;
|
|
486
|
+
const ret = wasm.kernel_contractQuery(this.__wbg_ptr, ptr0, len0);
|
|
487
|
+
var ptr2 = ret[0];
|
|
488
|
+
var len2 = ret[1];
|
|
489
|
+
if (ret[3]) {
|
|
490
|
+
ptr2 = 0; len2 = 0;
|
|
491
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
492
|
+
}
|
|
493
|
+
deferred3_0 = ptr2;
|
|
494
|
+
deferred3_1 = len2;
|
|
495
|
+
return getStringFromWasm0(ptr2, len2);
|
|
439
496
|
} finally {
|
|
440
|
-
wasm.__wbindgen_free(
|
|
441
|
-
}
|
|
442
|
-
}
|
|
443
|
-
/**
|
|
444
|
-
* @param {string} traits_json
|
|
445
|
-
*/
|
|
446
|
-
mount(traits_json) {
|
|
447
|
-
const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
448
|
-
const len0 = WASM_VECTOR_LEN;
|
|
449
|
-
const ret = wasm.server_mount(this.__wbg_ptr, ptr0, len0);
|
|
450
|
-
if (ret[1]) {
|
|
451
|
-
throw takeFromExternrefTable0(ret[0]);
|
|
452
|
-
}
|
|
453
|
-
}
|
|
454
|
-
/**
|
|
455
|
-
* @param {string} resolved_schema_json
|
|
456
|
-
*/
|
|
457
|
-
constructor(resolved_schema_json) {
|
|
458
|
-
const ptr0 = passStringToWasm0(resolved_schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
459
|
-
const len0 = WASM_VECTOR_LEN;
|
|
460
|
-
const ret = wasm.server_new(ptr0, len0);
|
|
461
|
-
if (ret[2]) {
|
|
462
|
-
throw takeFromExternrefTable0(ret[1]);
|
|
463
|
-
}
|
|
464
|
-
this.__wbg_ptr = ret[0];
|
|
465
|
-
ServerFinalization.register(this, this.__wbg_ptr, this);
|
|
466
|
-
return this;
|
|
467
|
-
}
|
|
468
|
-
/**
|
|
469
|
-
* @param {string} traits_json
|
|
470
|
-
*/
|
|
471
|
-
remount(traits_json) {
|
|
472
|
-
const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
473
|
-
const len0 = WASM_VECTOR_LEN;
|
|
474
|
-
const ret = wasm.server_remount(this.__wbg_ptr, ptr0, len0);
|
|
475
|
-
if (ret[1]) {
|
|
476
|
-
throw takeFromExternrefTable0(ret[0]);
|
|
497
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
477
498
|
}
|
|
478
499
|
}
|
|
479
500
|
/**
|
|
480
501
|
* @param {number} flight
|
|
481
|
-
* @param {string}
|
|
502
|
+
* @param {string} emitted_json
|
|
482
503
|
* @returns {string}
|
|
483
504
|
*/
|
|
484
|
-
|
|
505
|
+
deliverEmitToListeners(flight, emitted_json) {
|
|
485
506
|
let deferred3_0;
|
|
486
507
|
let deferred3_1;
|
|
487
508
|
try {
|
|
488
|
-
const ptr0 = passStringToWasm0(
|
|
509
|
+
const ptr0 = passStringToWasm0(emitted_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
489
510
|
const len0 = WASM_VECTOR_LEN;
|
|
490
|
-
const ret = wasm.
|
|
511
|
+
const ret = wasm.kernel_deliverEmitToListeners(this.__wbg_ptr, flight, ptr0, len0);
|
|
491
512
|
var ptr2 = ret[0];
|
|
492
513
|
var len2 = ret[1];
|
|
493
514
|
if (ret[3]) {
|
|
@@ -502,124 +523,3679 @@ export class Server {
|
|
|
502
523
|
}
|
|
503
524
|
}
|
|
504
525
|
/**
|
|
505
|
-
* @param {
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
const ptr0 = passStringToWasm0(user_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
509
|
-
const len0 = WASM_VECTOR_LEN;
|
|
510
|
-
const ret = wasm.server_setDefaultUser(this.__wbg_ptr, ptr0, len0);
|
|
511
|
-
if (ret[1]) {
|
|
512
|
-
throw takeFromExternrefTable0(ret[0]);
|
|
513
|
-
}
|
|
514
|
-
}
|
|
515
|
-
/**
|
|
516
|
-
* @param {string} locales_json
|
|
517
|
-
* @param {string} catalogs_json
|
|
526
|
+
* @param {number} flight
|
|
527
|
+
* @param {string} emitted_json
|
|
528
|
+
* @returns {string}
|
|
518
529
|
*/
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
530
|
+
deliverOriginEmit(flight, emitted_json) {
|
|
531
|
+
let deferred3_0;
|
|
532
|
+
let deferred3_1;
|
|
533
|
+
try {
|
|
534
|
+
const ptr0 = passStringToWasm0(emitted_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
535
|
+
const len0 = WASM_VECTOR_LEN;
|
|
536
|
+
const ret = wasm.kernel_deliverOriginEmit(this.__wbg_ptr, flight, ptr0, len0);
|
|
537
|
+
var ptr2 = ret[0];
|
|
538
|
+
var len2 = ret[1];
|
|
539
|
+
if (ret[3]) {
|
|
540
|
+
ptr2 = 0; len2 = 0;
|
|
541
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
542
|
+
}
|
|
543
|
+
deferred3_0 = ptr2;
|
|
544
|
+
deferred3_1 = len2;
|
|
545
|
+
return getStringFromWasm0(ptr2, len2);
|
|
546
|
+
} finally {
|
|
547
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
527
548
|
}
|
|
528
549
|
}
|
|
529
550
|
/**
|
|
530
|
-
* @param {string}
|
|
551
|
+
* @param {string} trait_name
|
|
552
|
+
* @param {string | null | undefined} entity_id
|
|
553
|
+
* @param {string} event
|
|
554
|
+
* @param {string | null} [payload_json]
|
|
555
|
+
* @returns {string}
|
|
531
556
|
*/
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
|
|
557
|
+
dispatch(trait_name, entity_id, event, payload_json) {
|
|
558
|
+
let deferred6_0;
|
|
559
|
+
let deferred6_1;
|
|
560
|
+
try {
|
|
561
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
562
|
+
const len0 = WASM_VECTOR_LEN;
|
|
563
|
+
var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
564
|
+
var len1 = WASM_VECTOR_LEN;
|
|
565
|
+
const ptr2 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
566
|
+
const len2 = WASM_VECTOR_LEN;
|
|
567
|
+
var ptr3 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
568
|
+
var len3 = WASM_VECTOR_LEN;
|
|
569
|
+
const ret = wasm.kernel_dispatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
570
|
+
var ptr5 = ret[0];
|
|
571
|
+
var len5 = ret[1];
|
|
572
|
+
if (ret[3]) {
|
|
573
|
+
ptr5 = 0; len5 = 0;
|
|
574
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
575
|
+
}
|
|
576
|
+
deferred6_0 = ptr5;
|
|
577
|
+
deferred6_1 = len5;
|
|
578
|
+
return getStringFromWasm0(ptr5, len5);
|
|
579
|
+
} finally {
|
|
580
|
+
wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
|
|
538
581
|
}
|
|
539
582
|
}
|
|
540
583
|
/**
|
|
541
|
-
*
|
|
542
|
-
* @param {string}
|
|
584
|
+
* The kernel's dispatch mode for a registered trait, as JSON text.
|
|
585
|
+
* @param {string} trait_name
|
|
543
586
|
* @returns {string}
|
|
544
587
|
*/
|
|
545
|
-
|
|
546
|
-
let
|
|
547
|
-
let
|
|
588
|
+
dispatchMode(trait_name) {
|
|
589
|
+
let deferred3_0;
|
|
590
|
+
let deferred3_1;
|
|
548
591
|
try {
|
|
549
|
-
const ptr0 = passStringToWasm0(
|
|
592
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
550
593
|
const len0 = WASM_VECTOR_LEN;
|
|
551
|
-
const
|
|
594
|
+
const ret = wasm.kernel_dispatchMode(this.__wbg_ptr, ptr0, len0);
|
|
595
|
+
var ptr2 = ret[0];
|
|
596
|
+
var len2 = ret[1];
|
|
597
|
+
if (ret[3]) {
|
|
598
|
+
ptr2 = 0; len2 = 0;
|
|
599
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
600
|
+
}
|
|
601
|
+
deferred3_0 = ptr2;
|
|
602
|
+
deferred3_1 = len2;
|
|
603
|
+
return getStringFromWasm0(ptr2, len2);
|
|
604
|
+
} finally {
|
|
605
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
606
|
+
}
|
|
607
|
+
}
|
|
608
|
+
/**
|
|
609
|
+
* @param {string} seeds_json
|
|
610
|
+
* @param {string | null} [entity_id]
|
|
611
|
+
* @param {string | null} [payload_json]
|
|
612
|
+
* @param {string | null} [route]
|
|
613
|
+
* @returns {string}
|
|
614
|
+
*/
|
|
615
|
+
dispatchMount(seeds_json, entity_id, payload_json, route) {
|
|
616
|
+
let deferred6_0;
|
|
617
|
+
let deferred6_1;
|
|
618
|
+
try {
|
|
619
|
+
const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
620
|
+
const len0 = WASM_VECTOR_LEN;
|
|
621
|
+
var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
622
|
+
var len1 = WASM_VECTOR_LEN;
|
|
623
|
+
var ptr2 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
624
|
+
var len2 = WASM_VECTOR_LEN;
|
|
625
|
+
var ptr3 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
626
|
+
var len3 = WASM_VECTOR_LEN;
|
|
627
|
+
const ret = wasm.kernel_dispatchMount(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
628
|
+
var ptr5 = ret[0];
|
|
629
|
+
var len5 = ret[1];
|
|
630
|
+
if (ret[3]) {
|
|
631
|
+
ptr5 = 0; len5 = 0;
|
|
632
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
633
|
+
}
|
|
634
|
+
deferred6_0 = ptr5;
|
|
635
|
+
deferred6_1 = len5;
|
|
636
|
+
return getStringFromWasm0(ptr5, len5);
|
|
637
|
+
} finally {
|
|
638
|
+
wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
|
|
639
|
+
}
|
|
640
|
+
}
|
|
641
|
+
/**
|
|
642
|
+
* @param {number} flight
|
|
643
|
+
* @returns {boolean}
|
|
644
|
+
*/
|
|
645
|
+
endFlight(flight) {
|
|
646
|
+
const ret = wasm.kernel_endFlight(this.__wbg_ptr, flight);
|
|
647
|
+
return ret !== 0;
|
|
648
|
+
}
|
|
649
|
+
/**
|
|
650
|
+
* @param {string | null | undefined} route_path
|
|
651
|
+
* @param {string} mount_key
|
|
652
|
+
* @param {string} traits_json
|
|
653
|
+
* @returns {string}
|
|
654
|
+
*/
|
|
655
|
+
enter(route_path, mount_key, traits_json) {
|
|
656
|
+
let deferred5_0;
|
|
657
|
+
let deferred5_1;
|
|
658
|
+
try {
|
|
659
|
+
var ptr0 = isLikeNone(route_path) ? 0 : passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
660
|
+
var len0 = WASM_VECTOR_LEN;
|
|
661
|
+
const ptr1 = passStringToWasm0(mount_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
552
662
|
const len1 = WASM_VECTOR_LEN;
|
|
553
|
-
const
|
|
554
|
-
|
|
555
|
-
|
|
663
|
+
const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
664
|
+
const len2 = WASM_VECTOR_LEN;
|
|
665
|
+
const ret = wasm.kernel_enter(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
666
|
+
var ptr4 = ret[0];
|
|
667
|
+
var len4 = ret[1];
|
|
556
668
|
if (ret[3]) {
|
|
557
|
-
|
|
669
|
+
ptr4 = 0; len4 = 0;
|
|
558
670
|
throw takeFromExternrefTable0(ret[2]);
|
|
559
671
|
}
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
return getStringFromWasm0(
|
|
672
|
+
deferred5_0 = ptr4;
|
|
673
|
+
deferred5_1 = len4;
|
|
674
|
+
return getStringFromWasm0(ptr4, len4);
|
|
563
675
|
} finally {
|
|
564
|
-
wasm.__wbindgen_free(
|
|
676
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
565
677
|
}
|
|
566
678
|
}
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
679
|
+
/**
|
|
680
|
+
* `undefined` when the leg carried no rows to fold against.
|
|
681
|
+
* @param {string | null | undefined} carried_json
|
|
682
|
+
* @param {string} seeded_json
|
|
683
|
+
* @param {string | null} [entity_id]
|
|
684
|
+
* @returns {string | undefined}
|
|
685
|
+
*/
|
|
686
|
+
foldBase(carried_json, seeded_json, entity_id) {
|
|
687
|
+
var ptr0 = isLikeNone(carried_json) ? 0 : passStringToWasm0(carried_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
688
|
+
var len0 = WASM_VECTOR_LEN;
|
|
689
|
+
const ptr1 = passStringToWasm0(seeded_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
690
|
+
const len1 = WASM_VECTOR_LEN;
|
|
691
|
+
var ptr2 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
692
|
+
var len2 = WASM_VECTOR_LEN;
|
|
693
|
+
const ret = wasm.kernel_foldBase(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
694
|
+
if (ret[3]) {
|
|
695
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
696
|
+
}
|
|
697
|
+
let v4;
|
|
698
|
+
if (ret[0] !== 0) {
|
|
699
|
+
v4 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
700
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
701
|
+
}
|
|
702
|
+
return v4;
|
|
581
703
|
}
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
704
|
+
/**
|
|
705
|
+
* @param {number} flight
|
|
706
|
+
* @param {string} response_json
|
|
707
|
+
* @param {string | null} [already_delivered_json]
|
|
708
|
+
* @param {string | null} [base_json]
|
|
709
|
+
* @returns {string}
|
|
710
|
+
*/
|
|
711
|
+
foldInOrder(flight, response_json, already_delivered_json, base_json) {
|
|
712
|
+
let deferred5_0;
|
|
713
|
+
let deferred5_1;
|
|
714
|
+
try {
|
|
715
|
+
const ptr0 = passStringToWasm0(response_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
716
|
+
const len0 = WASM_VECTOR_LEN;
|
|
717
|
+
var ptr1 = isLikeNone(already_delivered_json) ? 0 : passStringToWasm0(already_delivered_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
718
|
+
var len1 = WASM_VECTOR_LEN;
|
|
719
|
+
var ptr2 = isLikeNone(base_json) ? 0 : passStringToWasm0(base_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
720
|
+
var len2 = WASM_VECTOR_LEN;
|
|
721
|
+
const ret = wasm.kernel_foldInOrder(this.__wbg_ptr, flight, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
722
|
+
var ptr4 = ret[0];
|
|
723
|
+
var len4 = ret[1];
|
|
724
|
+
if (ret[3]) {
|
|
725
|
+
ptr4 = 0; len4 = 0;
|
|
726
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
727
|
+
}
|
|
728
|
+
deferred5_0 = ptr4;
|
|
729
|
+
deferred5_1 = len4;
|
|
730
|
+
return getStringFromWasm0(ptr4, len4);
|
|
731
|
+
} finally {
|
|
732
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
733
|
+
}
|
|
734
|
+
}
|
|
735
|
+
/**
|
|
736
|
+
* `undefined` when no tick is due this frame.
|
|
737
|
+
* @param {number} now_ms
|
|
738
|
+
* @returns {string | undefined}
|
|
739
|
+
*/
|
|
740
|
+
frame(now_ms) {
|
|
741
|
+
const ret = wasm.kernel_frame(this.__wbg_ptr, now_ms);
|
|
742
|
+
if (ret[3]) {
|
|
743
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
744
|
+
}
|
|
745
|
+
let v1;
|
|
746
|
+
if (ret[0] !== 0) {
|
|
747
|
+
v1 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
748
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
749
|
+
}
|
|
750
|
+
return v1;
|
|
751
|
+
}
|
|
752
|
+
framePause() {
|
|
753
|
+
wasm.kernel_framePause(this.__wbg_ptr);
|
|
754
|
+
}
|
|
755
|
+
frameResume() {
|
|
756
|
+
wasm.kernel_frameResume(this.__wbg_ptr);
|
|
757
|
+
}
|
|
758
|
+
/**
|
|
759
|
+
* @param {number} since
|
|
760
|
+
* @returns {string}
|
|
761
|
+
*/
|
|
762
|
+
framesSince(since) {
|
|
763
|
+
let deferred2_0;
|
|
764
|
+
let deferred2_1;
|
|
765
|
+
try {
|
|
766
|
+
const ret = wasm.kernel_framesSince(this.__wbg_ptr, since);
|
|
767
|
+
var ptr1 = ret[0];
|
|
768
|
+
var len1 = ret[1];
|
|
769
|
+
if (ret[3]) {
|
|
770
|
+
ptr1 = 0; len1 = 0;
|
|
771
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
772
|
+
}
|
|
773
|
+
deferred2_0 = ptr1;
|
|
774
|
+
deferred2_1 = len1;
|
|
775
|
+
return getStringFromWasm0(ptr1, len1);
|
|
776
|
+
} finally {
|
|
777
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
778
|
+
}
|
|
779
|
+
}
|
|
780
|
+
/**
|
|
781
|
+
* @param {string} trait_name
|
|
782
|
+
* @param {string | null} [entity_id]
|
|
783
|
+
* @returns {string}
|
|
784
|
+
*/
|
|
785
|
+
getState(trait_name, entity_id) {
|
|
786
|
+
let deferred3_0;
|
|
787
|
+
let deferred3_1;
|
|
788
|
+
try {
|
|
789
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
790
|
+
const len0 = WASM_VECTOR_LEN;
|
|
791
|
+
var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
792
|
+
var len1 = WASM_VECTOR_LEN;
|
|
793
|
+
const ret = wasm.kernel_getState(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
794
|
+
deferred3_0 = ret[0];
|
|
795
|
+
deferred3_1 = ret[1];
|
|
796
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
797
|
+
} finally {
|
|
798
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
799
|
+
}
|
|
800
|
+
}
|
|
801
|
+
/**
|
|
802
|
+
* @returns {string}
|
|
803
|
+
*/
|
|
804
|
+
lastError() {
|
|
805
|
+
let deferred1_0;
|
|
806
|
+
let deferred1_1;
|
|
807
|
+
try {
|
|
808
|
+
const ret = wasm.kernel_lastError(this.__wbg_ptr);
|
|
809
|
+
deferred1_0 = ret[0];
|
|
810
|
+
deferred1_1 = ret[1];
|
|
811
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
812
|
+
} finally {
|
|
813
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
814
|
+
}
|
|
815
|
+
}
|
|
816
|
+
/**
|
|
817
|
+
* @returns {string}
|
|
818
|
+
*/
|
|
819
|
+
leave() {
|
|
820
|
+
let deferred2_0;
|
|
821
|
+
let deferred2_1;
|
|
822
|
+
try {
|
|
823
|
+
const ret = wasm.kernel_leave(this.__wbg_ptr);
|
|
824
|
+
var ptr1 = ret[0];
|
|
825
|
+
var len1 = ret[1];
|
|
826
|
+
if (ret[3]) {
|
|
827
|
+
ptr1 = 0; len1 = 0;
|
|
828
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
829
|
+
}
|
|
830
|
+
deferred2_0 = ptr1;
|
|
831
|
+
deferred2_1 = len1;
|
|
832
|
+
return getStringFromWasm0(ptr1, len1);
|
|
833
|
+
} finally {
|
|
834
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
835
|
+
}
|
|
836
|
+
}
|
|
837
|
+
/**
|
|
838
|
+
* @param {string} traits_json
|
|
839
|
+
*/
|
|
840
|
+
mount(traits_json) {
|
|
841
|
+
const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
842
|
+
const len0 = WASM_VECTOR_LEN;
|
|
843
|
+
const ret = wasm.kernel_mount(this.__wbg_ptr, ptr0, len0);
|
|
844
|
+
if (ret[1]) {
|
|
845
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
846
|
+
}
|
|
847
|
+
}
|
|
848
|
+
/**
|
|
849
|
+
* @param {string} resolved_schema_json
|
|
850
|
+
* @param {string} client_id
|
|
851
|
+
*/
|
|
852
|
+
constructor(resolved_schema_json, client_id) {
|
|
853
|
+
const ptr0 = passStringToWasm0(resolved_schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
854
|
+
const len0 = WASM_VECTOR_LEN;
|
|
855
|
+
const ptr1 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
856
|
+
const len1 = WASM_VECTOR_LEN;
|
|
857
|
+
const ret = wasm.kernel_new(ptr0, len0, ptr1, len1);
|
|
858
|
+
if (ret[2]) {
|
|
859
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
860
|
+
}
|
|
861
|
+
this.__wbg_ptr = ret[0];
|
|
862
|
+
KernelFinalization.register(this, this.__wbg_ptr, this);
|
|
863
|
+
return this;
|
|
864
|
+
}
|
|
865
|
+
/**
|
|
866
|
+
* @returns {string | undefined}
|
|
867
|
+
*/
|
|
868
|
+
nextFold() {
|
|
869
|
+
const ret = wasm.kernel_nextFold(this.__wbg_ptr);
|
|
870
|
+
if (ret[3]) {
|
|
871
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
872
|
+
}
|
|
873
|
+
let v1;
|
|
874
|
+
if (ret[0] !== 0) {
|
|
875
|
+
v1 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
876
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
877
|
+
}
|
|
878
|
+
return v1;
|
|
879
|
+
}
|
|
880
|
+
/**
|
|
881
|
+
* @returns {number}
|
|
882
|
+
*/
|
|
883
|
+
openFlight() {
|
|
884
|
+
const ret = wasm.kernel_openFlight(this.__wbg_ptr);
|
|
885
|
+
return ret;
|
|
886
|
+
}
|
|
887
|
+
/**
|
|
888
|
+
* @param {string | null} [page]
|
|
889
|
+
* @param {string | null} [route]
|
|
890
|
+
* @returns {string}
|
|
891
|
+
*/
|
|
892
|
+
pageCircuit(page, route) {
|
|
893
|
+
let deferred4_0;
|
|
894
|
+
let deferred4_1;
|
|
895
|
+
try {
|
|
896
|
+
var ptr0 = isLikeNone(page) ? 0 : passStringToWasm0(page, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
897
|
+
var len0 = WASM_VECTOR_LEN;
|
|
898
|
+
var ptr1 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
899
|
+
var len1 = WASM_VECTOR_LEN;
|
|
900
|
+
const ret = wasm.kernel_pageCircuit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
901
|
+
var ptr3 = ret[0];
|
|
902
|
+
var len3 = ret[1];
|
|
903
|
+
if (ret[3]) {
|
|
904
|
+
ptr3 = 0; len3 = 0;
|
|
905
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
906
|
+
}
|
|
907
|
+
deferred4_0 = ptr3;
|
|
908
|
+
deferred4_1 = len3;
|
|
909
|
+
return getStringFromWasm0(ptr3, len3);
|
|
910
|
+
} finally {
|
|
911
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
912
|
+
}
|
|
913
|
+
}
|
|
914
|
+
/**
|
|
915
|
+
* @param {string} traits_json
|
|
916
|
+
* @returns {string}
|
|
917
|
+
*/
|
|
918
|
+
remount(traits_json) {
|
|
919
|
+
let deferred3_0;
|
|
920
|
+
let deferred3_1;
|
|
921
|
+
try {
|
|
922
|
+
const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
923
|
+
const len0 = WASM_VECTOR_LEN;
|
|
924
|
+
const ret = wasm.kernel_remount(this.__wbg_ptr, ptr0, len0);
|
|
925
|
+
var ptr2 = ret[0];
|
|
926
|
+
var len2 = ret[1];
|
|
927
|
+
if (ret[3]) {
|
|
928
|
+
ptr2 = 0; len2 = 0;
|
|
929
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
930
|
+
}
|
|
931
|
+
deferred3_0 = ptr2;
|
|
932
|
+
deferred3_1 = len2;
|
|
933
|
+
return getStringFromWasm0(ptr2, len2);
|
|
934
|
+
} finally {
|
|
935
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
936
|
+
}
|
|
937
|
+
}
|
|
938
|
+
/**
|
|
939
|
+
* @param {string} seeds_json
|
|
940
|
+
* @param {string | null} [entity_id]
|
|
941
|
+
* @returns {string}
|
|
942
|
+
*/
|
|
943
|
+
reseedLeg(seeds_json, entity_id) {
|
|
944
|
+
let deferred4_0;
|
|
945
|
+
let deferred4_1;
|
|
946
|
+
try {
|
|
947
|
+
const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
948
|
+
const len0 = WASM_VECTOR_LEN;
|
|
949
|
+
var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
950
|
+
var len1 = WASM_VECTOR_LEN;
|
|
951
|
+
const ret = wasm.kernel_reseedLeg(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
952
|
+
var ptr3 = ret[0];
|
|
953
|
+
var len3 = ret[1];
|
|
954
|
+
if (ret[3]) {
|
|
955
|
+
ptr3 = 0; len3 = 0;
|
|
956
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
957
|
+
}
|
|
958
|
+
deferred4_0 = ptr3;
|
|
959
|
+
deferred4_1 = len3;
|
|
960
|
+
return getStringFromWasm0(ptr3, len3);
|
|
961
|
+
} finally {
|
|
962
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
963
|
+
}
|
|
964
|
+
}
|
|
965
|
+
/**
|
|
966
|
+
* A row-set reference resolved against this kernel's rows for its current user (`{ rows, total }`).
|
|
967
|
+
* @param {string} ref_json
|
|
968
|
+
* @returns {string}
|
|
969
|
+
*/
|
|
970
|
+
resolveRows(ref_json) {
|
|
971
|
+
let deferred3_0;
|
|
972
|
+
let deferred3_1;
|
|
973
|
+
try {
|
|
974
|
+
const ptr0 = passStringToWasm0(ref_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
975
|
+
const len0 = WASM_VECTOR_LEN;
|
|
976
|
+
const ret = wasm.kernel_resolveRows(this.__wbg_ptr, ptr0, len0);
|
|
977
|
+
var ptr2 = ret[0];
|
|
978
|
+
var len2 = ret[1];
|
|
979
|
+
if (ret[3]) {
|
|
980
|
+
ptr2 = 0; len2 = 0;
|
|
981
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
982
|
+
}
|
|
983
|
+
deferred3_0 = ptr2;
|
|
984
|
+
deferred3_1 = len2;
|
|
985
|
+
return getStringFromWasm0(ptr2, len2);
|
|
986
|
+
} finally {
|
|
987
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
988
|
+
}
|
|
989
|
+
}
|
|
990
|
+
/**
|
|
991
|
+
* @param {string} trait_name
|
|
992
|
+
* @param {string | null | undefined} entity_id
|
|
993
|
+
* @param {string} snapshot_json
|
|
994
|
+
* @returns {string}
|
|
995
|
+
*/
|
|
996
|
+
restore(trait_name, entity_id, snapshot_json) {
|
|
997
|
+
let deferred5_0;
|
|
998
|
+
let deferred5_1;
|
|
999
|
+
try {
|
|
1000
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1001
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1002
|
+
var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1003
|
+
var len1 = WASM_VECTOR_LEN;
|
|
1004
|
+
const ptr2 = passStringToWasm0(snapshot_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1005
|
+
const len2 = WASM_VECTOR_LEN;
|
|
1006
|
+
const ret = wasm.kernel_restore(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
1007
|
+
var ptr4 = ret[0];
|
|
1008
|
+
var len4 = ret[1];
|
|
1009
|
+
if (ret[3]) {
|
|
1010
|
+
ptr4 = 0; len4 = 0;
|
|
1011
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1012
|
+
}
|
|
1013
|
+
deferred5_0 = ptr4;
|
|
1014
|
+
deferred5_1 = len4;
|
|
1015
|
+
return getStringFromWasm0(ptr4, len4);
|
|
1016
|
+
} finally {
|
|
1017
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
1018
|
+
}
|
|
1019
|
+
}
|
|
1020
|
+
/**
|
|
1021
|
+
* @param {string} route_path
|
|
1022
|
+
* @returns {string}
|
|
1023
|
+
*/
|
|
1024
|
+
routeMounts(route_path) {
|
|
1025
|
+
let deferred3_0;
|
|
1026
|
+
let deferred3_1;
|
|
1027
|
+
try {
|
|
1028
|
+
const ptr0 = passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1029
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1030
|
+
const ret = wasm.kernel_routeMounts(this.__wbg_ptr, ptr0, len0);
|
|
1031
|
+
var ptr2 = ret[0];
|
|
1032
|
+
var len2 = ret[1];
|
|
1033
|
+
if (ret[3]) {
|
|
1034
|
+
ptr2 = 0; len2 = 0;
|
|
1035
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1036
|
+
}
|
|
1037
|
+
deferred3_0 = ptr2;
|
|
1038
|
+
deferred3_1 = len2;
|
|
1039
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1040
|
+
} finally {
|
|
1041
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1042
|
+
}
|
|
1043
|
+
}
|
|
1044
|
+
/**
|
|
1045
|
+
* @param {string} entity_type
|
|
1046
|
+
* @param {string} rows_json
|
|
1047
|
+
*/
|
|
1048
|
+
seed(entity_type, rows_json) {
|
|
1049
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1050
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1051
|
+
const ptr1 = passStringToWasm0(rows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1052
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1053
|
+
const ret = wasm.kernel_seed(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1054
|
+
if (ret[1]) {
|
|
1055
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1056
|
+
}
|
|
1057
|
+
}
|
|
1058
|
+
/**
|
|
1059
|
+
* The theme key bound to this client's session (`theme/set`, mirrored from the server's frames), or `undefined`.
|
|
1060
|
+
* @returns {string | undefined}
|
|
1061
|
+
*/
|
|
1062
|
+
sessionTheme() {
|
|
1063
|
+
const ret = wasm.kernel_sessionTheme(this.__wbg_ptr);
|
|
1064
|
+
let v1;
|
|
1065
|
+
if (ret[0] !== 0) {
|
|
1066
|
+
v1 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
1067
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
1068
|
+
}
|
|
1069
|
+
return v1;
|
|
1070
|
+
}
|
|
1071
|
+
/**
|
|
1072
|
+
* Carry each tick's `effectResults` on the frame response, for a verifier. Off by default (P-015).
|
|
1073
|
+
* @param {boolean} carry
|
|
1074
|
+
*/
|
|
1075
|
+
setFrameEffectResults(carry) {
|
|
1076
|
+
wasm.kernel_setFrameEffectResults(this.__wbg_ptr, carry);
|
|
1077
|
+
}
|
|
1078
|
+
/**
|
|
1079
|
+
* The host runs the listeners of every emit it marks `dispatched` (the JS runtime, `orbital-server`).
|
|
1080
|
+
* @param {boolean} fans_out
|
|
1081
|
+
*/
|
|
1082
|
+
setHostFansOut(fans_out) {
|
|
1083
|
+
wasm.kernel_setHostFansOut(this.__wbg_ptr, fans_out);
|
|
1084
|
+
}
|
|
1085
|
+
/**
|
|
1086
|
+
* Carry each hop's `@entity` before and after it on the dispatch's transitions (`observed`), for a verifier
|
|
1087
|
+
* judging `@ensures`. Off by default (EXEC-STEP-10).
|
|
1088
|
+
* @param {boolean} record
|
|
1089
|
+
*/
|
|
1090
|
+
setRecordEntityAfter(record) {
|
|
1091
|
+
wasm.kernel_setRecordEntityAfter(this.__wbg_ptr, record);
|
|
1092
|
+
}
|
|
1093
|
+
/**
|
|
1094
|
+
* @param {string} mode
|
|
1095
|
+
*/
|
|
1096
|
+
setThemeMode(mode) {
|
|
1097
|
+
const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1098
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1099
|
+
const ret = wasm.kernel_setThemeMode(this.__wbg_ptr, ptr0, len0);
|
|
1100
|
+
if (ret[1]) {
|
|
1101
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1102
|
+
}
|
|
1103
|
+
}
|
|
1104
|
+
/**
|
|
1105
|
+
* Record each dispatch as a trace item while on, for the host's `program/live { kind: "trace" }` streams.
|
|
1106
|
+
* @param {boolean} on
|
|
1107
|
+
*/
|
|
1108
|
+
setTraceOn(on) {
|
|
1109
|
+
wasm.kernel_setTraceOn(this.__wbg_ptr, on);
|
|
1110
|
+
}
|
|
1111
|
+
/**
|
|
1112
|
+
* The host's report of whether a trait's rendered output is on screen; gates its `[visible]` ticks.
|
|
1113
|
+
* @param {string} trait_name
|
|
1114
|
+
* @param {boolean} on_screen
|
|
1115
|
+
*/
|
|
1116
|
+
setTraitOnScreen(trait_name, on_screen) {
|
|
1117
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1118
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1119
|
+
wasm.kernel_setTraitOnScreen(this.__wbg_ptr, ptr0, len0, on_screen);
|
|
1120
|
+
}
|
|
1121
|
+
/**
|
|
1122
|
+
* The page's locale `i18n/t` paints in when a dispatch names none; the program carries its own messages.
|
|
1123
|
+
* @param {string | null} [locale]
|
|
1124
|
+
*/
|
|
1125
|
+
setViewerLocale(locale) {
|
|
1126
|
+
var ptr0 = isLikeNone(locale) ? 0 : passStringToWasm0(locale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1127
|
+
var len0 = WASM_VECTOR_LEN;
|
|
1128
|
+
const ret = wasm.kernel_setViewerLocale(this.__wbg_ptr, ptr0, len0);
|
|
1129
|
+
if (ret[1]) {
|
|
1130
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1131
|
+
}
|
|
1132
|
+
}
|
|
1133
|
+
/**
|
|
1134
|
+
* @returns {string}
|
|
1135
|
+
*/
|
|
1136
|
+
snapshot() {
|
|
1137
|
+
let deferred2_0;
|
|
1138
|
+
let deferred2_1;
|
|
1139
|
+
try {
|
|
1140
|
+
const ret = wasm.kernel_snapshot(this.__wbg_ptr);
|
|
1141
|
+
var ptr1 = ret[0];
|
|
1142
|
+
var len1 = ret[1];
|
|
1143
|
+
if (ret[3]) {
|
|
1144
|
+
ptr1 = 0; len1 = 0;
|
|
1145
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1146
|
+
}
|
|
1147
|
+
deferred2_0 = ptr1;
|
|
1148
|
+
deferred2_1 = len1;
|
|
1149
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1150
|
+
} finally {
|
|
1151
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1152
|
+
}
|
|
1153
|
+
}
|
|
1154
|
+
/**
|
|
1155
|
+
* @param {string} leg_json
|
|
1156
|
+
* @returns {string}
|
|
1157
|
+
*/
|
|
1158
|
+
statefulLeg(leg_json) {
|
|
1159
|
+
let deferred3_0;
|
|
1160
|
+
let deferred3_1;
|
|
1161
|
+
try {
|
|
1162
|
+
const ptr0 = passStringToWasm0(leg_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1163
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1164
|
+
const ret = wasm.kernel_statefulLeg(this.__wbg_ptr, ptr0, len0);
|
|
1165
|
+
var ptr2 = ret[0];
|
|
1166
|
+
var len2 = ret[1];
|
|
1167
|
+
if (ret[3]) {
|
|
1168
|
+
ptr2 = 0; len2 = 0;
|
|
1169
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1170
|
+
}
|
|
1171
|
+
deferred3_0 = ptr2;
|
|
1172
|
+
deferred3_1 = len2;
|
|
1173
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1174
|
+
} finally {
|
|
1175
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1176
|
+
}
|
|
1177
|
+
}
|
|
1178
|
+
/**
|
|
1179
|
+
* The trace items recorded since the last take, in dispatch order: a JSON array.
|
|
1180
|
+
* @returns {string}
|
|
1181
|
+
*/
|
|
1182
|
+
takeTrace() {
|
|
1183
|
+
let deferred2_0;
|
|
1184
|
+
let deferred2_1;
|
|
1185
|
+
try {
|
|
1186
|
+
const ret = wasm.kernel_takeTrace(this.__wbg_ptr);
|
|
1187
|
+
var ptr1 = ret[0];
|
|
1188
|
+
var len1 = ret[1];
|
|
1189
|
+
if (ret[3]) {
|
|
1190
|
+
ptr1 = 0; len1 = 0;
|
|
1191
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1192
|
+
}
|
|
1193
|
+
deferred2_0 = ptr1;
|
|
1194
|
+
deferred2_1 = len1;
|
|
1195
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1196
|
+
} finally {
|
|
1197
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1198
|
+
}
|
|
1199
|
+
}
|
|
1200
|
+
/**
|
|
1201
|
+
* @param {string} trait_name
|
|
1202
|
+
* @param {string} tick_name
|
|
1203
|
+
* @param {string | null} [entity_id]
|
|
1204
|
+
* @returns {string}
|
|
1205
|
+
*/
|
|
1206
|
+
tick(trait_name, tick_name, entity_id) {
|
|
1207
|
+
let deferred5_0;
|
|
1208
|
+
let deferred5_1;
|
|
1209
|
+
try {
|
|
1210
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1211
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1212
|
+
const ptr1 = passStringToWasm0(tick_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1213
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1214
|
+
var ptr2 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1215
|
+
var len2 = WASM_VECTOR_LEN;
|
|
1216
|
+
const ret = wasm.kernel_tick(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
1217
|
+
var ptr4 = ret[0];
|
|
1218
|
+
var len4 = ret[1];
|
|
1219
|
+
if (ret[3]) {
|
|
1220
|
+
ptr4 = 0; len4 = 0;
|
|
1221
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1222
|
+
}
|
|
1223
|
+
deferred5_0 = ptr4;
|
|
1224
|
+
deferred5_1 = len4;
|
|
1225
|
+
return getStringFromWasm0(ptr4, len4);
|
|
1226
|
+
} finally {
|
|
1227
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
1228
|
+
}
|
|
1229
|
+
}
|
|
1230
|
+
/**
|
|
1231
|
+
* @returns {number}
|
|
1232
|
+
*/
|
|
1233
|
+
tickCount() {
|
|
1234
|
+
const ret = wasm.kernel_tickCount(this.__wbg_ptr);
|
|
1235
|
+
return ret >>> 0;
|
|
1236
|
+
}
|
|
1237
|
+
/**
|
|
1238
|
+
* The config the kernel binds as `@config` for a registered trait, as JSON text.
|
|
1239
|
+
* @param {string} trait_name
|
|
1240
|
+
* @returns {string}
|
|
1241
|
+
*/
|
|
1242
|
+
traitConfig(trait_name) {
|
|
1243
|
+
let deferred3_0;
|
|
1244
|
+
let deferred3_1;
|
|
1245
|
+
try {
|
|
1246
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1247
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1248
|
+
const ret = wasm.kernel_traitConfig(this.__wbg_ptr, ptr0, len0);
|
|
1249
|
+
var ptr2 = ret[0];
|
|
1250
|
+
var len2 = ret[1];
|
|
1251
|
+
if (ret[3]) {
|
|
1252
|
+
ptr2 = 0; len2 = 0;
|
|
1253
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1254
|
+
}
|
|
1255
|
+
deferred3_0 = ptr2;
|
|
1256
|
+
deferred3_1 = len2;
|
|
1257
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1258
|
+
} finally {
|
|
1259
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1260
|
+
}
|
|
1261
|
+
}
|
|
1262
|
+
/**
|
|
1263
|
+
* @param {string} traits_json
|
|
1264
|
+
* @returns {string}
|
|
1265
|
+
*/
|
|
1266
|
+
unmount(traits_json) {
|
|
1267
|
+
let deferred3_0;
|
|
1268
|
+
let deferred3_1;
|
|
1269
|
+
try {
|
|
1270
|
+
const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1271
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1272
|
+
const ret = wasm.kernel_unmount(this.__wbg_ptr, ptr0, len0);
|
|
1273
|
+
var ptr2 = ret[0];
|
|
1274
|
+
var len2 = ret[1];
|
|
1275
|
+
if (ret[3]) {
|
|
1276
|
+
ptr2 = 0; len2 = 0;
|
|
1277
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1278
|
+
}
|
|
1279
|
+
deferred3_0 = ptr2;
|
|
1280
|
+
deferred3_1 = len2;
|
|
1281
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1282
|
+
} finally {
|
|
1283
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1284
|
+
}
|
|
1285
|
+
}
|
|
1286
|
+
}
|
|
1287
|
+
if (Symbol.dispose) Kernel.prototype[Symbol.dispose] = Kernel.prototype.free;
|
|
1288
|
+
|
|
1289
|
+
export class MemoryStore {
|
|
1290
|
+
__destroy_into_raw() {
|
|
1291
|
+
const ptr = this.__wbg_ptr;
|
|
1292
|
+
this.__wbg_ptr = 0;
|
|
1293
|
+
MemoryStoreFinalization.unregister(this);
|
|
1294
|
+
return ptr;
|
|
1295
|
+
}
|
|
1296
|
+
free() {
|
|
1297
|
+
const ptr = this.__destroy_into_raw();
|
|
1298
|
+
wasm.__wbg_memorystore_free(ptr, 0);
|
|
1299
|
+
}
|
|
1300
|
+
/**
|
|
1301
|
+
* @param {string} entity_type
|
|
1302
|
+
* @param {string} collection
|
|
1303
|
+
*/
|
|
1304
|
+
bindCollection(entity_type, collection) {
|
|
1305
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1306
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1307
|
+
const ptr1 = passStringToWasm0(collection, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1308
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1309
|
+
wasm.memorystore_bindCollection(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1310
|
+
}
|
|
1311
|
+
clear() {
|
|
1312
|
+
wasm.memorystore_clear(this.__wbg_ptr);
|
|
1313
|
+
}
|
|
1314
|
+
/**
|
|
1315
|
+
* @param {string} entity_type
|
|
1316
|
+
* @param {string} data_json
|
|
1317
|
+
* @returns {string}
|
|
1318
|
+
*/
|
|
1319
|
+
create(entity_type, data_json) {
|
|
1320
|
+
let deferred4_0;
|
|
1321
|
+
let deferred4_1;
|
|
1322
|
+
try {
|
|
1323
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1324
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1325
|
+
const ptr1 = passStringToWasm0(data_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1326
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1327
|
+
const ret = wasm.memorystore_create(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1328
|
+
var ptr3 = ret[0];
|
|
1329
|
+
var len3 = ret[1];
|
|
1330
|
+
if (ret[3]) {
|
|
1331
|
+
ptr3 = 0; len3 = 0;
|
|
1332
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1333
|
+
}
|
|
1334
|
+
deferred4_0 = ptr3;
|
|
1335
|
+
deferred4_1 = len3;
|
|
1336
|
+
return getStringFromWasm0(ptr3, len3);
|
|
1337
|
+
} finally {
|
|
1338
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
1339
|
+
}
|
|
1340
|
+
}
|
|
1341
|
+
/**
|
|
1342
|
+
* @param {string} entity_type
|
|
1343
|
+
* @param {string} id
|
|
1344
|
+
*/
|
|
1345
|
+
delete(entity_type, id) {
|
|
1346
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1347
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1348
|
+
const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1349
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1350
|
+
const ret = wasm.memorystore_delete(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1351
|
+
if (ret[1]) {
|
|
1352
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1353
|
+
}
|
|
1354
|
+
}
|
|
1355
|
+
/**
|
|
1356
|
+
* @param {string} entity_type
|
|
1357
|
+
* @param {string} id
|
|
1358
|
+
* @returns {string}
|
|
1359
|
+
*/
|
|
1360
|
+
getById(entity_type, id) {
|
|
1361
|
+
let deferred4_0;
|
|
1362
|
+
let deferred4_1;
|
|
1363
|
+
try {
|
|
1364
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1365
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1366
|
+
const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1367
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1368
|
+
const ret = wasm.memorystore_getById(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1369
|
+
var ptr3 = ret[0];
|
|
1370
|
+
var len3 = ret[1];
|
|
1371
|
+
if (ret[3]) {
|
|
1372
|
+
ptr3 = 0; len3 = 0;
|
|
1373
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1374
|
+
}
|
|
1375
|
+
deferred4_0 = ptr3;
|
|
1376
|
+
deferred4_1 = len3;
|
|
1377
|
+
return getStringFromWasm0(ptr3, len3);
|
|
1378
|
+
} finally {
|
|
1379
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
1380
|
+
}
|
|
1381
|
+
}
|
|
1382
|
+
/**
|
|
1383
|
+
* @param {string} entity_type
|
|
1384
|
+
* @returns {string}
|
|
1385
|
+
*/
|
|
1386
|
+
list(entity_type) {
|
|
1387
|
+
let deferred3_0;
|
|
1388
|
+
let deferred3_1;
|
|
1389
|
+
try {
|
|
1390
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1391
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1392
|
+
const ret = wasm.memorystore_list(this.__wbg_ptr, ptr0, len0);
|
|
1393
|
+
var ptr2 = ret[0];
|
|
1394
|
+
var len2 = ret[1];
|
|
1395
|
+
if (ret[3]) {
|
|
1396
|
+
ptr2 = 0; len2 = 0;
|
|
1397
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1398
|
+
}
|
|
1399
|
+
deferred3_0 = ptr2;
|
|
1400
|
+
deferred3_1 = len2;
|
|
1401
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1402
|
+
} finally {
|
|
1403
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1404
|
+
}
|
|
1405
|
+
}
|
|
1406
|
+
constructor() {
|
|
1407
|
+
const ret = wasm.memorystore_new();
|
|
1408
|
+
this.__wbg_ptr = ret;
|
|
1409
|
+
MemoryStoreFinalization.register(this, this.__wbg_ptr, this);
|
|
1410
|
+
return this;
|
|
1411
|
+
}
|
|
1412
|
+
/**
|
|
1413
|
+
* @returns {string}
|
|
1414
|
+
*/
|
|
1415
|
+
queryCapabilities() {
|
|
1416
|
+
let deferred2_0;
|
|
1417
|
+
let deferred2_1;
|
|
1418
|
+
try {
|
|
1419
|
+
const ret = wasm.memorystore_queryCapabilities(this.__wbg_ptr);
|
|
1420
|
+
var ptr1 = ret[0];
|
|
1421
|
+
var len1 = ret[1];
|
|
1422
|
+
if (ret[3]) {
|
|
1423
|
+
ptr1 = 0; len1 = 0;
|
|
1424
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1425
|
+
}
|
|
1426
|
+
deferred2_0 = ptr1;
|
|
1427
|
+
deferred2_1 = len1;
|
|
1428
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1429
|
+
} finally {
|
|
1430
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1431
|
+
}
|
|
1432
|
+
}
|
|
1433
|
+
/**
|
|
1434
|
+
* @param {string} entity_type
|
|
1435
|
+
* @param {string} query_json
|
|
1436
|
+
* @returns {string}
|
|
1437
|
+
*/
|
|
1438
|
+
queryIds(entity_type, query_json) {
|
|
1439
|
+
let deferred4_0;
|
|
1440
|
+
let deferred4_1;
|
|
1441
|
+
try {
|
|
1442
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1443
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1444
|
+
const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1445
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1446
|
+
const ret = wasm.memorystore_queryIds(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1447
|
+
var ptr3 = ret[0];
|
|
1448
|
+
var len3 = ret[1];
|
|
1449
|
+
if (ret[3]) {
|
|
1450
|
+
ptr3 = 0; len3 = 0;
|
|
1451
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1452
|
+
}
|
|
1453
|
+
deferred4_0 = ptr3;
|
|
1454
|
+
deferred4_1 = len3;
|
|
1455
|
+
return getStringFromWasm0(ptr3, len3);
|
|
1456
|
+
} finally {
|
|
1457
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
1458
|
+
}
|
|
1459
|
+
}
|
|
1460
|
+
/**
|
|
1461
|
+
* @param {string} entity_type
|
|
1462
|
+
* @param {string} query_json
|
|
1463
|
+
* @returns {string}
|
|
1464
|
+
*/
|
|
1465
|
+
queryPage(entity_type, query_json) {
|
|
1466
|
+
let deferred4_0;
|
|
1467
|
+
let deferred4_1;
|
|
1468
|
+
try {
|
|
1469
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1470
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1471
|
+
const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1472
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1473
|
+
const ret = wasm.memorystore_queryPage(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1474
|
+
var ptr3 = ret[0];
|
|
1475
|
+
var len3 = ret[1];
|
|
1476
|
+
if (ret[3]) {
|
|
1477
|
+
ptr3 = 0; len3 = 0;
|
|
1478
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1479
|
+
}
|
|
1480
|
+
deferred4_0 = ptr3;
|
|
1481
|
+
deferred4_1 = len3;
|
|
1482
|
+
return getStringFromWasm0(ptr3, len3);
|
|
1483
|
+
} finally {
|
|
1484
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
1485
|
+
}
|
|
1486
|
+
}
|
|
1487
|
+
/**
|
|
1488
|
+
* @returns {string}
|
|
1489
|
+
*/
|
|
1490
|
+
snapshot() {
|
|
1491
|
+
let deferred2_0;
|
|
1492
|
+
let deferred2_1;
|
|
1493
|
+
try {
|
|
1494
|
+
const ret = wasm.memorystore_snapshot(this.__wbg_ptr);
|
|
1495
|
+
var ptr1 = ret[0];
|
|
1496
|
+
var len1 = ret[1];
|
|
1497
|
+
if (ret[3]) {
|
|
1498
|
+
ptr1 = 0; len1 = 0;
|
|
1499
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1500
|
+
}
|
|
1501
|
+
deferred2_0 = ptr1;
|
|
1502
|
+
deferred2_1 = len1;
|
|
1503
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1504
|
+
} finally {
|
|
1505
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1506
|
+
}
|
|
1507
|
+
}
|
|
1508
|
+
/**
|
|
1509
|
+
* @param {string} entity_type
|
|
1510
|
+
* @param {string} id
|
|
1511
|
+
* @param {string} data_json
|
|
1512
|
+
* @returns {string}
|
|
1513
|
+
*/
|
|
1514
|
+
update(entity_type, id, data_json) {
|
|
1515
|
+
let deferred5_0;
|
|
1516
|
+
let deferred5_1;
|
|
1517
|
+
try {
|
|
1518
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1519
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1520
|
+
const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1521
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1522
|
+
const ptr2 = passStringToWasm0(data_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1523
|
+
const len2 = WASM_VECTOR_LEN;
|
|
1524
|
+
const ret = wasm.memorystore_update(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
1525
|
+
var ptr4 = ret[0];
|
|
1526
|
+
var len4 = ret[1];
|
|
1527
|
+
if (ret[3]) {
|
|
1528
|
+
ptr4 = 0; len4 = 0;
|
|
1529
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1530
|
+
}
|
|
1531
|
+
deferred5_0 = ptr4;
|
|
1532
|
+
deferred5_1 = len4;
|
|
1533
|
+
return getStringFromWasm0(ptr4, len4);
|
|
1534
|
+
} finally {
|
|
1535
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
1536
|
+
}
|
|
1537
|
+
}
|
|
1538
|
+
/**
|
|
1539
|
+
* @param {string} batch_json
|
|
1540
|
+
* @returns {string}
|
|
1541
|
+
*/
|
|
1542
|
+
writeBatch(batch_json) {
|
|
1543
|
+
let deferred3_0;
|
|
1544
|
+
let deferred3_1;
|
|
1545
|
+
try {
|
|
1546
|
+
const ptr0 = passStringToWasm0(batch_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1547
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1548
|
+
const ret = wasm.memorystore_writeBatch(this.__wbg_ptr, ptr0, len0);
|
|
1549
|
+
var ptr2 = ret[0];
|
|
1550
|
+
var len2 = ret[1];
|
|
1551
|
+
if (ret[3]) {
|
|
1552
|
+
ptr2 = 0; len2 = 0;
|
|
1553
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1554
|
+
}
|
|
1555
|
+
deferred3_0 = ptr2;
|
|
1556
|
+
deferred3_1 = len2;
|
|
1557
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1558
|
+
} finally {
|
|
1559
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1560
|
+
}
|
|
1561
|
+
}
|
|
1562
|
+
/**
|
|
1563
|
+
* @returns {string}
|
|
1564
|
+
*/
|
|
1565
|
+
writeCapabilities() {
|
|
1566
|
+
let deferred2_0;
|
|
1567
|
+
let deferred2_1;
|
|
1568
|
+
try {
|
|
1569
|
+
const ret = wasm.memorystore_writeCapabilities(this.__wbg_ptr);
|
|
1570
|
+
var ptr1 = ret[0];
|
|
1571
|
+
var len1 = ret[1];
|
|
1572
|
+
if (ret[3]) {
|
|
1573
|
+
ptr1 = 0; len1 = 0;
|
|
1574
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1575
|
+
}
|
|
1576
|
+
deferred2_0 = ptr1;
|
|
1577
|
+
deferred2_1 = len1;
|
|
1578
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1579
|
+
} finally {
|
|
1580
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1581
|
+
}
|
|
1582
|
+
}
|
|
1583
|
+
/**
|
|
1584
|
+
* @param {string} op_json
|
|
1585
|
+
* @returns {string}
|
|
1586
|
+
*/
|
|
1587
|
+
writeWhere(op_json) {
|
|
1588
|
+
let deferred3_0;
|
|
1589
|
+
let deferred3_1;
|
|
1590
|
+
try {
|
|
1591
|
+
const ptr0 = passStringToWasm0(op_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1592
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1593
|
+
const ret = wasm.memorystore_writeWhere(this.__wbg_ptr, ptr0, len0);
|
|
1594
|
+
var ptr2 = ret[0];
|
|
1595
|
+
var len2 = ret[1];
|
|
1596
|
+
if (ret[3]) {
|
|
1597
|
+
ptr2 = 0; len2 = 0;
|
|
1598
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1599
|
+
}
|
|
1600
|
+
deferred3_0 = ptr2;
|
|
1601
|
+
deferred3_1 = len2;
|
|
1602
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1603
|
+
} finally {
|
|
1604
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1605
|
+
}
|
|
1606
|
+
}
|
|
1607
|
+
}
|
|
1608
|
+
if (Symbol.dispose) MemoryStore.prototype[Symbol.dispose] = MemoryStore.prototype.free;
|
|
1609
|
+
|
|
1610
|
+
/**
|
|
1611
|
+
* The server role: `start` a request, answer the I/O it asks for, `resume` the flight until it is done.
|
|
1612
|
+
*/
|
|
1613
|
+
export class Server {
|
|
1614
|
+
static __wrap(ptr) {
|
|
1615
|
+
const obj = Object.create(Server.prototype);
|
|
1616
|
+
obj.__wbg_ptr = ptr;
|
|
1617
|
+
ServerFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1618
|
+
return obj;
|
|
1619
|
+
}
|
|
1620
|
+
__destroy_into_raw() {
|
|
1621
|
+
const ptr = this.__wbg_ptr;
|
|
1622
|
+
this.__wbg_ptr = 0;
|
|
1623
|
+
ServerFinalization.unregister(this);
|
|
1624
|
+
return ptr;
|
|
1625
|
+
}
|
|
1626
|
+
free() {
|
|
1627
|
+
const ptr = this.__destroy_into_raw();
|
|
1628
|
+
wasm.__wbg_server_free(ptr, 0);
|
|
1629
|
+
}
|
|
1630
|
+
/**
|
|
1631
|
+
* @param {number} flight
|
|
1632
|
+
* @returns {boolean}
|
|
1633
|
+
*/
|
|
1634
|
+
abandon(flight) {
|
|
1635
|
+
const ret = wasm.server_abandon(this.__wbg_ptr, flight);
|
|
1636
|
+
if (ret[2]) {
|
|
1637
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1638
|
+
}
|
|
1639
|
+
return ret[0] !== 0;
|
|
1640
|
+
}
|
|
1641
|
+
/**
|
|
1642
|
+
* @param {string} side
|
|
1643
|
+
* @returns {string}
|
|
1644
|
+
*/
|
|
1645
|
+
bootMounts(side) {
|
|
1646
|
+
let deferred3_0;
|
|
1647
|
+
let deferred3_1;
|
|
1648
|
+
try {
|
|
1649
|
+
const ptr0 = passStringToWasm0(side, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1650
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1651
|
+
const ret = wasm.server_bootMounts(this.__wbg_ptr, ptr0, len0);
|
|
1652
|
+
var ptr2 = ret[0];
|
|
1653
|
+
var len2 = ret[1];
|
|
1654
|
+
if (ret[3]) {
|
|
1655
|
+
ptr2 = 0; len2 = 0;
|
|
1656
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1657
|
+
}
|
|
1658
|
+
deferred3_0 = ptr2;
|
|
1659
|
+
deferred3_1 = len2;
|
|
1660
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1661
|
+
} finally {
|
|
1662
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1663
|
+
}
|
|
1664
|
+
}
|
|
1665
|
+
/**
|
|
1666
|
+
* @param {number} id
|
|
1667
|
+
* @returns {boolean}
|
|
1668
|
+
*/
|
|
1669
|
+
closeSessionStream(id) {
|
|
1670
|
+
const ret = wasm.server_closeSessionStream(this.__wbg_ptr, id);
|
|
1671
|
+
if (ret[2]) {
|
|
1672
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1673
|
+
}
|
|
1674
|
+
return ret[0] !== 0;
|
|
1675
|
+
}
|
|
1676
|
+
/**
|
|
1677
|
+
* One question about the registered program (a `ContractQuery` as JSON): its answer as JSON.
|
|
1678
|
+
* @param {string} query_json
|
|
1679
|
+
* @returns {string}
|
|
1680
|
+
*/
|
|
1681
|
+
contractQuery(query_json) {
|
|
1682
|
+
let deferred3_0;
|
|
1683
|
+
let deferred3_1;
|
|
1684
|
+
try {
|
|
1685
|
+
const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1686
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1687
|
+
const ret = wasm.server_contractQuery(this.__wbg_ptr, ptr0, len0);
|
|
1688
|
+
var ptr2 = ret[0];
|
|
1689
|
+
var len2 = ret[1];
|
|
1690
|
+
if (ret[3]) {
|
|
1691
|
+
ptr2 = 0; len2 = 0;
|
|
1692
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1693
|
+
}
|
|
1694
|
+
deferred3_0 = ptr2;
|
|
1695
|
+
deferred3_1 = len2;
|
|
1696
|
+
return getStringFromWasm0(ptr2, len2);
|
|
1697
|
+
} finally {
|
|
1698
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1699
|
+
}
|
|
1700
|
+
}
|
|
1701
|
+
/**
|
|
1702
|
+
* @returns {boolean}
|
|
1703
|
+
*/
|
|
1704
|
+
declaresTicks() {
|
|
1705
|
+
const ret = wasm.server_declaresTicks(this.__wbg_ptr);
|
|
1706
|
+
return ret !== 0;
|
|
1707
|
+
}
|
|
1708
|
+
/**
|
|
1709
|
+
* @returns {string}
|
|
1710
|
+
*/
|
|
1711
|
+
dispatchStream() {
|
|
1712
|
+
let deferred2_0;
|
|
1713
|
+
let deferred2_1;
|
|
1714
|
+
try {
|
|
1715
|
+
const ret = wasm.server_dispatchStream(this.__wbg_ptr);
|
|
1716
|
+
var ptr1 = ret[0];
|
|
1717
|
+
var len1 = ret[1];
|
|
1718
|
+
if (ret[3]) {
|
|
1719
|
+
ptr1 = 0; len1 = 0;
|
|
1720
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1721
|
+
}
|
|
1722
|
+
deferred2_0 = ptr1;
|
|
1723
|
+
deferred2_1 = len1;
|
|
1724
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1725
|
+
} finally {
|
|
1726
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1727
|
+
}
|
|
1728
|
+
}
|
|
1729
|
+
/**
|
|
1730
|
+
* @param {string} url
|
|
1731
|
+
* @returns {boolean}
|
|
1732
|
+
*/
|
|
1733
|
+
egressAllows(url) {
|
|
1734
|
+
const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1735
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1736
|
+
const ret = wasm.server_egressAllows(this.__wbg_ptr, ptr0, len0);
|
|
1737
|
+
return ret !== 0;
|
|
1738
|
+
}
|
|
1739
|
+
/**
|
|
1740
|
+
* @returns {string}
|
|
1741
|
+
*/
|
|
1742
|
+
flushTickRelay() {
|
|
1743
|
+
let deferred2_0;
|
|
1744
|
+
let deferred2_1;
|
|
1745
|
+
try {
|
|
1746
|
+
const ret = wasm.server_flushTickRelay(this.__wbg_ptr);
|
|
1747
|
+
var ptr1 = ret[0];
|
|
1748
|
+
var len1 = ret[1];
|
|
1749
|
+
if (ret[3]) {
|
|
1750
|
+
ptr1 = 0; len1 = 0;
|
|
1751
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1752
|
+
}
|
|
1753
|
+
deferred2_0 = ptr1;
|
|
1754
|
+
deferred2_1 = len1;
|
|
1755
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1756
|
+
} finally {
|
|
1757
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1758
|
+
}
|
|
1759
|
+
}
|
|
1760
|
+
/**
|
|
1761
|
+
* A server holding this one's registered program and none of its session: what a stateless host serves
|
|
1762
|
+
* each request from, instead of registering the program again.
|
|
1763
|
+
* @returns {Server}
|
|
1764
|
+
*/
|
|
1765
|
+
fork() {
|
|
1766
|
+
const ret = wasm.server_fork(this.__wbg_ptr);
|
|
1767
|
+
if (ret[2]) {
|
|
1768
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1769
|
+
}
|
|
1770
|
+
return Server.__wrap(ret[0]);
|
|
1771
|
+
}
|
|
1772
|
+
/**
|
|
1773
|
+
* @param {string} program_json
|
|
1774
|
+
* @returns {Server}
|
|
1775
|
+
*/
|
|
1776
|
+
forkProgram(program_json) {
|
|
1777
|
+
const ptr0 = passStringToWasm0(program_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1778
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1779
|
+
const ret = wasm.server_forkProgram(this.__wbg_ptr, ptr0, len0);
|
|
1780
|
+
if (ret[2]) {
|
|
1781
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1782
|
+
}
|
|
1783
|
+
return Server.__wrap(ret[0]);
|
|
1784
|
+
}
|
|
1785
|
+
/**
|
|
1786
|
+
* @param {string} trait_name
|
|
1787
|
+
* @param {string | null} [entity_id]
|
|
1788
|
+
* @returns {string}
|
|
1789
|
+
*/
|
|
1790
|
+
getState(trait_name, entity_id) {
|
|
1791
|
+
let deferred3_0;
|
|
1792
|
+
let deferred3_1;
|
|
1793
|
+
try {
|
|
1794
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1795
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1796
|
+
var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1797
|
+
var len1 = WASM_VECTOR_LEN;
|
|
1798
|
+
const ret = wasm.server_getState(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1799
|
+
deferred3_0 = ret[0];
|
|
1800
|
+
deferred3_1 = ret[1];
|
|
1801
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
1802
|
+
} finally {
|
|
1803
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1804
|
+
}
|
|
1805
|
+
}
|
|
1806
|
+
/**
|
|
1807
|
+
* @param {number} flight
|
|
1808
|
+
* @returns {boolean}
|
|
1809
|
+
*/
|
|
1810
|
+
holdsLane(flight) {
|
|
1811
|
+
const ret = wasm.server_holdsLane(this.__wbg_ptr, flight);
|
|
1812
|
+
if (ret[2]) {
|
|
1813
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1814
|
+
}
|
|
1815
|
+
return ret[0] !== 0;
|
|
1816
|
+
}
|
|
1817
|
+
/**
|
|
1818
|
+
* @returns {number}
|
|
1819
|
+
*/
|
|
1820
|
+
inFlight() {
|
|
1821
|
+
const ret = wasm.server_inFlight(this.__wbg_ptr);
|
|
1822
|
+
return ret >>> 0;
|
|
1823
|
+
}
|
|
1824
|
+
/**
|
|
1825
|
+
* @returns {string}
|
|
1826
|
+
*/
|
|
1827
|
+
lastError() {
|
|
1828
|
+
let deferred1_0;
|
|
1829
|
+
let deferred1_1;
|
|
1830
|
+
try {
|
|
1831
|
+
const ret = wasm.server_lastError(this.__wbg_ptr);
|
|
1832
|
+
deferred1_0 = ret[0];
|
|
1833
|
+
deferred1_1 = ret[1];
|
|
1834
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
1835
|
+
} finally {
|
|
1836
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1837
|
+
}
|
|
1838
|
+
}
|
|
1839
|
+
/**
|
|
1840
|
+
* @param {string} item_json
|
|
1841
|
+
* @param {string | null} [client_id]
|
|
1842
|
+
* @returns {boolean}
|
|
1843
|
+
*/
|
|
1844
|
+
liveItemDelivered(item_json, client_id) {
|
|
1845
|
+
const ptr0 = passStringToWasm0(item_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1846
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1847
|
+
var ptr1 = isLikeNone(client_id) ? 0 : passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1848
|
+
var len1 = WASM_VECTOR_LEN;
|
|
1849
|
+
const ret = wasm.server_liveItemDelivered(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1850
|
+
if (ret[2]) {
|
|
1851
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1852
|
+
}
|
|
1853
|
+
return ret[0] !== 0;
|
|
1854
|
+
}
|
|
1855
|
+
/**
|
|
1856
|
+
* @param {string} traits_json
|
|
1857
|
+
*/
|
|
1858
|
+
mount(traits_json) {
|
|
1859
|
+
const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1860
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1861
|
+
const ret = wasm.server_mount(this.__wbg_ptr, ptr0, len0);
|
|
1862
|
+
if (ret[1]) {
|
|
1863
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1864
|
+
}
|
|
1865
|
+
}
|
|
1866
|
+
/**
|
|
1867
|
+
* @param {string} client
|
|
1868
|
+
* @param {string} orbital
|
|
1869
|
+
* @param {string} traits_json
|
|
1870
|
+
*/
|
|
1871
|
+
mountClient(client, orbital, traits_json) {
|
|
1872
|
+
const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1873
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1874
|
+
const ptr1 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1875
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1876
|
+
const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1877
|
+
const len2 = WASM_VECTOR_LEN;
|
|
1878
|
+
const ret = wasm.server_mountClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
1879
|
+
if (ret[1]) {
|
|
1880
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1881
|
+
}
|
|
1882
|
+
}
|
|
1883
|
+
/**
|
|
1884
|
+
* @param {string} resolved_schema_json
|
|
1885
|
+
*/
|
|
1886
|
+
constructor(resolved_schema_json) {
|
|
1887
|
+
const ptr0 = passStringToWasm0(resolved_schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1888
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1889
|
+
const ret = wasm.server_new(ptr0, len0);
|
|
1890
|
+
if (ret[2]) {
|
|
1891
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1892
|
+
}
|
|
1893
|
+
this.__wbg_ptr = ret[0];
|
|
1894
|
+
ServerFinalization.register(this, this.__wbg_ptr, this);
|
|
1895
|
+
return this;
|
|
1896
|
+
}
|
|
1897
|
+
/**
|
|
1898
|
+
* The oldest queued request, started now the lane is free (`NextWire` JSON), or `null`.
|
|
1899
|
+
* @returns {string}
|
|
1900
|
+
*/
|
|
1901
|
+
next() {
|
|
1902
|
+
let deferred2_0;
|
|
1903
|
+
let deferred2_1;
|
|
1904
|
+
try {
|
|
1905
|
+
const ret = wasm.server_next(this.__wbg_ptr);
|
|
1906
|
+
var ptr1 = ret[0];
|
|
1907
|
+
var len1 = ret[1];
|
|
1908
|
+
if (ret[3]) {
|
|
1909
|
+
ptr1 = 0; len1 = 0;
|
|
1910
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1911
|
+
}
|
|
1912
|
+
deferred2_0 = ptr1;
|
|
1913
|
+
deferred2_1 = len1;
|
|
1914
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1915
|
+
} finally {
|
|
1916
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1917
|
+
}
|
|
1918
|
+
}
|
|
1919
|
+
/**
|
|
1920
|
+
* A live stream of `client`'s session opened (EXEC-DIST-9); the id closes it.
|
|
1921
|
+
* @param {string} client
|
|
1922
|
+
* @returns {number}
|
|
1923
|
+
*/
|
|
1924
|
+
openSessionStream(client) {
|
|
1925
|
+
const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1926
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1927
|
+
const ret = wasm.server_openSessionStream(this.__wbg_ptr, ptr0, len0);
|
|
1928
|
+
return ret;
|
|
1929
|
+
}
|
|
1930
|
+
/**
|
|
1931
|
+
* @param {string} requirement_json
|
|
1932
|
+
* @param {string | null} [orbital]
|
|
1933
|
+
* @returns {boolean}
|
|
1934
|
+
*/
|
|
1935
|
+
osAllows(requirement_json, orbital) {
|
|
1936
|
+
const ptr0 = passStringToWasm0(requirement_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1937
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1938
|
+
var ptr1 = isLikeNone(orbital) ? 0 : passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1939
|
+
var len1 = WASM_VECTOR_LEN;
|
|
1940
|
+
const ret = wasm.server_osAllows(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1941
|
+
if (ret[2]) {
|
|
1942
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1943
|
+
}
|
|
1944
|
+
return ret[0] !== 0;
|
|
1945
|
+
}
|
|
1946
|
+
/**
|
|
1947
|
+
* @param {string} op
|
|
1948
|
+
* @param {string} args_json
|
|
1949
|
+
* @returns {string}
|
|
1950
|
+
*/
|
|
1951
|
+
osResolveArgs(op, args_json) {
|
|
1952
|
+
let deferred4_0;
|
|
1953
|
+
let deferred4_1;
|
|
1954
|
+
try {
|
|
1955
|
+
const ptr0 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1956
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1957
|
+
const ptr1 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1958
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1959
|
+
const ret = wasm.server_osResolveArgs(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1960
|
+
var ptr3 = ret[0];
|
|
1961
|
+
var len3 = ret[1];
|
|
1962
|
+
if (ret[3]) {
|
|
1963
|
+
ptr3 = 0; len3 = 0;
|
|
1964
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1965
|
+
}
|
|
1966
|
+
deferred4_0 = ptr3;
|
|
1967
|
+
deferred4_1 = len3;
|
|
1968
|
+
return getStringFromWasm0(ptr3, len3);
|
|
1969
|
+
} finally {
|
|
1970
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
1971
|
+
}
|
|
1972
|
+
}
|
|
1973
|
+
/**
|
|
1974
|
+
* @param {string | null} [page]
|
|
1975
|
+
* @param {string | null} [route]
|
|
1976
|
+
* @returns {string}
|
|
1977
|
+
*/
|
|
1978
|
+
pageCircuit(page, route) {
|
|
1979
|
+
let deferred4_0;
|
|
1980
|
+
let deferred4_1;
|
|
1981
|
+
try {
|
|
1982
|
+
var ptr0 = isLikeNone(page) ? 0 : passStringToWasm0(page, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1983
|
+
var len0 = WASM_VECTOR_LEN;
|
|
1984
|
+
var ptr1 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1985
|
+
var len1 = WASM_VECTOR_LEN;
|
|
1986
|
+
const ret = wasm.server_pageCircuit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1987
|
+
var ptr3 = ret[0];
|
|
1988
|
+
var len3 = ret[1];
|
|
1989
|
+
if (ret[3]) {
|
|
1990
|
+
ptr3 = 0; len3 = 0;
|
|
1991
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1992
|
+
}
|
|
1993
|
+
deferred4_0 = ptr3;
|
|
1994
|
+
deferred4_1 = len3;
|
|
1995
|
+
return getStringFromWasm0(ptr3, len3);
|
|
1996
|
+
} finally {
|
|
1997
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
1998
|
+
}
|
|
1999
|
+
}
|
|
2000
|
+
/**
|
|
2001
|
+
* @param {string} orbital
|
|
2002
|
+
* @param {string} request_json
|
|
2003
|
+
* @returns {string}
|
|
2004
|
+
*/
|
|
2005
|
+
relayTick(orbital, request_json) {
|
|
2006
|
+
let deferred4_0;
|
|
2007
|
+
let deferred4_1;
|
|
2008
|
+
try {
|
|
2009
|
+
const ptr0 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2010
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2011
|
+
const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2012
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2013
|
+
const ret = wasm.server_relayTick(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
2014
|
+
var ptr3 = ret[0];
|
|
2015
|
+
var len3 = ret[1];
|
|
2016
|
+
if (ret[3]) {
|
|
2017
|
+
ptr3 = 0; len3 = 0;
|
|
2018
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2019
|
+
}
|
|
2020
|
+
deferred4_0 = ptr3;
|
|
2021
|
+
deferred4_1 = len3;
|
|
2022
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2023
|
+
} finally {
|
|
2024
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2025
|
+
}
|
|
2026
|
+
}
|
|
2027
|
+
/**
|
|
2028
|
+
* @param {string} client
|
|
2029
|
+
*/
|
|
2030
|
+
releaseClient(client) {
|
|
2031
|
+
const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2032
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2033
|
+
wasm.server_releaseClient(this.__wbg_ptr, ptr0, len0);
|
|
2034
|
+
}
|
|
2035
|
+
/**
|
|
2036
|
+
* @param {string} traits_json
|
|
2037
|
+
*/
|
|
2038
|
+
remount(traits_json) {
|
|
2039
|
+
const ptr0 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2040
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2041
|
+
const ret = wasm.server_remount(this.__wbg_ptr, ptr0, len0);
|
|
2042
|
+
if (ret[1]) {
|
|
2043
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
2044
|
+
}
|
|
2045
|
+
}
|
|
2046
|
+
/**
|
|
2047
|
+
* @param {string} ref_json
|
|
2048
|
+
* @param {string | null} [client_id]
|
|
2049
|
+
* @returns {string}
|
|
2050
|
+
*/
|
|
2051
|
+
resolveRows(ref_json, client_id) {
|
|
2052
|
+
let deferred4_0;
|
|
2053
|
+
let deferred4_1;
|
|
2054
|
+
try {
|
|
2055
|
+
const ptr0 = passStringToWasm0(ref_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2056
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2057
|
+
var ptr1 = isLikeNone(client_id) ? 0 : passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2058
|
+
var len1 = WASM_VECTOR_LEN;
|
|
2059
|
+
const ret = wasm.server_resolveRows(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
2060
|
+
var ptr3 = ret[0];
|
|
2061
|
+
var len3 = ret[1];
|
|
2062
|
+
if (ret[3]) {
|
|
2063
|
+
ptr3 = 0; len3 = 0;
|
|
2064
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2065
|
+
}
|
|
2066
|
+
deferred4_0 = ptr3;
|
|
2067
|
+
deferred4_1 = len3;
|
|
2068
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2069
|
+
} finally {
|
|
2070
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2071
|
+
}
|
|
2072
|
+
}
|
|
2073
|
+
/**
|
|
2074
|
+
* @param {number} flight
|
|
2075
|
+
* @param {string} replies_json
|
|
2076
|
+
* @returns {string}
|
|
2077
|
+
*/
|
|
2078
|
+
resume(flight, replies_json) {
|
|
2079
|
+
let deferred3_0;
|
|
2080
|
+
let deferred3_1;
|
|
2081
|
+
try {
|
|
2082
|
+
const ptr0 = passStringToWasm0(replies_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2083
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2084
|
+
const ret = wasm.server_resume(this.__wbg_ptr, flight, ptr0, len0);
|
|
2085
|
+
var ptr2 = ret[0];
|
|
2086
|
+
var len2 = ret[1];
|
|
2087
|
+
if (ret[3]) {
|
|
2088
|
+
ptr2 = 0; len2 = 0;
|
|
2089
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2090
|
+
}
|
|
2091
|
+
deferred3_0 = ptr2;
|
|
2092
|
+
deferred3_1 = len2;
|
|
2093
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2094
|
+
} finally {
|
|
2095
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2096
|
+
}
|
|
2097
|
+
}
|
|
2098
|
+
/**
|
|
2099
|
+
* @param {number} flight
|
|
2100
|
+
* @param {string} replies_json
|
|
2101
|
+
* @returns {string}
|
|
2102
|
+
*/
|
|
2103
|
+
resumeResolve(flight, replies_json) {
|
|
2104
|
+
let deferred3_0;
|
|
2105
|
+
let deferred3_1;
|
|
2106
|
+
try {
|
|
2107
|
+
const ptr0 = passStringToWasm0(replies_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2108
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2109
|
+
const ret = wasm.server_resumeResolve(this.__wbg_ptr, flight, ptr0, len0);
|
|
2110
|
+
var ptr2 = ret[0];
|
|
2111
|
+
var len2 = ret[1];
|
|
2112
|
+
if (ret[3]) {
|
|
2113
|
+
ptr2 = 0; len2 = 0;
|
|
2114
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2115
|
+
}
|
|
2116
|
+
deferred3_0 = ptr2;
|
|
2117
|
+
deferred3_1 = len2;
|
|
2118
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2119
|
+
} finally {
|
|
2120
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2121
|
+
}
|
|
2122
|
+
}
|
|
2123
|
+
/**
|
|
2124
|
+
* @param {string} route_path
|
|
2125
|
+
* @returns {string}
|
|
2126
|
+
*/
|
|
2127
|
+
routeMounts(route_path) {
|
|
2128
|
+
let deferred3_0;
|
|
2129
|
+
let deferred3_1;
|
|
2130
|
+
try {
|
|
2131
|
+
const ptr0 = passStringToWasm0(route_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2132
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2133
|
+
const ret = wasm.server_routeMounts(this.__wbg_ptr, ptr0, len0);
|
|
2134
|
+
var ptr2 = ret[0];
|
|
2135
|
+
var len2 = ret[1];
|
|
2136
|
+
if (ret[3]) {
|
|
2137
|
+
ptr2 = 0; len2 = 0;
|
|
2138
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2139
|
+
}
|
|
2140
|
+
deferred3_0 = ptr2;
|
|
2141
|
+
deferred3_1 = len2;
|
|
2142
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2143
|
+
} finally {
|
|
2144
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2145
|
+
}
|
|
2146
|
+
}
|
|
2147
|
+
/**
|
|
2148
|
+
* @param {string} entity_type
|
|
2149
|
+
* @param {string} query_json
|
|
2150
|
+
* @param {string} write_json
|
|
2151
|
+
*/
|
|
2152
|
+
setCapabilities(entity_type, query_json, write_json) {
|
|
2153
|
+
const ptr0 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2154
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2155
|
+
const ptr1 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2156
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2157
|
+
const ptr2 = passStringToWasm0(write_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2158
|
+
const len2 = WASM_VECTOR_LEN;
|
|
2159
|
+
const ret = wasm.server_setCapabilities(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
2160
|
+
if (ret[1]) {
|
|
2161
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
2162
|
+
}
|
|
2163
|
+
}
|
|
2164
|
+
/**
|
|
2165
|
+
* @param {string} program_json
|
|
2166
|
+
*/
|
|
2167
|
+
setManagedProgram(program_json) {
|
|
2168
|
+
const ptr0 = passStringToWasm0(program_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2169
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2170
|
+
const ret = wasm.server_setManagedProgram(this.__wbg_ptr, ptr0, len0);
|
|
2171
|
+
if (ret[1]) {
|
|
2172
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
2173
|
+
}
|
|
2174
|
+
}
|
|
2175
|
+
/**
|
|
2176
|
+
* @param {string} anchors_json
|
|
2177
|
+
* @returns {string}
|
|
2178
|
+
*/
|
|
2179
|
+
setOsAnchors(anchors_json) {
|
|
2180
|
+
let deferred3_0;
|
|
2181
|
+
let deferred3_1;
|
|
2182
|
+
try {
|
|
2183
|
+
const ptr0 = passStringToWasm0(anchors_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2184
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2185
|
+
const ret = wasm.server_setOsAnchors(this.__wbg_ptr, ptr0, len0);
|
|
2186
|
+
var ptr2 = ret[0];
|
|
2187
|
+
var len2 = ret[1];
|
|
2188
|
+
if (ret[3]) {
|
|
2189
|
+
ptr2 = 0; len2 = 0;
|
|
2190
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2191
|
+
}
|
|
2192
|
+
deferred3_0 = ptr2;
|
|
2193
|
+
deferred3_1 = len2;
|
|
2194
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2195
|
+
} finally {
|
|
2196
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2197
|
+
}
|
|
2198
|
+
}
|
|
2199
|
+
/**
|
|
2200
|
+
* @param {boolean} stateful
|
|
2201
|
+
*/
|
|
2202
|
+
setStateful(stateful) {
|
|
2203
|
+
wasm.server_setStateful(this.__wbg_ptr, stateful);
|
|
2204
|
+
}
|
|
2205
|
+
/**
|
|
2206
|
+
* @param {number} interval_ms
|
|
2207
|
+
*/
|
|
2208
|
+
setTickRelayInterval(interval_ms) {
|
|
2209
|
+
wasm.server_setTickRelayInterval(this.__wbg_ptr, interval_ms);
|
|
2210
|
+
}
|
|
2211
|
+
/**
|
|
2212
|
+
* @param {string} orbital
|
|
2213
|
+
* @param {string} request_json
|
|
2214
|
+
* @returns {string}
|
|
2215
|
+
*/
|
|
2216
|
+
start(orbital, request_json) {
|
|
2217
|
+
let deferred4_0;
|
|
2218
|
+
let deferred4_1;
|
|
2219
|
+
try {
|
|
2220
|
+
const ptr0 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2221
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2222
|
+
const ptr1 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2223
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2224
|
+
const ret = wasm.server_start(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
2225
|
+
var ptr3 = ret[0];
|
|
2226
|
+
var len3 = ret[1];
|
|
2227
|
+
if (ret[3]) {
|
|
2228
|
+
ptr3 = 0; len3 = 0;
|
|
2229
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2230
|
+
}
|
|
2231
|
+
deferred4_0 = ptr3;
|
|
2232
|
+
deferred4_1 = len3;
|
|
2233
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2234
|
+
} finally {
|
|
2235
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2236
|
+
}
|
|
2237
|
+
}
|
|
2238
|
+
/**
|
|
2239
|
+
* @param {number} now_ms
|
|
2240
|
+
* @returns {string}
|
|
2241
|
+
*/
|
|
2242
|
+
tickPass(now_ms) {
|
|
2243
|
+
let deferred2_0;
|
|
2244
|
+
let deferred2_1;
|
|
2245
|
+
try {
|
|
2246
|
+
const ret = wasm.server_tickPass(this.__wbg_ptr, now_ms);
|
|
2247
|
+
var ptr1 = ret[0];
|
|
2248
|
+
var len1 = ret[1];
|
|
2249
|
+
if (ret[3]) {
|
|
2250
|
+
ptr1 = 0; len1 = 0;
|
|
2251
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2252
|
+
}
|
|
2253
|
+
deferred2_0 = ptr1;
|
|
2254
|
+
deferred2_1 = len1;
|
|
2255
|
+
return getStringFromWasm0(ptr1, len1);
|
|
2256
|
+
} finally {
|
|
2257
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
2258
|
+
}
|
|
2259
|
+
}
|
|
2260
|
+
tickPause() {
|
|
2261
|
+
wasm.server_tickPause(this.__wbg_ptr);
|
|
2262
|
+
}
|
|
2263
|
+
/**
|
|
2264
|
+
* @returns {boolean}
|
|
2265
|
+
*/
|
|
2266
|
+
tickPaused() {
|
|
2267
|
+
const ret = wasm.server_tickPaused(this.__wbg_ptr);
|
|
2268
|
+
return ret !== 0;
|
|
2269
|
+
}
|
|
2270
|
+
tickResume() {
|
|
2271
|
+
wasm.server_tickResume(this.__wbg_ptr);
|
|
2272
|
+
}
|
|
2273
|
+
/**
|
|
2274
|
+
* Feed a deferred raw `os/` outcome into the TLS operation the kernel parked under `key`: `null` when `key` parks
|
|
2275
|
+
* none, `{ ask: { op, args } }` for the next raw ask the host must answer, or `{ done: Settled }`.
|
|
2276
|
+
* @param {string} key
|
|
2277
|
+
* @param {string} outcome_json
|
|
2278
|
+
* @returns {string}
|
|
2279
|
+
*/
|
|
2280
|
+
tlsComplete(key, outcome_json) {
|
|
2281
|
+
let deferred4_0;
|
|
2282
|
+
let deferred4_1;
|
|
2283
|
+
try {
|
|
2284
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2285
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2286
|
+
const ptr1 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2287
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2288
|
+
const ret = wasm.server_tlsComplete(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
2289
|
+
var ptr3 = ret[0];
|
|
2290
|
+
var len3 = ret[1];
|
|
2291
|
+
if (ret[3]) {
|
|
2292
|
+
ptr3 = 0; len3 = 0;
|
|
2293
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2294
|
+
}
|
|
2295
|
+
deferred4_0 = ptr3;
|
|
2296
|
+
deferred4_1 = len3;
|
|
2297
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2298
|
+
} finally {
|
|
2299
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2300
|
+
}
|
|
2301
|
+
}
|
|
2302
|
+
/**
|
|
2303
|
+
* @param {string} client
|
|
2304
|
+
* @param {string} orbital
|
|
2305
|
+
* @param {string} traits_json
|
|
2306
|
+
*/
|
|
2307
|
+
unmountClient(client, orbital, traits_json) {
|
|
2308
|
+
const ptr0 = passStringToWasm0(client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2309
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2310
|
+
const ptr1 = passStringToWasm0(orbital, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2311
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2312
|
+
const ptr2 = passStringToWasm0(traits_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2313
|
+
const len2 = WASM_VECTOR_LEN;
|
|
2314
|
+
const ret = wasm.server_unmountClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
2315
|
+
if (ret[1]) {
|
|
2316
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
2317
|
+
}
|
|
2318
|
+
}
|
|
2319
|
+
}
|
|
2320
|
+
if (Symbol.dispose) Server.prototype[Symbol.dispose] = Server.prototype.free;
|
|
2321
|
+
|
|
2322
|
+
/**
|
|
2323
|
+
* Whether a row may be created, updated or deleted under a directive (`MutationVerdictWire` as JSON).
|
|
2324
|
+
* @param {string} operation
|
|
2325
|
+
* @param {string} bindings_json
|
|
2326
|
+
* @param {string} row_json
|
|
2327
|
+
* @param {string} policy_json
|
|
2328
|
+
* @param {string} entity_type
|
|
2329
|
+
* @returns {string}
|
|
2330
|
+
*/
|
|
2331
|
+
export function checkMutationAccess(operation, bindings_json, row_json, policy_json, entity_type) {
|
|
2332
|
+
let deferred7_0;
|
|
2333
|
+
let deferred7_1;
|
|
2334
|
+
try {
|
|
2335
|
+
const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2336
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2337
|
+
const ptr1 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2338
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2339
|
+
const ptr2 = passStringToWasm0(row_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2340
|
+
const len2 = WASM_VECTOR_LEN;
|
|
2341
|
+
const ptr3 = passStringToWasm0(policy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2342
|
+
const len3 = WASM_VECTOR_LEN;
|
|
2343
|
+
const ptr4 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2344
|
+
const len4 = WASM_VECTOR_LEN;
|
|
2345
|
+
const ret = wasm.checkMutationAccess(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
|
|
2346
|
+
var ptr6 = ret[0];
|
|
2347
|
+
var len6 = ret[1];
|
|
2348
|
+
if (ret[3]) {
|
|
2349
|
+
ptr6 = 0; len6 = 0;
|
|
2350
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2351
|
+
}
|
|
2352
|
+
deferred7_0 = ptr6;
|
|
2353
|
+
deferred7_1 = len6;
|
|
2354
|
+
return getStringFromWasm0(ptr6, len6);
|
|
2355
|
+
} finally {
|
|
2356
|
+
wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
|
|
2357
|
+
}
|
|
2358
|
+
}
|
|
2359
|
+
|
|
2360
|
+
/**
|
|
2361
|
+
* One `ContractQuery` (as JSON) answered for a host with no registered program, as JSON.
|
|
2362
|
+
* @param {string} query_json
|
|
2363
|
+
* @returns {string}
|
|
2364
|
+
*/
|
|
2365
|
+
export function contractQueryWithoutProgram(query_json) {
|
|
2366
|
+
let deferred3_0;
|
|
2367
|
+
let deferred3_1;
|
|
2368
|
+
try {
|
|
2369
|
+
const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2370
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2371
|
+
const ret = wasm.contractQueryWithoutProgram(ptr0, len0);
|
|
2372
|
+
var ptr2 = ret[0];
|
|
2373
|
+
var len2 = ret[1];
|
|
2374
|
+
if (ret[3]) {
|
|
2375
|
+
ptr2 = 0; len2 = 0;
|
|
2376
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2377
|
+
}
|
|
2378
|
+
deferred3_0 = ptr2;
|
|
2379
|
+
deferred3_1 = len2;
|
|
2380
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2381
|
+
} finally {
|
|
2382
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2383
|
+
}
|
|
2384
|
+
}
|
|
2385
|
+
|
|
2386
|
+
/**
|
|
2387
|
+
* Every guard of a render against a context in one crossing (`GuardOutcomeWire[]` as JSON).
|
|
2388
|
+
* @param {string} context_json
|
|
2389
|
+
* @param {string} guards_json
|
|
2390
|
+
* @returns {string}
|
|
2391
|
+
*/
|
|
2392
|
+
export function evaluateGuards(context_json, guards_json) {
|
|
2393
|
+
let deferred4_0;
|
|
2394
|
+
let deferred4_1;
|
|
2395
|
+
try {
|
|
2396
|
+
const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2397
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2398
|
+
const ptr1 = passStringToWasm0(guards_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2399
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2400
|
+
const ret = wasm.evaluateGuards(ptr0, len0, ptr1, len1);
|
|
2401
|
+
var ptr3 = ret[0];
|
|
2402
|
+
var len3 = ret[1];
|
|
2403
|
+
if (ret[3]) {
|
|
2404
|
+
ptr3 = 0; len3 = 0;
|
|
2405
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2406
|
+
}
|
|
2407
|
+
deferred4_0 = ptr3;
|
|
2408
|
+
deferred4_1 = len3;
|
|
2409
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2410
|
+
} finally {
|
|
2411
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2412
|
+
}
|
|
2413
|
+
}
|
|
2414
|
+
|
|
2415
|
+
/**
|
|
2416
|
+
* Evaluate `expressionsJson` (`SExpr[]`) against `contextJson` (`EvalContextWire`) in one crossing:
|
|
2417
|
+
* `EvalOutcomeWire[]` as JSON, in order.
|
|
2418
|
+
* @param {string} context_json
|
|
2419
|
+
* @param {string} expressions_json
|
|
2420
|
+
* @returns {string}
|
|
2421
|
+
*/
|
|
2422
|
+
export function evaluateMany(context_json, expressions_json) {
|
|
2423
|
+
let deferred4_0;
|
|
2424
|
+
let deferred4_1;
|
|
2425
|
+
try {
|
|
2426
|
+
const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2427
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2428
|
+
const ptr1 = passStringToWasm0(expressions_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2429
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2430
|
+
const ret = wasm.evaluateMany(ptr0, len0, ptr1, len1);
|
|
2431
|
+
var ptr3 = ret[0];
|
|
2432
|
+
var len3 = ret[1];
|
|
2433
|
+
if (ret[3]) {
|
|
2434
|
+
ptr3 = 0; len3 = 0;
|
|
2435
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2436
|
+
}
|
|
2437
|
+
deferred4_0 = ptr3;
|
|
2438
|
+
deferred4_1 = len3;
|
|
2439
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2440
|
+
} finally {
|
|
2441
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2442
|
+
}
|
|
2443
|
+
}
|
|
2444
|
+
|
|
2445
|
+
/**
|
|
2446
|
+
* One expression with its trace (`EvalTracedWire` as JSON).
|
|
2447
|
+
* @param {string} context_json
|
|
2448
|
+
* @param {string} expression_json
|
|
2449
|
+
* @returns {string}
|
|
2450
|
+
*/
|
|
2451
|
+
export function evaluateTraced(context_json, expression_json) {
|
|
2452
|
+
let deferred4_0;
|
|
2453
|
+
let deferred4_1;
|
|
2454
|
+
try {
|
|
2455
|
+
const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2456
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2457
|
+
const ptr1 = passStringToWasm0(expression_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2458
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2459
|
+
const ret = wasm.evaluateTraced(ptr0, len0, ptr1, len1);
|
|
2460
|
+
var ptr3 = ret[0];
|
|
2461
|
+
var len3 = ret[1];
|
|
2462
|
+
if (ret[3]) {
|
|
2463
|
+
ptr3 = 0; len3 = 0;
|
|
2464
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2465
|
+
}
|
|
2466
|
+
deferred4_0 = ptr3;
|
|
2467
|
+
deferred4_1 = len3;
|
|
2468
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2469
|
+
} finally {
|
|
2470
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2471
|
+
}
|
|
2472
|
+
}
|
|
2473
|
+
|
|
2474
|
+
/**
|
|
2475
|
+
* The program's emitter-to-listener wire table (`EventWire[]` as JSON), by the source rule the kernel delivers by.
|
|
2476
|
+
* @param {string} schema_json
|
|
2477
|
+
* @returns {string}
|
|
2478
|
+
*/
|
|
2479
|
+
export function eventWires(schema_json) {
|
|
2480
|
+
let deferred3_0;
|
|
2481
|
+
let deferred3_1;
|
|
2482
|
+
try {
|
|
2483
|
+
const ptr0 = passStringToWasm0(schema_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2484
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2485
|
+
const ret = wasm.eventWires(ptr0, len0);
|
|
2486
|
+
var ptr2 = ret[0];
|
|
2487
|
+
var len2 = ret[1];
|
|
2488
|
+
if (ret[3]) {
|
|
2489
|
+
ptr2 = 0; len2 = 0;
|
|
2490
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2491
|
+
}
|
|
2492
|
+
deferred3_0 = ptr2;
|
|
2493
|
+
deferred3_1 = len2;
|
|
2494
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2495
|
+
} finally {
|
|
2496
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2497
|
+
}
|
|
2498
|
+
}
|
|
2499
|
+
|
|
2500
|
+
/**
|
|
2501
|
+
* @param {string} layer_json
|
|
2502
|
+
* @param {number} epoch_now_ms
|
|
2503
|
+
* @param {string} dimension
|
|
2504
|
+
* @param {number} tile_width
|
|
2505
|
+
* @returns {string}
|
|
2506
|
+
*/
|
|
2507
|
+
export function expandFxLayer(layer_json, epoch_now_ms, dimension, tile_width) {
|
|
2508
|
+
let deferred4_0;
|
|
2509
|
+
let deferred4_1;
|
|
2510
|
+
try {
|
|
2511
|
+
const ptr0 = passStringToWasm0(layer_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2512
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2513
|
+
const ptr1 = passStringToWasm0(dimension, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2514
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2515
|
+
const ret = wasm.expandFxLayer(ptr0, len0, epoch_now_ms, ptr1, len1, tile_width);
|
|
2516
|
+
var ptr3 = ret[0];
|
|
2517
|
+
var len3 = ret[1];
|
|
2518
|
+
if (ret[3]) {
|
|
2519
|
+
ptr3 = 0; len3 = 0;
|
|
2520
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2521
|
+
}
|
|
2522
|
+
deferred4_0 = ptr3;
|
|
2523
|
+
deferred4_1 = len3;
|
|
2524
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2525
|
+
} finally {
|
|
2526
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2527
|
+
}
|
|
2528
|
+
}
|
|
2529
|
+
|
|
2530
|
+
/**
|
|
2531
|
+
* @param {string} seed
|
|
2532
|
+
* @param {number} salt
|
|
2533
|
+
* @returns {number}
|
|
2534
|
+
*/
|
|
2535
|
+
export function fxHash01(seed, salt) {
|
|
2536
|
+
const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2537
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2538
|
+
const ret = wasm.fxHash01(ptr0, len0, salt);
|
|
2539
|
+
return ret;
|
|
2540
|
+
}
|
|
2541
|
+
|
|
2542
|
+
/**
|
|
2543
|
+
* @param {string} view_json
|
|
2544
|
+
* @param {number} epoch_now_ms
|
|
2545
|
+
* @param {number} tick_ms
|
|
2546
|
+
* @returns {string}
|
|
2547
|
+
*/
|
|
2548
|
+
export function fxLifecycle(view_json, epoch_now_ms, tick_ms) {
|
|
2549
|
+
let deferred3_0;
|
|
2550
|
+
let deferred3_1;
|
|
2551
|
+
try {
|
|
2552
|
+
const ptr0 = passStringToWasm0(view_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2553
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2554
|
+
const ret = wasm.fxLifecycle(ptr0, len0, epoch_now_ms, tick_ms);
|
|
2555
|
+
var ptr2 = ret[0];
|
|
2556
|
+
var len2 = ret[1];
|
|
2557
|
+
if (ret[3]) {
|
|
2558
|
+
ptr2 = 0; len2 = 0;
|
|
2559
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2560
|
+
}
|
|
2561
|
+
deferred3_0 = ptr2;
|
|
2562
|
+
deferred3_1 = len2;
|
|
2563
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2564
|
+
} finally {
|
|
2565
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2566
|
+
}
|
|
2567
|
+
}
|
|
2568
|
+
|
|
2569
|
+
/**
|
|
2570
|
+
* Install the language data a host assembles from its installed `@almadar/core` and `@almadar/std`
|
|
2571
|
+
* (`readLanguageBundle`): the operator table that routes `program/*` and the other host effects.
|
|
2572
|
+
* @param {string} bundle_json
|
|
2573
|
+
*/
|
|
2574
|
+
export function installLanguage(bundle_json) {
|
|
2575
|
+
const ptr0 = passStringToWasm0(bundle_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2576
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2577
|
+
const ret = wasm.installLanguage(ptr0, len0);
|
|
2578
|
+
if (ret[1]) {
|
|
2579
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
2580
|
+
}
|
|
2581
|
+
}
|
|
2582
|
+
|
|
2583
|
+
/**
|
|
2584
|
+
* @param {string} ip
|
|
2585
|
+
* @returns {boolean}
|
|
2586
|
+
*/
|
|
2587
|
+
export function isPublicAddress(ip) {
|
|
2588
|
+
const ptr0 = passStringToWasm0(ip, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2589
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2590
|
+
const ret = wasm.isPublicAddress(ptr0, len0);
|
|
2591
|
+
if (ret[2]) {
|
|
2592
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2593
|
+
}
|
|
2594
|
+
return ret[0] !== 0;
|
|
2595
|
+
}
|
|
2596
|
+
|
|
2597
|
+
/**
|
|
2598
|
+
* A listen route's `with` mapping applied to the source payload (the mapped payload as JSON).
|
|
2599
|
+
* @param {string} mapping_json
|
|
2600
|
+
* @param {string} payload_json
|
|
2601
|
+
* @returns {string}
|
|
2602
|
+
*/
|
|
2603
|
+
export function mapListenPayload(mapping_json, payload_json) {
|
|
2604
|
+
let deferred4_0;
|
|
2605
|
+
let deferred4_1;
|
|
2606
|
+
try {
|
|
2607
|
+
const ptr0 = passStringToWasm0(mapping_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2608
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2609
|
+
const ptr1 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2610
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2611
|
+
const ret = wasm.mapListenPayload(ptr0, len0, ptr1, len1);
|
|
2612
|
+
var ptr3 = ret[0];
|
|
2613
|
+
var len3 = ret[1];
|
|
2614
|
+
if (ret[3]) {
|
|
2615
|
+
ptr3 = 0; len3 = 0;
|
|
2616
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2617
|
+
}
|
|
2618
|
+
deferred4_0 = ptr3;
|
|
2619
|
+
deferred4_1 = len3;
|
|
2620
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2621
|
+
} finally {
|
|
2622
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2623
|
+
}
|
|
2624
|
+
}
|
|
2625
|
+
|
|
2626
|
+
/**
|
|
2627
|
+
* The `{ event, payload }` a deferred keyed `os/` call's outcome (`Settled`) fires on its call site, or `null`.
|
|
2628
|
+
* @param {string} site_json
|
|
2629
|
+
* @param {string} key
|
|
2630
|
+
* @param {string} outcome_json
|
|
2631
|
+
* @returns {string}
|
|
2632
|
+
*/
|
|
2633
|
+
export function osCompletionEvent(site_json, key, outcome_json) {
|
|
2634
|
+
let deferred5_0;
|
|
2635
|
+
let deferred5_1;
|
|
2636
|
+
try {
|
|
2637
|
+
const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2638
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2639
|
+
const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2640
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2641
|
+
const ptr2 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2642
|
+
const len2 = WASM_VECTOR_LEN;
|
|
2643
|
+
const ret = wasm.osCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2);
|
|
2644
|
+
var ptr4 = ret[0];
|
|
2645
|
+
var len4 = ret[1];
|
|
2646
|
+
if (ret[3]) {
|
|
2647
|
+
ptr4 = 0; len4 = 0;
|
|
2648
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2649
|
+
}
|
|
2650
|
+
deferred5_0 = ptr4;
|
|
2651
|
+
deferred5_1 = len4;
|
|
2652
|
+
return getStringFromWasm0(ptr4, len4);
|
|
2653
|
+
} finally {
|
|
2654
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
2655
|
+
}
|
|
2656
|
+
}
|
|
2657
|
+
|
|
2658
|
+
/**
|
|
2659
|
+
* The names of the `os/` operations whose keyed call may defer its completion, as a JSON array.
|
|
2660
|
+
* @returns {string}
|
|
2661
|
+
*/
|
|
2662
|
+
export function osDeferringOps() {
|
|
2663
|
+
let deferred2_0;
|
|
2664
|
+
let deferred2_1;
|
|
2665
|
+
try {
|
|
2666
|
+
const ret = wasm.osDeferringOps();
|
|
2667
|
+
var ptr1 = ret[0];
|
|
2668
|
+
var len1 = ret[1];
|
|
2669
|
+
if (ret[3]) {
|
|
2670
|
+
ptr1 = 0; len1 = 0;
|
|
2671
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2672
|
+
}
|
|
2673
|
+
deferred2_0 = ptr1;
|
|
2674
|
+
deferred2_1 = len1;
|
|
2675
|
+
return getStringFromWasm0(ptr1, len1);
|
|
2676
|
+
} finally {
|
|
2677
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
2678
|
+
}
|
|
2679
|
+
}
|
|
2680
|
+
|
|
2681
|
+
/**
|
|
2682
|
+
* @param {string} glob
|
|
2683
|
+
* @param {string} path
|
|
2684
|
+
* @returns {boolean}
|
|
2685
|
+
*/
|
|
2686
|
+
export function osGlobMatches(glob, path) {
|
|
2687
|
+
const ptr0 = passStringToWasm0(glob, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2688
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2689
|
+
const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2690
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2691
|
+
const ret = wasm.osGlobMatches(ptr0, len0, ptr1, len1);
|
|
2692
|
+
return ret !== 0;
|
|
2693
|
+
}
|
|
2694
|
+
|
|
2695
|
+
/**
|
|
2696
|
+
* The names of the `os/` operations whose keyed call is a stream, as a JSON array.
|
|
2697
|
+
* @returns {string}
|
|
2698
|
+
*/
|
|
2699
|
+
export function osStreamOps() {
|
|
2700
|
+
let deferred2_0;
|
|
2701
|
+
let deferred2_1;
|
|
2702
|
+
try {
|
|
2703
|
+
const ret = wasm.osStreamOps();
|
|
2704
|
+
var ptr1 = ret[0];
|
|
2705
|
+
var len1 = ret[1];
|
|
2706
|
+
if (ret[3]) {
|
|
2707
|
+
ptr1 = 0; len1 = 0;
|
|
2708
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2709
|
+
}
|
|
2710
|
+
deferred2_0 = ptr1;
|
|
2711
|
+
deferred2_1 = len1;
|
|
2712
|
+
return getStringFromWasm0(ptr1, len1);
|
|
2713
|
+
} finally {
|
|
2714
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
2715
|
+
}
|
|
2716
|
+
}
|
|
2717
|
+
|
|
2718
|
+
/**
|
|
2719
|
+
* The typed event request a `program/dispatch` call names, as an object; a record that is no event request throws the reason.
|
|
2720
|
+
* @param {string} payload_json
|
|
2721
|
+
* @param {string} options_json
|
|
2722
|
+
* @returns {any}
|
|
2723
|
+
*/
|
|
2724
|
+
export function parseEventRequest(payload_json, options_json) {
|
|
2725
|
+
const ptr0 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2726
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2727
|
+
const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2728
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2729
|
+
const ret = wasm.parseEventRequest(ptr0, len0, ptr1, len1);
|
|
2730
|
+
if (ret[2]) {
|
|
2731
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2732
|
+
}
|
|
2733
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2734
|
+
}
|
|
2735
|
+
|
|
2736
|
+
export function report_panics() {
|
|
2737
|
+
wasm.report_panics();
|
|
2738
|
+
}
|
|
2739
|
+
|
|
2740
|
+
/**
|
|
2741
|
+
* @param {string} item_json
|
|
2742
|
+
* @param {string | null} [presets_json]
|
|
2743
|
+
* @returns {string}
|
|
2744
|
+
*/
|
|
2745
|
+
export function resolveFxView(item_json, presets_json) {
|
|
2746
|
+
let deferred4_0;
|
|
2747
|
+
let deferred4_1;
|
|
2748
|
+
try {
|
|
2749
|
+
const ptr0 = passStringToWasm0(item_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2750
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2751
|
+
var ptr1 = isLikeNone(presets_json) ? 0 : passStringToWasm0(presets_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2752
|
+
var len1 = WASM_VECTOR_LEN;
|
|
2753
|
+
const ret = wasm.resolveFxView(ptr0, len0, ptr1, len1);
|
|
2754
|
+
var ptr3 = ret[0];
|
|
2755
|
+
var len3 = ret[1];
|
|
2756
|
+
if (ret[3]) {
|
|
2757
|
+
ptr3 = 0; len3 = 0;
|
|
2758
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2759
|
+
}
|
|
2760
|
+
deferred4_0 = ptr3;
|
|
2761
|
+
deferred4_1 = len3;
|
|
2762
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2763
|
+
} finally {
|
|
2764
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2765
|
+
}
|
|
2766
|
+
}
|
|
2767
|
+
|
|
2768
|
+
/**
|
|
2769
|
+
* What a `@user`/`@payload`/`@config`/`@now` term folds to for a row predicate (`RowBindingWire` as JSON).
|
|
2770
|
+
* @param {string} term
|
|
2771
|
+
* @param {string} bindings_json
|
|
2772
|
+
* @returns {string}
|
|
2773
|
+
*/
|
|
2774
|
+
export function resolveRowBinding(term, bindings_json) {
|
|
2775
|
+
let deferred4_0;
|
|
2776
|
+
let deferred4_1;
|
|
2777
|
+
try {
|
|
2778
|
+
const ptr0 = passStringToWasm0(term, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2779
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2780
|
+
const ptr1 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2781
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2782
|
+
const ret = wasm.resolveRowBinding(ptr0, len0, ptr1, len1);
|
|
2783
|
+
var ptr3 = ret[0];
|
|
2784
|
+
var len3 = ret[1];
|
|
2785
|
+
if (ret[3]) {
|
|
2786
|
+
ptr3 = 0; len3 = 0;
|
|
2787
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2788
|
+
}
|
|
2789
|
+
deferred4_0 = ptr3;
|
|
2790
|
+
deferred4_1 = len3;
|
|
2791
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2792
|
+
} finally {
|
|
2793
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2794
|
+
}
|
|
2795
|
+
}
|
|
2796
|
+
|
|
2797
|
+
/**
|
|
2798
|
+
* Resolve every prop value of a render against `contextJson` in one crossing: each binding, embedded ones
|
|
2799
|
+
* included, and each operator call (`EvalOutcomeWire[]` as JSON, in order).
|
|
2800
|
+
* @param {string} context_json
|
|
2801
|
+
* @param {string} values_json
|
|
2802
|
+
* @returns {string}
|
|
2803
|
+
*/
|
|
2804
|
+
export function resolveValues(context_json, values_json) {
|
|
2805
|
+
let deferred4_0;
|
|
2806
|
+
let deferred4_1;
|
|
2807
|
+
try {
|
|
2808
|
+
const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2809
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2810
|
+
const ptr1 = passStringToWasm0(values_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2811
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2812
|
+
const ret = wasm.resolveValues(ptr0, len0, ptr1, len1);
|
|
2813
|
+
var ptr3 = ret[0];
|
|
2814
|
+
var len3 = ret[1];
|
|
2815
|
+
if (ret[3]) {
|
|
2816
|
+
ptr3 = 0; len3 = 0;
|
|
2817
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2818
|
+
}
|
|
2819
|
+
deferred4_0 = ptr3;
|
|
2820
|
+
deferred4_1 = len3;
|
|
2821
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2822
|
+
} finally {
|
|
2823
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2824
|
+
}
|
|
2825
|
+
}
|
|
2826
|
+
|
|
2827
|
+
/**
|
|
2828
|
+
* The rows that pass a `@read` policy and a call-site filter (each an `SExpr` as JSON, or empty).
|
|
2829
|
+
* @param {string} bindings_json
|
|
2830
|
+
* @param {string} rows_json
|
|
2831
|
+
* @param {string} policy_json
|
|
2832
|
+
* @param {string} filter_json
|
|
2833
|
+
* @param {string} entity_type
|
|
2834
|
+
* @returns {string}
|
|
2835
|
+
*/
|
|
2836
|
+
export function scopeRows(bindings_json, rows_json, policy_json, filter_json, entity_type) {
|
|
2837
|
+
let deferred7_0;
|
|
2838
|
+
let deferred7_1;
|
|
2839
|
+
try {
|
|
2840
|
+
const ptr0 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2841
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2842
|
+
const ptr1 = passStringToWasm0(rows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2843
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2844
|
+
const ptr2 = passStringToWasm0(policy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2845
|
+
const len2 = WASM_VECTOR_LEN;
|
|
2846
|
+
const ptr3 = passStringToWasm0(filter_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2847
|
+
const len3 = WASM_VECTOR_LEN;
|
|
2848
|
+
const ptr4 = passStringToWasm0(entity_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2849
|
+
const len4 = WASM_VECTOR_LEN;
|
|
2850
|
+
const ret = wasm.scopeRows(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
|
|
2851
|
+
var ptr6 = ret[0];
|
|
2852
|
+
var len6 = ret[1];
|
|
2853
|
+
if (ret[3]) {
|
|
2854
|
+
ptr6 = 0; len6 = 0;
|
|
2855
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2856
|
+
}
|
|
2857
|
+
deferred7_0 = ptr6;
|
|
2858
|
+
deferred7_1 = len6;
|
|
2859
|
+
return getStringFromWasm0(ptr6, len6);
|
|
2860
|
+
} finally {
|
|
2861
|
+
wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
|
|
2862
|
+
}
|
|
2863
|
+
}
|
|
2864
|
+
|
|
2865
|
+
/**
|
|
2866
|
+
* @param {string} matrix_json
|
|
2867
|
+
* @param {number} x
|
|
2868
|
+
* @param {number} y
|
|
2869
|
+
* @returns {string}
|
|
2870
|
+
*/
|
|
2871
|
+
export function skinApplyAffine(matrix_json, x, y) {
|
|
2872
|
+
let deferred3_0;
|
|
2873
|
+
let deferred3_1;
|
|
2874
|
+
try {
|
|
2875
|
+
const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2876
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2877
|
+
const ret = wasm.skinApplyAffine(ptr0, len0, x, y);
|
|
2878
|
+
var ptr2 = ret[0];
|
|
2879
|
+
var len2 = ret[1];
|
|
2880
|
+
if (ret[3]) {
|
|
2881
|
+
ptr2 = 0; len2 = 0;
|
|
2882
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2883
|
+
}
|
|
2884
|
+
deferred3_0 = ptr2;
|
|
2885
|
+
deferred3_1 = len2;
|
|
2886
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2887
|
+
} finally {
|
|
2888
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2889
|
+
}
|
|
2890
|
+
}
|
|
2891
|
+
|
|
2892
|
+
/**
|
|
2893
|
+
* @param {string} a_json
|
|
2894
|
+
* @param {string} b_json
|
|
2895
|
+
* @returns {string}
|
|
2896
|
+
*/
|
|
2897
|
+
export function skinComposeAffine(a_json, b_json) {
|
|
2898
|
+
let deferred4_0;
|
|
2899
|
+
let deferred4_1;
|
|
2900
|
+
try {
|
|
2901
|
+
const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2902
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2903
|
+
const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2904
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2905
|
+
const ret = wasm.skinComposeAffine(ptr0, len0, ptr1, len1);
|
|
2906
|
+
var ptr3 = ret[0];
|
|
2907
|
+
var len3 = ret[1];
|
|
2908
|
+
if (ret[3]) {
|
|
2909
|
+
ptr3 = 0; len3 = 0;
|
|
2910
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2911
|
+
}
|
|
2912
|
+
deferred4_0 = ptr3;
|
|
2913
|
+
deferred4_1 = len3;
|
|
2914
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2915
|
+
} finally {
|
|
2916
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2917
|
+
}
|
|
2918
|
+
}
|
|
2919
|
+
|
|
2920
|
+
/**
|
|
2921
|
+
* @param {string} matrix_json
|
|
2922
|
+
* @param {number} bone
|
|
2923
|
+
* @returns {string}
|
|
2924
|
+
*/
|
|
2925
|
+
export function skinInvertAffine(matrix_json, bone) {
|
|
2926
|
+
let deferred3_0;
|
|
2927
|
+
let deferred3_1;
|
|
2928
|
+
try {
|
|
2929
|
+
const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2930
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2931
|
+
const ret = wasm.skinInvertAffine(ptr0, len0, bone);
|
|
2932
|
+
var ptr2 = ret[0];
|
|
2933
|
+
var len2 = ret[1];
|
|
2934
|
+
if (ret[3]) {
|
|
2935
|
+
ptr2 = 0; len2 = 0;
|
|
2936
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2937
|
+
}
|
|
2938
|
+
deferred3_0 = ptr2;
|
|
2939
|
+
deferred3_1 = len2;
|
|
2940
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2941
|
+
} finally {
|
|
2942
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2943
|
+
}
|
|
2944
|
+
}
|
|
2945
|
+
|
|
2946
|
+
/**
|
|
2947
|
+
* @param {string} src_json
|
|
2948
|
+
* @param {string} dst_json
|
|
2949
|
+
* @returns {string}
|
|
2950
|
+
*/
|
|
2951
|
+
export function skinTriangleAffine(src_json, dst_json) {
|
|
2952
|
+
let deferred4_0;
|
|
2953
|
+
let deferred4_1;
|
|
2954
|
+
try {
|
|
2955
|
+
const ptr0 = passStringToWasm0(src_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2956
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2957
|
+
const ptr1 = passStringToWasm0(dst_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2958
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2959
|
+
const ret = wasm.skinTriangleAffine(ptr0, len0, ptr1, len1);
|
|
2960
|
+
var ptr3 = ret[0];
|
|
2961
|
+
var len3 = ret[1];
|
|
2962
|
+
if (ret[3]) {
|
|
2963
|
+
ptr3 = 0; len3 = 0;
|
|
2964
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2965
|
+
}
|
|
2966
|
+
deferred4_0 = ptr3;
|
|
2967
|
+
deferred4_1 = len3;
|
|
2968
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2969
|
+
} finally {
|
|
2970
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2971
|
+
}
|
|
2972
|
+
}
|
|
2973
|
+
|
|
2974
|
+
/**
|
|
2975
|
+
* @param {string} points_json
|
|
2976
|
+
* @returns {string}
|
|
2977
|
+
*/
|
|
2978
|
+
export function skinVertexBounds(points_json) {
|
|
2979
|
+
let deferred3_0;
|
|
2980
|
+
let deferred3_1;
|
|
2981
|
+
try {
|
|
2982
|
+
const ptr0 = passStringToWasm0(points_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2983
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2984
|
+
const ret = wasm.skinVertexBounds(ptr0, len0);
|
|
2985
|
+
var ptr2 = ret[0];
|
|
2986
|
+
var len2 = ret[1];
|
|
2987
|
+
if (ret[3]) {
|
|
2988
|
+
ptr2 = 0; len2 = 0;
|
|
2989
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2990
|
+
}
|
|
2991
|
+
deferred3_0 = ptr2;
|
|
2992
|
+
deferred3_1 = len2;
|
|
2993
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2994
|
+
} finally {
|
|
2995
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2996
|
+
}
|
|
2997
|
+
}
|
|
2998
|
+
|
|
2999
|
+
/**
|
|
3000
|
+
* @param {string} mesh_json
|
|
3001
|
+
* @param {string} bind_json
|
|
3002
|
+
* @param {string} current_json
|
|
3003
|
+
* @returns {string}
|
|
3004
|
+
*/
|
|
3005
|
+
export function skinVertices(mesh_json, bind_json, current_json) {
|
|
3006
|
+
let deferred5_0;
|
|
3007
|
+
let deferred5_1;
|
|
3008
|
+
try {
|
|
3009
|
+
const ptr0 = passStringToWasm0(mesh_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3010
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3011
|
+
const ptr1 = passStringToWasm0(bind_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3012
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3013
|
+
const ptr2 = passStringToWasm0(current_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3014
|
+
const len2 = WASM_VECTOR_LEN;
|
|
3015
|
+
const ret = wasm.skinVertices(ptr0, len0, ptr1, len1, ptr2, len2);
|
|
3016
|
+
var ptr4 = ret[0];
|
|
3017
|
+
var len4 = ret[1];
|
|
3018
|
+
if (ret[3]) {
|
|
3019
|
+
ptr4 = 0; len4 = 0;
|
|
3020
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3021
|
+
}
|
|
3022
|
+
deferred5_0 = ptr4;
|
|
3023
|
+
deferred5_1 = len4;
|
|
3024
|
+
return getStringFromWasm0(ptr4, len4);
|
|
3025
|
+
} finally {
|
|
3026
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
3027
|
+
}
|
|
3028
|
+
}
|
|
3029
|
+
|
|
3030
|
+
/**
|
|
3031
|
+
* @param {string} bones_json
|
|
3032
|
+
* @param {string} pose_json
|
|
3033
|
+
* @returns {string}
|
|
3034
|
+
*/
|
|
3035
|
+
export function skinWorldMatrices(bones_json, pose_json) {
|
|
3036
|
+
let deferred4_0;
|
|
3037
|
+
let deferred4_1;
|
|
3038
|
+
try {
|
|
3039
|
+
const ptr0 = passStringToWasm0(bones_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3040
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3041
|
+
const ptr1 = passStringToWasm0(pose_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3042
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3043
|
+
const ret = wasm.skinWorldMatrices(ptr0, len0, ptr1, len1);
|
|
3044
|
+
var ptr3 = ret[0];
|
|
3045
|
+
var len3 = ret[1];
|
|
3046
|
+
if (ret[3]) {
|
|
3047
|
+
ptr3 = 0; len3 = 0;
|
|
3048
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3049
|
+
}
|
|
3050
|
+
deferred4_0 = ptr3;
|
|
3051
|
+
deferred4_1 = len3;
|
|
3052
|
+
return getStringFromWasm0(ptr3, len3);
|
|
3053
|
+
} finally {
|
|
3054
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3055
|
+
}
|
|
3056
|
+
}
|
|
3057
|
+
|
|
3058
|
+
/**
|
|
3059
|
+
* @param {string} site_json
|
|
3060
|
+
* @param {string} key
|
|
3061
|
+
* @param {string} op
|
|
3062
|
+
* @param {string} args_json
|
|
3063
|
+
* @param {string} outcome_json
|
|
3064
|
+
* @returns {string}
|
|
3065
|
+
*/
|
|
3066
|
+
export function substrateCompletionEvent(site_json, key, op, args_json, outcome_json) {
|
|
3067
|
+
let deferred7_0;
|
|
3068
|
+
let deferred7_1;
|
|
3069
|
+
try {
|
|
3070
|
+
const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3071
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3072
|
+
const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3073
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3074
|
+
const ptr2 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3075
|
+
const len2 = WASM_VECTOR_LEN;
|
|
3076
|
+
const ptr3 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3077
|
+
const len3 = WASM_VECTOR_LEN;
|
|
3078
|
+
const ptr4 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3079
|
+
const len4 = WASM_VECTOR_LEN;
|
|
3080
|
+
const ret = wasm.substrateCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
|
|
3081
|
+
var ptr6 = ret[0];
|
|
3082
|
+
var len6 = ret[1];
|
|
3083
|
+
if (ret[3]) {
|
|
3084
|
+
ptr6 = 0; len6 = 0;
|
|
3085
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3086
|
+
}
|
|
3087
|
+
deferred7_0 = ptr6;
|
|
3088
|
+
deferred7_1 = len6;
|
|
3089
|
+
return getStringFromWasm0(ptr6, len6);
|
|
3090
|
+
} finally {
|
|
3091
|
+
wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
|
|
3092
|
+
}
|
|
3093
|
+
}
|
|
3094
|
+
|
|
3095
|
+
/**
|
|
3096
|
+
* Whether the Chrome match pattern `pattern` matches `url`.
|
|
3097
|
+
* @param {string} pattern
|
|
3098
|
+
* @param {string} url
|
|
3099
|
+
* @returns {boolean}
|
|
3100
|
+
*/
|
|
3101
|
+
export function tabUrlMatches(pattern, url) {
|
|
3102
|
+
const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3103
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3104
|
+
const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3105
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3106
|
+
const ret = wasm.tabUrlMatches(ptr0, len0, ptr1, len1);
|
|
3107
|
+
return ret !== 0;
|
|
3108
|
+
}
|
|
3109
|
+
|
|
3110
|
+
/**
|
|
3111
|
+
* Effects run in order against a row (`TraceEffectsWire` as JSON): a trace per effect, the events raised, the writes made.
|
|
3112
|
+
* @param {string} context_json
|
|
3113
|
+
* @param {string} effects_json
|
|
3114
|
+
* @returns {string}
|
|
3115
|
+
*/
|
|
3116
|
+
export function traceEffects(context_json, effects_json) {
|
|
3117
|
+
let deferred4_0;
|
|
3118
|
+
let deferred4_1;
|
|
3119
|
+
try {
|
|
3120
|
+
const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3121
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3122
|
+
const ptr1 = passStringToWasm0(effects_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3123
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3124
|
+
const ret = wasm.traceEffects(ptr0, len0, ptr1, len1);
|
|
3125
|
+
var ptr3 = ret[0];
|
|
3126
|
+
var len3 = ret[1];
|
|
3127
|
+
if (ret[3]) {
|
|
3128
|
+
ptr3 = 0; len3 = 0;
|
|
3129
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3130
|
+
}
|
|
3131
|
+
deferred4_0 = ptr3;
|
|
3132
|
+
deferred4_1 = len3;
|
|
3133
|
+
return getStringFromWasm0(ptr3, len3);
|
|
3134
|
+
} finally {
|
|
3135
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3136
|
+
}
|
|
3137
|
+
}
|
|
3138
|
+
|
|
3139
|
+
/**
|
|
3140
|
+
* The kernel's verdict on language packs (`[{ package, definition }]` as JSON): throws the refusal that names each pack, section and word.
|
|
3141
|
+
* @param {string} packs_json
|
|
3142
|
+
*/
|
|
3143
|
+
export function validatePacks(packs_json) {
|
|
3144
|
+
const ptr0 = passStringToWasm0(packs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3145
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3146
|
+
const ret = wasm.validatePacks(ptr0, len0);
|
|
3147
|
+
if (ret[1]) {
|
|
3148
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
3149
|
+
}
|
|
3150
|
+
}
|
|
3151
|
+
function __wbg_get_imports() {
|
|
3152
|
+
const import0 = {
|
|
3153
|
+
__proto__: null,
|
|
3154
|
+
__wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
|
|
3155
|
+
const ret = Error(getStringFromWasm0(arg0, arg1));
|
|
3156
|
+
return ret;
|
|
3157
|
+
},
|
|
3158
|
+
__wbg_Window_defb2c76b3875a73: function(arg0) {
|
|
3159
|
+
const ret = arg0.Window;
|
|
3160
|
+
return ret;
|
|
3161
|
+
},
|
|
3162
|
+
__wbg_WorkerGlobalScope_184e45d6565eb3f0: function(arg0) {
|
|
3163
|
+
const ret = arg0.WorkerGlobalScope;
|
|
3164
|
+
return ret;
|
|
3165
|
+
},
|
|
3166
|
+
__wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
|
|
3167
|
+
const ret = debugString(arg1);
|
|
3168
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3169
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3170
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3171
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3172
|
+
},
|
|
3173
|
+
__wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
|
|
3174
|
+
const ret = typeof(arg0) === 'function';
|
|
3175
|
+
return ret;
|
|
3176
|
+
},
|
|
3177
|
+
__wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
|
|
3178
|
+
const ret = arg0 === null;
|
|
3179
|
+
return ret;
|
|
3180
|
+
},
|
|
3181
|
+
__wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
|
|
3182
|
+
const val = arg0;
|
|
3183
|
+
const ret = typeof(val) === 'object' && val !== null;
|
|
3184
|
+
return ret;
|
|
3185
|
+
},
|
|
3186
|
+
__wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
|
|
3187
|
+
const ret = typeof(arg0) === 'string';
|
|
3188
|
+
return ret;
|
|
3189
|
+
},
|
|
3190
|
+
__wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
|
|
3191
|
+
const ret = arg0 === undefined;
|
|
3192
|
+
return ret;
|
|
3193
|
+
},
|
|
3194
|
+
__wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
|
|
3195
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
3196
|
+
},
|
|
3197
|
+
__wbg__wbg_cb_unref_fffb441def202758: function(arg0) {
|
|
3198
|
+
arg0._wbg_cb_unref();
|
|
3199
|
+
},
|
|
3200
|
+
__wbg_arrayBuffer_3b637f0fa65c5351: function() { return handleError(function (arg0) {
|
|
3201
|
+
const ret = arg0.arrayBuffer();
|
|
3202
|
+
return ret;
|
|
3203
|
+
}, arguments); },
|
|
3204
|
+
__wbg_beginRenderPass_8f60a9940800c223: function() { return handleError(function (arg0, arg1) {
|
|
3205
|
+
const ret = arg0.beginRenderPass(arg1);
|
|
3206
|
+
return ret;
|
|
3207
|
+
}, arguments); },
|
|
3208
|
+
__wbg_buffer_54b87055582c8a81: function(arg0) {
|
|
3209
|
+
const ret = arg0.buffer;
|
|
3210
|
+
return ret;
|
|
3211
|
+
},
|
|
3212
|
+
__wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
|
|
3213
|
+
const ret = arg0.call(arg1, arg2);
|
|
3214
|
+
return ret;
|
|
3215
|
+
}, arguments); },
|
|
3216
|
+
__wbg_configure_6e4ddb3faabc6005: function() { return handleError(function (arg0, arg1) {
|
|
3217
|
+
arg0.configure(arg1);
|
|
3218
|
+
}, arguments); },
|
|
3219
|
+
__wbg_copyTextureToBuffer_09ba100a04b1b001: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
3220
|
+
arg0.copyTextureToBuffer(arg1, arg2, arg3);
|
|
3221
|
+
}, arguments); },
|
|
3222
|
+
__wbg_createBindGroupLayout_1dad97f44fda2929: function() { return handleError(function (arg0, arg1) {
|
|
3223
|
+
const ret = arg0.createBindGroupLayout(arg1);
|
|
3224
|
+
return ret;
|
|
3225
|
+
}, arguments); },
|
|
3226
|
+
__wbg_createBindGroup_0ee0646375643dfb: function(arg0, arg1) {
|
|
3227
|
+
const ret = arg0.createBindGroup(arg1);
|
|
3228
|
+
return ret;
|
|
3229
|
+
},
|
|
3230
|
+
__wbg_createBuffer_474baee88e74f68a: function() { return handleError(function (arg0, arg1) {
|
|
3231
|
+
const ret = arg0.createBuffer(arg1);
|
|
3232
|
+
return ret;
|
|
3233
|
+
}, arguments); },
|
|
3234
|
+
__wbg_createCommandEncoder_5229e112300218b4: function(arg0, arg1) {
|
|
3235
|
+
const ret = arg0.createCommandEncoder(arg1);
|
|
3236
|
+
return ret;
|
|
3237
|
+
},
|
|
3238
|
+
__wbg_createPipelineLayout_bf0deba7918ca157: function(arg0, arg1) {
|
|
3239
|
+
const ret = arg0.createPipelineLayout(arg1);
|
|
3240
|
+
return ret;
|
|
3241
|
+
},
|
|
3242
|
+
__wbg_createRenderPipeline_7baf812b1e7e39e8: function() { return handleError(function (arg0, arg1) {
|
|
3243
|
+
const ret = arg0.createRenderPipeline(arg1);
|
|
3244
|
+
return ret;
|
|
3245
|
+
}, arguments); },
|
|
3246
|
+
__wbg_createSampler_5970d585f322df95: function(arg0, arg1) {
|
|
3247
|
+
const ret = arg0.createSampler(arg1);
|
|
3248
|
+
return ret;
|
|
3249
|
+
},
|
|
3250
|
+
__wbg_createShaderModule_744311a1dd685c14: function(arg0, arg1) {
|
|
3251
|
+
const ret = arg0.createShaderModule(arg1);
|
|
3252
|
+
return ret;
|
|
3253
|
+
},
|
|
3254
|
+
__wbg_createTexture_f357c38256411287: function() { return handleError(function (arg0, arg1) {
|
|
3255
|
+
const ret = arg0.createTexture(arg1);
|
|
3256
|
+
return ret;
|
|
3257
|
+
}, arguments); },
|
|
3258
|
+
__wbg_createView_e7a36ec95c4190f3: function() { return handleError(function (arg0, arg1) {
|
|
3259
|
+
const ret = arg0.createView(arg1);
|
|
3260
|
+
return ret;
|
|
3261
|
+
}, arguments); },
|
|
3262
|
+
__wbg_crypto_38df2bab126b63dc: function(arg0) {
|
|
3263
|
+
const ret = arg0.crypto;
|
|
3264
|
+
return ret;
|
|
3265
|
+
},
|
|
3266
|
+
__wbg_draw_b93abd56938fa3b6: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3267
|
+
arg0.draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
|
|
3268
|
+
},
|
|
3269
|
+
__wbg_end_2fdce848e1c526bc: function(arg0) {
|
|
3270
|
+
arg0.end();
|
|
3271
|
+
},
|
|
3272
|
+
__wbg_error_96e899f14d8344a2: function(arg0, arg1) {
|
|
3273
|
+
console.error(getStringFromWasm0(arg0, arg1));
|
|
3274
|
+
},
|
|
3275
|
+
__wbg_fetch_58167e2c1ef32e0a: function(arg0, arg1, arg2) {
|
|
3276
|
+
const ret = arg0.fetch(getStringFromWasm0(arg1, arg2));
|
|
3277
|
+
return ret;
|
|
3278
|
+
},
|
|
3279
|
+
__wbg_finish_7370ad1c0e62b448: function(arg0) {
|
|
3280
|
+
const ret = arg0.finish();
|
|
3281
|
+
return ret;
|
|
3282
|
+
},
|
|
3283
|
+
__wbg_finish_797b32d15bab2338: function(arg0, arg1) {
|
|
3284
|
+
const ret = arg0.finish(arg1);
|
|
3285
|
+
return ret;
|
|
3286
|
+
},
|
|
3287
|
+
__wbg_getCurrentTexture_628ddb7c08d25190: function() { return handleError(function (arg0) {
|
|
3288
|
+
const ret = arg0.getCurrentTexture();
|
|
3289
|
+
return ret;
|
|
3290
|
+
}, arguments); },
|
|
3291
|
+
__wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
|
|
3292
|
+
const ret = arg0.getDate();
|
|
3293
|
+
return ret;
|
|
3294
|
+
},
|
|
3295
|
+
__wbg_getDay_aa318cce5da74c49: function(arg0) {
|
|
3296
|
+
const ret = arg0.getDay();
|
|
3297
|
+
return ret;
|
|
3298
|
+
},
|
|
3299
|
+
__wbg_getFullYear_6af8b229792ae254: function(arg0) {
|
|
3300
|
+
const ret = arg0.getFullYear();
|
|
3301
|
+
return ret;
|
|
3302
|
+
},
|
|
3303
|
+
__wbg_getHours_9f6561095682ce51: function(arg0) {
|
|
3304
|
+
const ret = arg0.getHours();
|
|
3305
|
+
return ret;
|
|
3306
|
+
},
|
|
3307
|
+
__wbg_getMappedRange_9f13d158ba3946fd: function() { return handleError(function (arg0, arg1, arg2) {
|
|
3308
|
+
const ret = arg0.getMappedRange(arg1, arg2);
|
|
3309
|
+
return ret;
|
|
3310
|
+
}, arguments); },
|
|
3311
|
+
__wbg_getMinutes_b0d5cd90bf9b8f22: function(arg0) {
|
|
3312
|
+
const ret = arg0.getMinutes();
|
|
3313
|
+
return ret;
|
|
3314
|
+
},
|
|
3315
|
+
__wbg_getMonth_fffe29d654d5eb69: function(arg0) {
|
|
3316
|
+
const ret = arg0.getMonth();
|
|
3317
|
+
return ret;
|
|
3318
|
+
},
|
|
3319
|
+
__wbg_getPreferredCanvasFormat_a2b6306e828c2f60: function(arg0) {
|
|
3320
|
+
const ret = arg0.getPreferredCanvasFormat();
|
|
3321
|
+
return (__wbindgen_enum_GpuTextureFormat.indexOf(ret) + 1 || 96) - 1;
|
|
3322
|
+
},
|
|
3323
|
+
__wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
|
|
3324
|
+
arg0.getRandomValues(arg1);
|
|
3325
|
+
}, arguments); },
|
|
3326
|
+
__wbg_get_18e0163e38e5048d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
3327
|
+
const ret = arg1.get(getStringFromWasm0(arg2, arg3));
|
|
3328
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3329
|
+
var len1 = WASM_VECTOR_LEN;
|
|
3330
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3331
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3332
|
+
}, arguments); },
|
|
3333
|
+
__wbg_gpu_ac6dc8fb638a26c3: function(arg0) {
|
|
3334
|
+
const ret = arg0.gpu;
|
|
3335
|
+
return ret;
|
|
3336
|
+
},
|
|
3337
|
+
__wbg_headers_cf9c80f30e2a4eff: function(arg0) {
|
|
3338
|
+
const ret = arg0.headers;
|
|
3339
|
+
return ret;
|
|
3340
|
+
},
|
|
3341
|
+
__wbg_instanceof_GpuAdapter_fb230cdccb184887: function(arg0) {
|
|
3342
|
+
let result;
|
|
3343
|
+
try {
|
|
3344
|
+
result = arg0 instanceof GPUAdapter;
|
|
3345
|
+
} catch (_) {
|
|
3346
|
+
result = false;
|
|
3347
|
+
}
|
|
3348
|
+
const ret = result;
|
|
3349
|
+
return ret;
|
|
3350
|
+
},
|
|
3351
|
+
__wbg_instanceof_Response_c8b64b2256f01bec: function(arg0) {
|
|
3352
|
+
let result;
|
|
3353
|
+
try {
|
|
3354
|
+
result = arg0 instanceof Response;
|
|
3355
|
+
} catch (_) {
|
|
3356
|
+
result = false;
|
|
3357
|
+
}
|
|
3358
|
+
const ret = result;
|
|
3359
|
+
return ret;
|
|
3360
|
+
},
|
|
3361
|
+
__wbg_instanceof_Window_05ba1ee4f6781663: function(arg0) {
|
|
3362
|
+
let result;
|
|
3363
|
+
try {
|
|
3364
|
+
result = arg0 instanceof Window;
|
|
3365
|
+
} catch (_) {
|
|
3366
|
+
result = false;
|
|
3367
|
+
}
|
|
3368
|
+
const ret = result;
|
|
3369
|
+
return ret;
|
|
3370
|
+
},
|
|
3371
|
+
__wbg_label_84abde6506fa15b7: function(arg0, arg1) {
|
|
3372
|
+
const ret = arg1.label;
|
|
3373
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3374
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3375
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3376
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3377
|
+
},
|
|
3378
|
+
__wbg_length_1f0964f4a5e2c6d8: function(arg0) {
|
|
3379
|
+
const ret = arg0.length;
|
|
3380
|
+
return ret;
|
|
3381
|
+
},
|
|
3382
|
+
__wbg_limits_a80585efb442d985: function(arg0) {
|
|
3383
|
+
const ret = arg0.limits;
|
|
3384
|
+
return ret;
|
|
3385
|
+
},
|
|
3386
|
+
__wbg_limits_d4ef440224084d65: function(arg0) {
|
|
3387
|
+
const ret = arg0.limits;
|
|
3388
|
+
return ret;
|
|
3389
|
+
},
|
|
3390
|
+
__wbg_mapAsync_3546b4b874e14738: function(arg0, arg1, arg2, arg3) {
|
|
3391
|
+
const ret = arg0.mapAsync(arg1 >>> 0, arg2, arg3);
|
|
3392
|
+
return ret;
|
|
3393
|
+
},
|
|
3394
|
+
__wbg_maxBindGroups_2fac2855adae76bb: function(arg0) {
|
|
3395
|
+
const ret = arg0.maxBindGroups;
|
|
3396
|
+
return ret;
|
|
3397
|
+
},
|
|
3398
|
+
__wbg_maxBindingsPerBindGroup_7b8b526a1900701d: function(arg0) {
|
|
3399
|
+
const ret = arg0.maxBindingsPerBindGroup;
|
|
3400
|
+
return ret;
|
|
3401
|
+
},
|
|
3402
|
+
__wbg_maxBufferSize_475dcdac4810587e: function(arg0) {
|
|
3403
|
+
const ret = arg0.maxBufferSize;
|
|
3404
|
+
return ret;
|
|
3405
|
+
},
|
|
3406
|
+
__wbg_maxColorAttachmentBytesPerSample_5a04a2d5a9e122bb: function(arg0) {
|
|
3407
|
+
const ret = arg0.maxColorAttachmentBytesPerSample;
|
|
3408
|
+
return ret;
|
|
3409
|
+
},
|
|
3410
|
+
__wbg_maxColorAttachments_2a487bb283cf8f08: function(arg0) {
|
|
3411
|
+
const ret = arg0.maxColorAttachments;
|
|
3412
|
+
return ret;
|
|
3413
|
+
},
|
|
3414
|
+
__wbg_maxComputeInvocationsPerWorkgroup_72908780df74614a: function(arg0) {
|
|
3415
|
+
const ret = arg0.maxComputeInvocationsPerWorkgroup;
|
|
3416
|
+
return ret;
|
|
3417
|
+
},
|
|
3418
|
+
__wbg_maxComputeWorkgroupSizeX_92eeefd082aefd07: function(arg0) {
|
|
3419
|
+
const ret = arg0.maxComputeWorkgroupSizeX;
|
|
3420
|
+
return ret;
|
|
3421
|
+
},
|
|
3422
|
+
__wbg_maxComputeWorkgroupSizeY_54fecee60bfa33ae: function(arg0) {
|
|
3423
|
+
const ret = arg0.maxComputeWorkgroupSizeY;
|
|
3424
|
+
return ret;
|
|
3425
|
+
},
|
|
3426
|
+
__wbg_maxComputeWorkgroupSizeZ_868f559f4eebf95f: function(arg0) {
|
|
3427
|
+
const ret = arg0.maxComputeWorkgroupSizeZ;
|
|
3428
|
+
return ret;
|
|
3429
|
+
},
|
|
3430
|
+
__wbg_maxComputeWorkgroupStorageSize_b4fd07bd827bde34: function(arg0) {
|
|
3431
|
+
const ret = arg0.maxComputeWorkgroupStorageSize;
|
|
3432
|
+
return ret;
|
|
3433
|
+
},
|
|
3434
|
+
__wbg_maxComputeWorkgroupsPerDimension_2d88e3f8e1f984fc: function(arg0) {
|
|
3435
|
+
const ret = arg0.maxComputeWorkgroupsPerDimension;
|
|
3436
|
+
return ret;
|
|
3437
|
+
},
|
|
3438
|
+
__wbg_maxDynamicStorageBuffersPerPipelineLayout_d6f0075161a2ec8e: function(arg0) {
|
|
3439
|
+
const ret = arg0.maxDynamicStorageBuffersPerPipelineLayout;
|
|
3440
|
+
return ret;
|
|
3441
|
+
},
|
|
3442
|
+
__wbg_maxDynamicUniformBuffersPerPipelineLayout_4fc01fff17019d2b: function(arg0) {
|
|
3443
|
+
const ret = arg0.maxDynamicUniformBuffersPerPipelineLayout;
|
|
3444
|
+
return ret;
|
|
3445
|
+
},
|
|
3446
|
+
__wbg_maxSampledTexturesPerShaderStage_224452301226d09a: function(arg0) {
|
|
3447
|
+
const ret = arg0.maxSampledTexturesPerShaderStage;
|
|
3448
|
+
return ret;
|
|
3449
|
+
},
|
|
3450
|
+
__wbg_maxSamplersPerShaderStage_34936f99dde7ae66: function(arg0) {
|
|
3451
|
+
const ret = arg0.maxSamplersPerShaderStage;
|
|
3452
|
+
return ret;
|
|
3453
|
+
},
|
|
3454
|
+
__wbg_maxStorageBufferBindingSize_9582c7cfe68faac0: function(arg0) {
|
|
3455
|
+
const ret = arg0.maxStorageBufferBindingSize;
|
|
3456
|
+
return ret;
|
|
3457
|
+
},
|
|
3458
|
+
__wbg_maxStorageBuffersPerShaderStage_6403069e851040db: function(arg0) {
|
|
3459
|
+
const ret = arg0.maxStorageBuffersPerShaderStage;
|
|
3460
|
+
return ret;
|
|
3461
|
+
},
|
|
3462
|
+
__wbg_maxStorageTexturesPerShaderStage_e44d7d6ed85de663: function(arg0) {
|
|
3463
|
+
const ret = arg0.maxStorageTexturesPerShaderStage;
|
|
3464
|
+
return ret;
|
|
3465
|
+
},
|
|
3466
|
+
__wbg_maxTextureArrayLayers_0f2fe636cc0fa44f: function(arg0) {
|
|
3467
|
+
const ret = arg0.maxTextureArrayLayers;
|
|
3468
|
+
return ret;
|
|
3469
|
+
},
|
|
3470
|
+
__wbg_maxTextureDimension1D_501e1e21119c564f: function(arg0) {
|
|
3471
|
+
const ret = arg0.maxTextureDimension1D;
|
|
3472
|
+
return ret;
|
|
3473
|
+
},
|
|
3474
|
+
__wbg_maxTextureDimension2D_ac594a0008180ab6: function(arg0) {
|
|
3475
|
+
const ret = arg0.maxTextureDimension2D;
|
|
3476
|
+
return ret;
|
|
3477
|
+
},
|
|
3478
|
+
__wbg_maxTextureDimension3D_8e5638a46d5786b0: function(arg0) {
|
|
3479
|
+
const ret = arg0.maxTextureDimension3D;
|
|
3480
|
+
return ret;
|
|
3481
|
+
},
|
|
3482
|
+
__wbg_maxUniformBufferBindingSize_a4c4feca62b81571: function(arg0) {
|
|
3483
|
+
const ret = arg0.maxUniformBufferBindingSize;
|
|
3484
|
+
return ret;
|
|
3485
|
+
},
|
|
3486
|
+
__wbg_maxUniformBuffersPerShaderStage_505f14dd3f814492: function(arg0) {
|
|
3487
|
+
const ret = arg0.maxUniformBuffersPerShaderStage;
|
|
3488
|
+
return ret;
|
|
3489
|
+
},
|
|
3490
|
+
__wbg_maxVertexAttributes_c4f4881b2d20616b: function(arg0) {
|
|
3491
|
+
const ret = arg0.maxVertexAttributes;
|
|
3492
|
+
return ret;
|
|
3493
|
+
},
|
|
3494
|
+
__wbg_maxVertexBufferArrayStride_da0782b779fc1a38: function(arg0) {
|
|
3495
|
+
const ret = arg0.maxVertexBufferArrayStride;
|
|
3496
|
+
return ret;
|
|
3497
|
+
},
|
|
3498
|
+
__wbg_maxVertexBuffers_90e848bae7f01af3: function(arg0) {
|
|
3499
|
+
const ret = arg0.maxVertexBuffers;
|
|
3500
|
+
return ret;
|
|
3501
|
+
},
|
|
3502
|
+
__wbg_minStorageBufferOffsetAlignment_58fcc139ce14bbb9: function(arg0) {
|
|
3503
|
+
const ret = arg0.minStorageBufferOffsetAlignment;
|
|
3504
|
+
return ret;
|
|
3505
|
+
},
|
|
3506
|
+
__wbg_minUniformBufferOffsetAlignment_33ca7570ff80f825: function(arg0) {
|
|
3507
|
+
const ret = arg0.minUniformBufferOffsetAlignment;
|
|
3508
|
+
return ret;
|
|
3509
|
+
},
|
|
3510
|
+
__wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
|
|
3511
|
+
const ret = arg0.msCrypto;
|
|
3512
|
+
return ret;
|
|
3513
|
+
},
|
|
3514
|
+
__wbg_navigator_51379c10a84aeec9: function(arg0) {
|
|
3515
|
+
const ret = arg0.navigator;
|
|
3516
|
+
return ret;
|
|
3517
|
+
},
|
|
3518
|
+
__wbg_navigator_99621db14b3f1099: function(arg0) {
|
|
3519
|
+
const ret = arg0.navigator;
|
|
3520
|
+
return ret;
|
|
3521
|
+
},
|
|
3522
|
+
__wbg_new_0_3da9e97f24fc69be: function() {
|
|
3523
|
+
const ret = new Date();
|
|
3524
|
+
return ret;
|
|
3525
|
+
},
|
|
3526
|
+
__wbg_new_32b398fb48b6d94a: function() {
|
|
3527
|
+
const ret = new Array();
|
|
3528
|
+
return ret;
|
|
3529
|
+
},
|
|
3530
|
+
__wbg_new_cd45aabdf6073e84: function(arg0) {
|
|
3531
|
+
const ret = new Uint8Array(arg0);
|
|
3532
|
+
return ret;
|
|
3533
|
+
},
|
|
3534
|
+
__wbg_new_da52cf8fe3429cb2: function() {
|
|
3535
|
+
const ret = new Object();
|
|
3536
|
+
return ret;
|
|
3537
|
+
},
|
|
3538
|
+
__wbg_new_from_slice_77cdfb7977362f3c: function(arg0, arg1) {
|
|
3539
|
+
const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
|
|
3540
|
+
return ret;
|
|
3541
|
+
},
|
|
3542
|
+
__wbg_new_with_byte_offset_and_length_54c7724ee3ec7d82: function(arg0, arg1, arg2) {
|
|
3543
|
+
const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
|
|
3544
|
+
return ret;
|
|
3545
|
+
},
|
|
3546
|
+
__wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
|
|
3547
|
+
const ret = new Uint8Array(arg0 >>> 0);
|
|
3548
|
+
return ret;
|
|
3549
|
+
},
|
|
3550
|
+
__wbg_node_84ea875411254db1: function(arg0) {
|
|
3551
|
+
const ret = arg0.node;
|
|
3552
|
+
return ret;
|
|
3553
|
+
},
|
|
3554
|
+
__wbg_now_86c0d4ba3fa605b8: function() {
|
|
3555
|
+
const ret = Date.now();
|
|
3556
|
+
return ret;
|
|
3557
|
+
},
|
|
3558
|
+
__wbg_ok_acc5e3fb89668864: function(arg0) {
|
|
3559
|
+
const ret = arg0.ok;
|
|
3560
|
+
return ret;
|
|
3561
|
+
},
|
|
3562
|
+
__wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
|
|
3563
|
+
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
|
|
3564
|
+
return ret;
|
|
3565
|
+
}, arguments); },
|
|
3566
|
+
__wbg_process_44c7a14e11e9f69e: function(arg0) {
|
|
3567
|
+
const ret = arg0.process;
|
|
3568
|
+
return ret;
|
|
3569
|
+
},
|
|
3570
|
+
__wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
|
|
3571
|
+
Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
|
|
3572
|
+
},
|
|
3573
|
+
__wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
|
|
3574
|
+
const ret = arg0.push(arg1);
|
|
3575
|
+
return ret;
|
|
3576
|
+
},
|
|
3577
|
+
__wbg_queueMicrotask_0ab5b2d2393e99b9: function(arg0) {
|
|
3578
|
+
const ret = arg0.queueMicrotask;
|
|
3579
|
+
return ret;
|
|
3580
|
+
},
|
|
3581
|
+
__wbg_queueMicrotask_6a09b7bc46549209: function(arg0) {
|
|
3582
|
+
queueMicrotask(arg0);
|
|
3583
|
+
},
|
|
3584
|
+
__wbg_queue_8cb065d04b06cb13: function(arg0) {
|
|
3585
|
+
const ret = arg0.queue;
|
|
3586
|
+
return ret;
|
|
3587
|
+
},
|
|
3588
|
+
__wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
|
|
3589
|
+
arg0.randomFillSync(arg1);
|
|
3590
|
+
}, arguments); },
|
|
3591
|
+
__wbg_requestAdapter_4814cb479d2dcf15: function(arg0, arg1) {
|
|
3592
|
+
const ret = arg0.requestAdapter(arg1);
|
|
3593
|
+
return ret;
|
|
3594
|
+
},
|
|
3595
|
+
__wbg_requestDevice_1b8f321791aa8b00: function(arg0, arg1) {
|
|
3596
|
+
const ret = arg0.requestDevice(arg1);
|
|
3597
|
+
return ret;
|
|
3598
|
+
},
|
|
3599
|
+
__wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
|
|
3600
|
+
const ret = module.require;
|
|
3601
|
+
return ret;
|
|
3602
|
+
}, arguments); },
|
|
3603
|
+
__wbg_resolve_2191a4dfe481c25b: function(arg0) {
|
|
3604
|
+
const ret = Promise.resolve(arg0);
|
|
3605
|
+
return ret;
|
|
3606
|
+
},
|
|
3607
|
+
__wbg_setBindGroup_9fdf11fd244aa68a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
3608
|
+
arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
|
|
3609
|
+
}, arguments); },
|
|
3610
|
+
__wbg_setBindGroup_a7e88440d0ecac88: function(arg0, arg1, arg2) {
|
|
3611
|
+
arg0.setBindGroup(arg1 >>> 0, arg2);
|
|
3612
|
+
},
|
|
3613
|
+
__wbg_setPipeline_092493bfd77760ee: function(arg0, arg1) {
|
|
3614
|
+
arg0.setPipeline(arg1);
|
|
3615
|
+
},
|
|
3616
|
+
__wbg_setVertexBuffer_1ed692dc2726f6c3: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3617
|
+
arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
|
|
3618
|
+
},
|
|
3619
|
+
__wbg_set_61e45ae8061eca11: function(arg0, arg1, arg2) {
|
|
3620
|
+
arg0.set(arg1, arg2 >>> 0);
|
|
3621
|
+
},
|
|
3622
|
+
__wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
|
|
3623
|
+
const ret = Reflect.set(arg0, arg1, arg2);
|
|
3624
|
+
return ret;
|
|
3625
|
+
}, arguments); },
|
|
3626
|
+
__wbg_set_a_9b35e9a1b60244b3: function(arg0, arg1) {
|
|
3627
|
+
arg0.a = arg1;
|
|
3628
|
+
},
|
|
3629
|
+
__wbg_set_access_67a4b0ae1c0f32f5: function(arg0, arg1) {
|
|
3630
|
+
arg0.access = __wbindgen_enum_GpuStorageTextureAccess[arg1];
|
|
3631
|
+
},
|
|
3632
|
+
__wbg_set_address_mode_u_1a44abe112b27750: function(arg0, arg1) {
|
|
3633
|
+
arg0.addressModeU = __wbindgen_enum_GpuAddressMode[arg1];
|
|
3634
|
+
},
|
|
3635
|
+
__wbg_set_address_mode_v_764da2dbc77dbf3e: function(arg0, arg1) {
|
|
3636
|
+
arg0.addressModeV = __wbindgen_enum_GpuAddressMode[arg1];
|
|
3637
|
+
},
|
|
3638
|
+
__wbg_set_address_mode_w_7c5135c7d56f9b4c: function(arg0, arg1) {
|
|
3639
|
+
arg0.addressModeW = __wbindgen_enum_GpuAddressMode[arg1];
|
|
3640
|
+
},
|
|
3641
|
+
__wbg_set_alpha_52d96a0bda4f4afe: function(arg0, arg1) {
|
|
3642
|
+
arg0.alpha = arg1;
|
|
3643
|
+
},
|
|
3644
|
+
__wbg_set_alpha_mode_5c1f4c4115bbe318: function(arg0, arg1) {
|
|
3645
|
+
arg0.alphaMode = __wbindgen_enum_GpuCanvasAlphaMode[arg1];
|
|
3646
|
+
},
|
|
3647
|
+
__wbg_set_alpha_to_coverage_enabled_36cef063cffb5d84: function(arg0, arg1) {
|
|
3648
|
+
arg0.alphaToCoverageEnabled = arg1 !== 0;
|
|
3649
|
+
},
|
|
3650
|
+
__wbg_set_array_layer_count_c2e975f5b62596bb: function(arg0, arg1) {
|
|
3651
|
+
arg0.arrayLayerCount = arg1 >>> 0;
|
|
3652
|
+
},
|
|
3653
|
+
__wbg_set_array_stride_eb9d409a95d2c1b3: function(arg0, arg1) {
|
|
3654
|
+
arg0.arrayStride = arg1;
|
|
3655
|
+
},
|
|
3656
|
+
__wbg_set_aspect_a453970e75d8e849: function(arg0, arg1) {
|
|
3657
|
+
arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
|
|
3658
|
+
},
|
|
3659
|
+
__wbg_set_attributes_edcbef656678a257: function(arg0, arg1) {
|
|
3660
|
+
arg0.attributes = arg1;
|
|
3661
|
+
},
|
|
3662
|
+
__wbg_set_b_5708a52cef50b19f: function(arg0, arg1) {
|
|
3663
|
+
arg0.b = arg1;
|
|
3664
|
+
},
|
|
3665
|
+
__wbg_set_base_array_layer_b67db9750fbc7053: function(arg0, arg1) {
|
|
3666
|
+
arg0.baseArrayLayer = arg1 >>> 0;
|
|
3667
|
+
},
|
|
3668
|
+
__wbg_set_base_mip_level_35f2fc3293e96083: function(arg0, arg1) {
|
|
3669
|
+
arg0.baseMipLevel = arg1 >>> 0;
|
|
3670
|
+
},
|
|
3671
|
+
__wbg_set_beginning_of_pass_write_index_8e570668cd8cad5e: function(arg0, arg1) {
|
|
3672
|
+
arg0.beginningOfPassWriteIndex = arg1 >>> 0;
|
|
3673
|
+
},
|
|
3674
|
+
__wbg_set_bind_group_layouts_436bd62a9b35e1ab: function(arg0, arg1) {
|
|
3675
|
+
arg0.bindGroupLayouts = arg1;
|
|
3676
|
+
},
|
|
3677
|
+
__wbg_set_binding_b575483e08d5ba4a: function(arg0, arg1) {
|
|
3678
|
+
arg0.binding = arg1 >>> 0;
|
|
3679
|
+
},
|
|
3680
|
+
__wbg_set_binding_c9feebb53a130ebe: function(arg0, arg1) {
|
|
3681
|
+
arg0.binding = arg1 >>> 0;
|
|
3682
|
+
},
|
|
3683
|
+
__wbg_set_blend_765238525504b1db: function(arg0, arg1) {
|
|
3684
|
+
arg0.blend = arg1;
|
|
3685
|
+
},
|
|
3686
|
+
__wbg_set_buffer_468874ee2bc9df02: function(arg0, arg1) {
|
|
3687
|
+
arg0.buffer = arg1;
|
|
3688
|
+
},
|
|
3689
|
+
__wbg_set_buffer_6c45652fb024e808: function(arg0, arg1) {
|
|
3690
|
+
arg0.buffer = arg1;
|
|
3691
|
+
},
|
|
3692
|
+
__wbg_set_buffer_83041e80a2b2c1b9: function(arg0, arg1) {
|
|
3693
|
+
arg0.buffer = arg1;
|
|
3694
|
+
},
|
|
3695
|
+
__wbg_set_buffers_986b265eda61fae6: function(arg0, arg1) {
|
|
3696
|
+
arg0.buffers = arg1;
|
|
3697
|
+
},
|
|
3698
|
+
__wbg_set_bytes_per_row_c127092e4fe9be22: function(arg0, arg1) {
|
|
3699
|
+
arg0.bytesPerRow = arg1 >>> 0;
|
|
3700
|
+
},
|
|
3701
|
+
__wbg_set_bytes_per_row_fecf7d0d8d5038d0: function(arg0, arg1) {
|
|
3702
|
+
arg0.bytesPerRow = arg1 >>> 0;
|
|
3703
|
+
},
|
|
3704
|
+
__wbg_set_clear_value_764be6f32f502d0a: function(arg0, arg1) {
|
|
3705
|
+
arg0.clearValue = arg1;
|
|
3706
|
+
},
|
|
3707
|
+
__wbg_set_code_0a82fa86cf58ca3b: function(arg0, arg1, arg2) {
|
|
3708
|
+
arg0.code = getStringFromWasm0(arg1, arg2);
|
|
3709
|
+
},
|
|
3710
|
+
__wbg_set_color_attachments_fad73def169d9610: function(arg0, arg1) {
|
|
3711
|
+
arg0.colorAttachments = arg1;
|
|
3712
|
+
},
|
|
3713
|
+
__wbg_set_color_c25fb8769b4f010f: function(arg0, arg1) {
|
|
3714
|
+
arg0.color = arg1;
|
|
3715
|
+
},
|
|
3716
|
+
__wbg_set_compare_1e2214a402af6db3: function(arg0, arg1) {
|
|
3717
|
+
arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
3718
|
+
},
|
|
3719
|
+
__wbg_set_compare_e61cc62d8f7e2191: function(arg0, arg1) {
|
|
3720
|
+
arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
3721
|
+
},
|
|
3722
|
+
__wbg_set_count_f285d8c62f4de679: function(arg0, arg1) {
|
|
3723
|
+
arg0.count = arg1 >>> 0;
|
|
3724
|
+
},
|
|
3725
|
+
__wbg_set_cull_mode_e6ca97d167dede04: function(arg0, arg1) {
|
|
3726
|
+
arg0.cullMode = __wbindgen_enum_GpuCullMode[arg1];
|
|
3727
|
+
},
|
|
3728
|
+
__wbg_set_depth_bias_clamp_e8da3e9edc037b18: function(arg0, arg1) {
|
|
3729
|
+
arg0.depthBiasClamp = arg1;
|
|
3730
|
+
},
|
|
3731
|
+
__wbg_set_depth_bias_edf83e7d032bdd2a: function(arg0, arg1) {
|
|
3732
|
+
arg0.depthBias = arg1;
|
|
3733
|
+
},
|
|
3734
|
+
__wbg_set_depth_bias_slope_scale_1746553a2d960310: function(arg0, arg1) {
|
|
3735
|
+
arg0.depthBiasSlopeScale = arg1;
|
|
3736
|
+
},
|
|
3737
|
+
__wbg_set_depth_clear_value_f6f20e460b0c4012: function(arg0, arg1) {
|
|
3738
|
+
arg0.depthClearValue = arg1;
|
|
3739
|
+
},
|
|
3740
|
+
__wbg_set_depth_compare_f18e709a5dc4a0b0: function(arg0, arg1) {
|
|
3741
|
+
arg0.depthCompare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
3742
|
+
},
|
|
3743
|
+
__wbg_set_depth_fail_op_45f4179ddfc376cd: function(arg0, arg1) {
|
|
3744
|
+
arg0.depthFailOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
3745
|
+
},
|
|
3746
|
+
__wbg_set_depth_load_op_c3d15137e916dd5a: function(arg0, arg1) {
|
|
3747
|
+
arg0.depthLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
3748
|
+
},
|
|
3749
|
+
__wbg_set_depth_or_array_layers_17284e1eac0007a1: function(arg0, arg1) {
|
|
3750
|
+
arg0.depthOrArrayLayers = arg1 >>> 0;
|
|
3751
|
+
},
|
|
3752
|
+
__wbg_set_depth_read_only_9a8994459a0acf9e: function(arg0, arg1) {
|
|
3753
|
+
arg0.depthReadOnly = arg1 !== 0;
|
|
3754
|
+
},
|
|
3755
|
+
__wbg_set_depth_stencil_8716a627d44d796e: function(arg0, arg1) {
|
|
3756
|
+
arg0.depthStencil = arg1;
|
|
3757
|
+
},
|
|
3758
|
+
__wbg_set_depth_stencil_attachment_08fe1db9243adb49: function(arg0, arg1) {
|
|
3759
|
+
arg0.depthStencilAttachment = arg1;
|
|
3760
|
+
},
|
|
3761
|
+
__wbg_set_depth_store_op_881c8dbe0d67045d: function(arg0, arg1) {
|
|
3762
|
+
arg0.depthStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
3763
|
+
},
|
|
3764
|
+
__wbg_set_depth_write_enabled_9b608c3bf190f04a: function(arg0, arg1) {
|
|
3765
|
+
arg0.depthWriteEnabled = arg1 !== 0;
|
|
3766
|
+
},
|
|
3767
|
+
__wbg_set_device_bf67f52a587f9aab: function(arg0, arg1) {
|
|
3768
|
+
arg0.device = arg1;
|
|
3769
|
+
},
|
|
3770
|
+
__wbg_set_dimension_3144c827eb67b110: function(arg0, arg1) {
|
|
3771
|
+
arg0.dimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
3772
|
+
},
|
|
3773
|
+
__wbg_set_dimension_9054f7ab0acbfd31: function(arg0, arg1) {
|
|
3774
|
+
arg0.dimension = __wbindgen_enum_GpuTextureDimension[arg1];
|
|
3775
|
+
},
|
|
3776
|
+
__wbg_set_dst_factor_77c088c0ad43b684: function(arg0, arg1) {
|
|
3777
|
+
arg0.dstFactor = __wbindgen_enum_GpuBlendFactor[arg1];
|
|
3778
|
+
},
|
|
3779
|
+
__wbg_set_end_of_pass_write_index_568e7295b1b273a3: function(arg0, arg1) {
|
|
3780
|
+
arg0.endOfPassWriteIndex = arg1 >>> 0;
|
|
3781
|
+
},
|
|
3782
|
+
__wbg_set_entries_247b5e665db79583: function(arg0, arg1) {
|
|
3783
|
+
arg0.entries = arg1;
|
|
3784
|
+
},
|
|
3785
|
+
__wbg_set_entries_bfbb6a7f04b96709: function(arg0, arg1) {
|
|
3786
|
+
arg0.entries = arg1;
|
|
3787
|
+
},
|
|
3788
|
+
__wbg_set_entry_point_1d7ecf099e15fa2b: function(arg0, arg1, arg2) {
|
|
3789
|
+
arg0.entryPoint = getStringFromWasm0(arg1, arg2);
|
|
3790
|
+
},
|
|
3791
|
+
__wbg_set_entry_point_a698bc91b472d5a9: function(arg0, arg1, arg2) {
|
|
3792
|
+
arg0.entryPoint = getStringFromWasm0(arg1, arg2);
|
|
3793
|
+
},
|
|
3794
|
+
__wbg_set_external_texture_a0db2eb13c76e01c: function(arg0, arg1) {
|
|
3795
|
+
arg0.externalTexture = arg1;
|
|
3796
|
+
},
|
|
3797
|
+
__wbg_set_fail_op_a6890cff6b560a14: function(arg0, arg1) {
|
|
3798
|
+
arg0.failOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
3799
|
+
},
|
|
3800
|
+
__wbg_set_format_237b3e4047d1be9a: function(arg0, arg1) {
|
|
3801
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3802
|
+
},
|
|
3803
|
+
__wbg_set_format_53479155b45c92ea: function(arg0, arg1) {
|
|
3804
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3805
|
+
},
|
|
3806
|
+
__wbg_set_format_7c20bfc7e4802e1e: function(arg0, arg1) {
|
|
3807
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3808
|
+
},
|
|
3809
|
+
__wbg_set_format_84af8ed546a319fa: function(arg0, arg1) {
|
|
3810
|
+
arg0.format = __wbindgen_enum_GpuVertexFormat[arg1];
|
|
3811
|
+
},
|
|
3812
|
+
__wbg_set_format_9f32450123336995: function(arg0, arg1) {
|
|
3813
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3814
|
+
},
|
|
3815
|
+
__wbg_set_format_c9dcecebf9c1e619: function(arg0, arg1) {
|
|
3816
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3817
|
+
},
|
|
3818
|
+
__wbg_set_format_d9d3420c1a9d1c59: function(arg0, arg1) {
|
|
3819
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3820
|
+
},
|
|
3821
|
+
__wbg_set_fragment_2c6f6192456fed1c: function(arg0, arg1) {
|
|
3822
|
+
arg0.fragment = arg1;
|
|
3823
|
+
},
|
|
3824
|
+
__wbg_set_front_face_fd34f06ac9239d11: function(arg0, arg1) {
|
|
3825
|
+
arg0.frontFace = __wbindgen_enum_GpuFrontFace[arg1];
|
|
3826
|
+
},
|
|
3827
|
+
__wbg_set_g_7bb456722103c5e6: function(arg0, arg1) {
|
|
3828
|
+
arg0.g = arg1;
|
|
3829
|
+
},
|
|
3830
|
+
__wbg_set_has_dynamic_offset_0c8a607543be8069: function(arg0, arg1) {
|
|
3831
|
+
arg0.hasDynamicOffset = arg1 !== 0;
|
|
3832
|
+
},
|
|
3833
|
+
__wbg_set_height_7d9d8f892e6964c6: function(arg0, arg1) {
|
|
3834
|
+
arg0.height = arg1 >>> 0;
|
|
3835
|
+
},
|
|
3836
|
+
__wbg_set_height_96611e96eee67c44: function(arg0, arg1) {
|
|
3837
|
+
arg0.height = arg1 >>> 0;
|
|
3838
|
+
},
|
|
3839
|
+
__wbg_set_height_bbeef8f354041577: function(arg0, arg1) {
|
|
3840
|
+
arg0.height = arg1 >>> 0;
|
|
3841
|
+
},
|
|
3842
|
+
__wbg_set_label_01228663ea03b92f: function(arg0, arg1, arg2) {
|
|
3843
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3844
|
+
},
|
|
3845
|
+
__wbg_set_label_13a2dd9810399e8b: function(arg0, arg1, arg2) {
|
|
3846
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3847
|
+
},
|
|
3848
|
+
__wbg_set_label_22e57f4c5b38215f: function(arg0, arg1, arg2) {
|
|
3849
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3850
|
+
},
|
|
3851
|
+
__wbg_set_label_382417d222111912: function(arg0, arg1, arg2) {
|
|
3852
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3853
|
+
},
|
|
3854
|
+
__wbg_set_label_4d049edb707ba31c: function(arg0, arg1, arg2) {
|
|
3855
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3856
|
+
},
|
|
3857
|
+
__wbg_set_label_5724e5c6286e8a4e: function(arg0, arg1, arg2) {
|
|
3858
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3859
|
+
},
|
|
3860
|
+
__wbg_set_label_8354c6463558484f: function(arg0, arg1, arg2) {
|
|
3861
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3862
|
+
},
|
|
3863
|
+
__wbg_set_label_acd66edf00f8e40f: function(arg0, arg1, arg2) {
|
|
3864
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3865
|
+
},
|
|
3866
|
+
__wbg_set_label_b3da7636c69f1a4c: function(arg0, arg1, arg2) {
|
|
3867
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3868
|
+
},
|
|
3869
|
+
__wbg_set_label_b7f797c13bc822c4: function(arg0, arg1, arg2) {
|
|
3870
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3871
|
+
},
|
|
3872
|
+
__wbg_set_label_e026aa2aea731594: function(arg0, arg1, arg2) {
|
|
3873
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3874
|
+
},
|
|
3875
|
+
__wbg_set_label_e6bc3b86ef6deeb8: function(arg0, arg1, arg2) {
|
|
3876
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3877
|
+
},
|
|
3878
|
+
__wbg_set_label_e7f76bba99d72971: function(arg0, arg1, arg2) {
|
|
3879
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3880
|
+
},
|
|
3881
|
+
__wbg_set_layout_210c56f1b01e883b: function(arg0, arg1) {
|
|
3882
|
+
arg0.layout = arg1;
|
|
3883
|
+
},
|
|
3884
|
+
__wbg_set_layout_44943c4c7d78f826: function(arg0, arg1) {
|
|
3885
|
+
arg0.layout = arg1;
|
|
3886
|
+
},
|
|
3887
|
+
__wbg_set_load_op_103e6ce0a06327b3: function(arg0, arg1) {
|
|
3888
|
+
arg0.loadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
3889
|
+
},
|
|
3890
|
+
__wbg_set_lod_max_clamp_3706b17de6a5a11a: function(arg0, arg1) {
|
|
3891
|
+
arg0.lodMaxClamp = arg1;
|
|
3892
|
+
},
|
|
3893
|
+
__wbg_set_lod_min_clamp_1f4b28d77d0c87c4: function(arg0, arg1) {
|
|
3894
|
+
arg0.lodMinClamp = arg1;
|
|
3895
|
+
},
|
|
3896
|
+
__wbg_set_mag_filter_2c8c212ff297b151: function(arg0, arg1) {
|
|
3897
|
+
arg0.magFilter = __wbindgen_enum_GpuFilterMode[arg1];
|
|
3898
|
+
},
|
|
3899
|
+
__wbg_set_mapped_at_creation_12773dff1bb6ea0f: function(arg0, arg1) {
|
|
3900
|
+
arg0.mappedAtCreation = arg1 !== 0;
|
|
3901
|
+
},
|
|
3902
|
+
__wbg_set_mask_94311bacf22c96b1: function(arg0, arg1) {
|
|
3903
|
+
arg0.mask = arg1 >>> 0;
|
|
3904
|
+
},
|
|
3905
|
+
__wbg_set_max_anisotropy_56bff110d0b4830f: function(arg0, arg1) {
|
|
3906
|
+
arg0.maxAnisotropy = arg1;
|
|
3907
|
+
},
|
|
3908
|
+
__wbg_set_min_binding_size_164df827e02821e1: function(arg0, arg1) {
|
|
3909
|
+
arg0.minBindingSize = arg1;
|
|
3910
|
+
},
|
|
3911
|
+
__wbg_set_min_filter_66d70efb70601bf9: function(arg0, arg1) {
|
|
3912
|
+
arg0.minFilter = __wbindgen_enum_GpuFilterMode[arg1];
|
|
3913
|
+
},
|
|
3914
|
+
__wbg_set_mip_level_7f56c1c607dda5cf: function(arg0, arg1) {
|
|
3915
|
+
arg0.mipLevel = arg1 >>> 0;
|
|
3916
|
+
},
|
|
3917
|
+
__wbg_set_mip_level_count_3402f5315a423b69: function(arg0, arg1) {
|
|
3918
|
+
arg0.mipLevelCount = arg1 >>> 0;
|
|
3919
|
+
},
|
|
3920
|
+
__wbg_set_mip_level_count_ed029120a0ee12b8: function(arg0, arg1) {
|
|
3921
|
+
arg0.mipLevelCount = arg1 >>> 0;
|
|
3922
|
+
},
|
|
3923
|
+
__wbg_set_mipmap_filter_1b3d153bd834ec26: function(arg0, arg1) {
|
|
3924
|
+
arg0.mipmapFilter = __wbindgen_enum_GpuMipmapFilterMode[arg1];
|
|
3925
|
+
},
|
|
3926
|
+
__wbg_set_module_119c125107e59165: function(arg0, arg1) {
|
|
3927
|
+
arg0.module = arg1;
|
|
3928
|
+
},
|
|
3929
|
+
__wbg_set_module_3336e0ce2672c07c: function(arg0, arg1) {
|
|
3930
|
+
arg0.module = arg1;
|
|
3931
|
+
},
|
|
3932
|
+
__wbg_set_multisample_1cdb4998c4f73341: function(arg0, arg1) {
|
|
3933
|
+
arg0.multisample = arg1;
|
|
3934
|
+
},
|
|
3935
|
+
__wbg_set_multisampled_e9d7bed0e68d1d6f: function(arg0, arg1) {
|
|
3936
|
+
arg0.multisampled = arg1 !== 0;
|
|
3937
|
+
},
|
|
3938
|
+
__wbg_set_offset_01c04218a4ccfa08: function(arg0, arg1) {
|
|
3939
|
+
arg0.offset = arg1;
|
|
3940
|
+
},
|
|
3941
|
+
__wbg_set_offset_5ea55c758ce6f103: function(arg0, arg1) {
|
|
3942
|
+
arg0.offset = arg1;
|
|
3943
|
+
},
|
|
3944
|
+
__wbg_set_offset_bd11f79890456c6f: function(arg0, arg1) {
|
|
3945
|
+
arg0.offset = arg1;
|
|
3946
|
+
},
|
|
3947
|
+
__wbg_set_offset_f07a73165707eb4c: function(arg0, arg1) {
|
|
3948
|
+
arg0.offset = arg1;
|
|
3949
|
+
},
|
|
3950
|
+
__wbg_set_operation_845ee9de4c1808be: function(arg0, arg1) {
|
|
3951
|
+
arg0.operation = __wbindgen_enum_GpuBlendOperation[arg1];
|
|
3952
|
+
},
|
|
3953
|
+
__wbg_set_origin_6be40076fb0623f4: function(arg0, arg1) {
|
|
3954
|
+
arg0.origin = arg1;
|
|
3955
|
+
},
|
|
3956
|
+
__wbg_set_pass_op_f4a566b4a6b819e0: function(arg0, arg1) {
|
|
3957
|
+
arg0.passOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
3958
|
+
},
|
|
3959
|
+
__wbg_set_power_preference_0721cf46746c0c7d: function(arg0, arg1) {
|
|
3960
|
+
arg0.powerPreference = __wbindgen_enum_GpuPowerPreference[arg1];
|
|
3961
|
+
},
|
|
3962
|
+
__wbg_set_primitive_94234ea756a4c469: function(arg0, arg1) {
|
|
3963
|
+
arg0.primitive = arg1;
|
|
3964
|
+
},
|
|
3965
|
+
__wbg_set_query_set_667d2dcfcedd1ec2: function(arg0, arg1) {
|
|
3966
|
+
arg0.querySet = arg1;
|
|
3967
|
+
},
|
|
3968
|
+
__wbg_set_r_13b3eba61d4ba4d9: function(arg0, arg1) {
|
|
3969
|
+
arg0.r = arg1;
|
|
3970
|
+
},
|
|
3971
|
+
__wbg_set_required_features_5202fa8cd082e531: function(arg0, arg1) {
|
|
3972
|
+
arg0.requiredFeatures = arg1;
|
|
3973
|
+
},
|
|
3974
|
+
__wbg_set_resolve_target_8251ec563ce24501: function(arg0, arg1) {
|
|
3975
|
+
arg0.resolveTarget = arg1;
|
|
3976
|
+
},
|
|
3977
|
+
__wbg_set_resource_c73d0c2d815f7211: function(arg0, arg1) {
|
|
3978
|
+
arg0.resource = arg1;
|
|
3979
|
+
},
|
|
3980
|
+
__wbg_set_rows_per_image_00c8e938dae40dae: function(arg0, arg1) {
|
|
3981
|
+
arg0.rowsPerImage = arg1 >>> 0;
|
|
3982
|
+
},
|
|
3983
|
+
__wbg_set_rows_per_image_e6e2c0c4a7e4fa8d: function(arg0, arg1) {
|
|
3984
|
+
arg0.rowsPerImage = arg1 >>> 0;
|
|
3985
|
+
},
|
|
3986
|
+
__wbg_set_sample_count_05dcc9952f4fa7ac: function(arg0, arg1) {
|
|
3987
|
+
arg0.sampleCount = arg1 >>> 0;
|
|
3988
|
+
},
|
|
3989
|
+
__wbg_set_sample_type_93886b8f9794f85c: function(arg0, arg1) {
|
|
3990
|
+
arg0.sampleType = __wbindgen_enum_GpuTextureSampleType[arg1];
|
|
3991
|
+
},
|
|
3992
|
+
__wbg_set_sampler_02989e99b27a50db: function(arg0, arg1) {
|
|
3993
|
+
arg0.sampler = arg1;
|
|
3994
|
+
},
|
|
3995
|
+
__wbg_set_shader_location_33bfc2cc417fdde2: function(arg0, arg1) {
|
|
3996
|
+
arg0.shaderLocation = arg1 >>> 0;
|
|
3997
|
+
},
|
|
3998
|
+
__wbg_set_size_b3e6b2bf58d62082: function(arg0, arg1) {
|
|
3999
|
+
arg0.size = arg1;
|
|
4000
|
+
},
|
|
4001
|
+
__wbg_set_size_c2a556d5571231f5: function(arg0, arg1) {
|
|
4002
|
+
arg0.size = arg1;
|
|
4003
|
+
},
|
|
4004
|
+
__wbg_set_size_f7b29f6cb1669c4d: function(arg0, arg1) {
|
|
4005
|
+
arg0.size = arg1;
|
|
4006
|
+
},
|
|
4007
|
+
__wbg_set_src_factor_deefdfd4b6427b5e: function(arg0, arg1) {
|
|
4008
|
+
arg0.srcFactor = __wbindgen_enum_GpuBlendFactor[arg1];
|
|
4009
|
+
},
|
|
4010
|
+
__wbg_set_stencil_back_9971eece60c613eb: function(arg0, arg1) {
|
|
4011
|
+
arg0.stencilBack = arg1;
|
|
4012
|
+
},
|
|
4013
|
+
__wbg_set_stencil_clear_value_4b82f2d7e6d9f496: function(arg0, arg1) {
|
|
4014
|
+
arg0.stencilClearValue = arg1 >>> 0;
|
|
4015
|
+
},
|
|
4016
|
+
__wbg_set_stencil_front_c82ccf19db426a5b: function(arg0, arg1) {
|
|
4017
|
+
arg0.stencilFront = arg1;
|
|
4018
|
+
},
|
|
4019
|
+
__wbg_set_stencil_load_op_dbc3af9713146f24: function(arg0, arg1) {
|
|
4020
|
+
arg0.stencilLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
4021
|
+
},
|
|
4022
|
+
__wbg_set_stencil_read_mask_926bce469fa8eaf3: function(arg0, arg1) {
|
|
4023
|
+
arg0.stencilReadMask = arg1 >>> 0;
|
|
4024
|
+
},
|
|
4025
|
+
__wbg_set_stencil_read_only_88136eaf94225fec: function(arg0, arg1) {
|
|
4026
|
+
arg0.stencilReadOnly = arg1 !== 0;
|
|
4027
|
+
},
|
|
4028
|
+
__wbg_set_stencil_store_op_e10e50255bf42e8b: function(arg0, arg1) {
|
|
4029
|
+
arg0.stencilStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
4030
|
+
},
|
|
4031
|
+
__wbg_set_stencil_write_mask_3a7b75284ae036de: function(arg0, arg1) {
|
|
4032
|
+
arg0.stencilWriteMask = arg1 >>> 0;
|
|
4033
|
+
},
|
|
4034
|
+
__wbg_set_step_mode_2a36020da93d6f16: function(arg0, arg1) {
|
|
4035
|
+
arg0.stepMode = __wbindgen_enum_GpuVertexStepMode[arg1];
|
|
4036
|
+
},
|
|
4037
|
+
__wbg_set_storage_texture_50af47fec531be02: function(arg0, arg1) {
|
|
4038
|
+
arg0.storageTexture = arg1;
|
|
4039
|
+
},
|
|
4040
|
+
__wbg_set_store_op_23c150f1deb52749: function(arg0, arg1) {
|
|
4041
|
+
arg0.storeOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
4042
|
+
},
|
|
4043
|
+
__wbg_set_strip_index_format_bd4035f66052e74e: function(arg0, arg1) {
|
|
4044
|
+
arg0.stripIndexFormat = __wbindgen_enum_GpuIndexFormat[arg1];
|
|
4045
|
+
},
|
|
4046
|
+
__wbg_set_targets_d4d849b9c6abd35a: function(arg0, arg1) {
|
|
4047
|
+
arg0.targets = arg1;
|
|
4048
|
+
},
|
|
4049
|
+
__wbg_set_texture_884f2777c0fe1e91: function(arg0, arg1) {
|
|
4050
|
+
arg0.texture = arg1;
|
|
4051
|
+
},
|
|
4052
|
+
__wbg_set_texture_a1baf7da91d20351: function(arg0, arg1) {
|
|
4053
|
+
arg0.texture = arg1;
|
|
4054
|
+
},
|
|
4055
|
+
__wbg_set_timestamp_writes_fdf8168751575b7f: function(arg0, arg1) {
|
|
4056
|
+
arg0.timestampWrites = arg1;
|
|
4057
|
+
},
|
|
4058
|
+
__wbg_set_topology_0a07d5f484aff275: function(arg0, arg1) {
|
|
4059
|
+
arg0.topology = __wbindgen_enum_GpuPrimitiveTopology[arg1];
|
|
4060
|
+
},
|
|
4061
|
+
__wbg_set_type_109702a7ec65b49d: function(arg0, arg1) {
|
|
4062
|
+
arg0.type = __wbindgen_enum_GpuSamplerBindingType[arg1];
|
|
4063
|
+
},
|
|
4064
|
+
__wbg_set_type_55112c374bcc5a9d: function(arg0, arg1) {
|
|
4065
|
+
arg0.type = __wbindgen_enum_GpuBufferBindingType[arg1];
|
|
4066
|
+
},
|
|
4067
|
+
__wbg_set_unclipped_depth_b15740038a226817: function(arg0, arg1) {
|
|
4068
|
+
arg0.unclippedDepth = arg1 !== 0;
|
|
4069
|
+
},
|
|
4070
|
+
__wbg_set_usage_75d0e81d39ff5284: function(arg0, arg1) {
|
|
4071
|
+
arg0.usage = arg1 >>> 0;
|
|
4072
|
+
},
|
|
4073
|
+
__wbg_set_usage_ac04cadda4108c1a: function(arg0, arg1) {
|
|
4074
|
+
arg0.usage = arg1 >>> 0;
|
|
4075
|
+
},
|
|
4076
|
+
__wbg_set_usage_ad30cd3b0e0f4244: function(arg0, arg1) {
|
|
4077
|
+
arg0.usage = arg1 >>> 0;
|
|
4078
|
+
},
|
|
4079
|
+
__wbg_set_usage_cc34543608cf3335: function(arg0, arg1) {
|
|
4080
|
+
arg0.usage = arg1 >>> 0;
|
|
4081
|
+
},
|
|
4082
|
+
__wbg_set_vertex_13029c78ba2f0430: function(arg0, arg1) {
|
|
4083
|
+
arg0.vertex = arg1;
|
|
4084
|
+
},
|
|
4085
|
+
__wbg_set_view_6f2831c0da43be15: function(arg0, arg1) {
|
|
4086
|
+
arg0.view = arg1;
|
|
4087
|
+
},
|
|
4088
|
+
__wbg_set_view_b18c2cccd427261d: function(arg0, arg1) {
|
|
4089
|
+
arg0.view = arg1;
|
|
4090
|
+
},
|
|
4091
|
+
__wbg_set_view_dimension_50f3edb06107948f: function(arg0, arg1) {
|
|
4092
|
+
arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
4093
|
+
},
|
|
4094
|
+
__wbg_set_view_dimension_925bb358df1f2b9d: function(arg0, arg1) {
|
|
4095
|
+
arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
4096
|
+
},
|
|
4097
|
+
__wbg_set_view_formats_3d2a72ffb1f55a75: function(arg0, arg1) {
|
|
4098
|
+
arg0.viewFormats = arg1;
|
|
4099
|
+
},
|
|
4100
|
+
__wbg_set_view_formats_ae87e8e12aa858fc: function(arg0, arg1) {
|
|
4101
|
+
arg0.viewFormats = arg1;
|
|
4102
|
+
},
|
|
4103
|
+
__wbg_set_visibility_bdebc70a7c0f236d: function(arg0, arg1) {
|
|
4104
|
+
arg0.visibility = arg1 >>> 0;
|
|
4105
|
+
},
|
|
4106
|
+
__wbg_set_width_40592253da7b2113: function(arg0, arg1) {
|
|
4107
|
+
arg0.width = arg1 >>> 0;
|
|
4108
|
+
},
|
|
4109
|
+
__wbg_set_width_49ac9b7d914afc85: function(arg0, arg1) {
|
|
4110
|
+
arg0.width = arg1 >>> 0;
|
|
4111
|
+
},
|
|
4112
|
+
__wbg_set_width_8e30d010cd66830d: function(arg0, arg1) {
|
|
4113
|
+
arg0.width = arg1 >>> 0;
|
|
4114
|
+
},
|
|
4115
|
+
__wbg_set_write_mask_c03e8a45a9236e80: function(arg0, arg1) {
|
|
4116
|
+
arg0.writeMask = arg1 >>> 0;
|
|
4117
|
+
},
|
|
4118
|
+
__wbg_set_x_3c1cb8191b848172: function(arg0, arg1) {
|
|
4119
|
+
arg0.x = arg1 >>> 0;
|
|
4120
|
+
},
|
|
4121
|
+
__wbg_set_y_9024331910317eff: function(arg0, arg1) {
|
|
4122
|
+
arg0.y = arg1 >>> 0;
|
|
4123
|
+
},
|
|
4124
|
+
__wbg_set_z_b6182f4c230116a7: function(arg0, arg1) {
|
|
4125
|
+
arg0.z = arg1 >>> 0;
|
|
4126
|
+
},
|
|
4127
|
+
__wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
|
|
4128
|
+
const ret = typeof global === 'undefined' ? null : global;
|
|
4129
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4130
|
+
},
|
|
4131
|
+
__wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
|
|
4132
|
+
const ret = typeof globalThis === 'undefined' ? null : globalThis;
|
|
4133
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4134
|
+
},
|
|
4135
|
+
__wbg_static_accessor_SELF_146583524fe1469b: function() {
|
|
4136
|
+
const ret = typeof self === 'undefined' ? null : self;
|
|
4137
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4138
|
+
},
|
|
4139
|
+
__wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
|
|
4140
|
+
const ret = typeof window === 'undefined' ? null : window;
|
|
4141
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4142
|
+
},
|
|
4143
|
+
__wbg_status_c45b3b9b3033184a: function(arg0) {
|
|
4144
|
+
const ret = arg0.status;
|
|
588
4145
|
return ret;
|
|
589
4146
|
},
|
|
590
|
-
|
|
591
|
-
|
|
4147
|
+
__wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
|
|
4148
|
+
const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
|
|
4149
|
+
return ret;
|
|
592
4150
|
},
|
|
593
|
-
|
|
594
|
-
|
|
4151
|
+
__wbg_submit_fc5b9a1154201a58: function(arg0, arg1) {
|
|
4152
|
+
arg0.submit(arg1);
|
|
4153
|
+
},
|
|
4154
|
+
__wbg_then_16d107c451e9905d: function(arg0, arg1, arg2) {
|
|
4155
|
+
const ret = arg0.then(arg1, arg2);
|
|
595
4156
|
return ret;
|
|
596
4157
|
},
|
|
597
|
-
|
|
598
|
-
const ret = arg0.
|
|
4158
|
+
__wbg_then_4a0b9283a66c4a8a: function(arg0, arg1, arg2) {
|
|
4159
|
+
const ret = arg0.then(arg1, arg2);
|
|
599
4160
|
return ret;
|
|
600
4161
|
},
|
|
601
|
-
|
|
602
|
-
const ret = arg0.
|
|
4162
|
+
__wbg_then_6ec10ae38b3e92f7: function(arg0, arg1) {
|
|
4163
|
+
const ret = arg0.then(arg1);
|
|
603
4164
|
return ret;
|
|
604
4165
|
},
|
|
605
|
-
|
|
606
|
-
|
|
4166
|
+
__wbg_unmap_50b3be4aaf23fa39: function(arg0) {
|
|
4167
|
+
arg0.unmap();
|
|
4168
|
+
},
|
|
4169
|
+
__wbg_versions_276b2795b1c6a219: function(arg0) {
|
|
4170
|
+
const ret = arg0.versions;
|
|
607
4171
|
return ret;
|
|
608
4172
|
},
|
|
609
|
-
|
|
610
|
-
|
|
4173
|
+
__wbg_writeTexture_9d4c493be748d189: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
4174
|
+
arg0.writeTexture(arg1, arg2, arg3, arg4);
|
|
4175
|
+
}, arguments); },
|
|
4176
|
+
__wbindgen_cast_0000000000000001: function(arg0, arg1) {
|
|
4177
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1895, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
4178
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691);
|
|
611
4179
|
return ret;
|
|
612
4180
|
},
|
|
613
|
-
|
|
614
|
-
|
|
4181
|
+
__wbindgen_cast_0000000000000002: function(arg0, arg1) {
|
|
4182
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3608, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
|
|
4183
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5);
|
|
615
4184
|
return ret;
|
|
616
4185
|
},
|
|
617
|
-
|
|
618
|
-
|
|
4186
|
+
__wbindgen_cast_0000000000000003: function(arg0) {
|
|
4187
|
+
// Cast intrinsic for `F64 -> Externref`.
|
|
4188
|
+
const ret = arg0;
|
|
619
4189
|
return ret;
|
|
620
4190
|
},
|
|
621
|
-
|
|
622
|
-
|
|
4191
|
+
__wbindgen_cast_0000000000000004: function(arg0, arg1) {
|
|
4192
|
+
// Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
|
|
4193
|
+
const ret = getArrayU8FromWasm0(arg0, arg1);
|
|
4194
|
+
return ret;
|
|
4195
|
+
},
|
|
4196
|
+
__wbindgen_cast_0000000000000005: function(arg0, arg1) {
|
|
4197
|
+
// Cast intrinsic for `Ref(String) -> Externref`.
|
|
4198
|
+
const ret = getStringFromWasm0(arg0, arg1);
|
|
623
4199
|
return ret;
|
|
624
4200
|
},
|
|
625
4201
|
__wbindgen_init_externref_table: function() {
|
|
@@ -638,17 +4214,209 @@ function __wbg_get_imports() {
|
|
|
638
4214
|
};
|
|
639
4215
|
}
|
|
640
4216
|
|
|
4217
|
+
function wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691(arg0, arg1, arg2) {
|
|
4218
|
+
wasm.wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691(arg0, arg1, arg2);
|
|
4219
|
+
}
|
|
4220
|
+
|
|
4221
|
+
function wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2) {
|
|
4222
|
+
const ret = wasm.wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2);
|
|
4223
|
+
if (ret[1]) {
|
|
4224
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
4225
|
+
}
|
|
4226
|
+
}
|
|
4227
|
+
|
|
4228
|
+
|
|
4229
|
+
const __wbindgen_enum_GpuAddressMode = ["clamp-to-edge", "repeat", "mirror-repeat"];
|
|
4230
|
+
|
|
4231
|
+
|
|
4232
|
+
const __wbindgen_enum_GpuBlendFactor = ["zero", "one", "src", "one-minus-src", "src-alpha", "one-minus-src-alpha", "dst", "one-minus-dst", "dst-alpha", "one-minus-dst-alpha", "src-alpha-saturated", "constant", "one-minus-constant", "src1", "one-minus-src1", "src1-alpha", "one-minus-src1-alpha"];
|
|
4233
|
+
|
|
4234
|
+
|
|
4235
|
+
const __wbindgen_enum_GpuBlendOperation = ["add", "subtract", "reverse-subtract", "min", "max"];
|
|
4236
|
+
|
|
4237
|
+
|
|
4238
|
+
const __wbindgen_enum_GpuBufferBindingType = ["uniform", "storage", "read-only-storage"];
|
|
4239
|
+
|
|
4240
|
+
|
|
4241
|
+
const __wbindgen_enum_GpuCanvasAlphaMode = ["opaque", "premultiplied"];
|
|
4242
|
+
|
|
4243
|
+
|
|
4244
|
+
const __wbindgen_enum_GpuCompareFunction = ["never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"];
|
|
4245
|
+
|
|
4246
|
+
|
|
4247
|
+
const __wbindgen_enum_GpuCullMode = ["none", "front", "back"];
|
|
4248
|
+
|
|
4249
|
+
|
|
4250
|
+
const __wbindgen_enum_GpuFilterMode = ["nearest", "linear"];
|
|
4251
|
+
|
|
4252
|
+
|
|
4253
|
+
const __wbindgen_enum_GpuFrontFace = ["ccw", "cw"];
|
|
4254
|
+
|
|
4255
|
+
|
|
4256
|
+
const __wbindgen_enum_GpuIndexFormat = ["uint16", "uint32"];
|
|
4257
|
+
|
|
4258
|
+
|
|
4259
|
+
const __wbindgen_enum_GpuLoadOp = ["load", "clear"];
|
|
4260
|
+
|
|
4261
|
+
|
|
4262
|
+
const __wbindgen_enum_GpuMipmapFilterMode = ["nearest", "linear"];
|
|
4263
|
+
|
|
4264
|
+
|
|
4265
|
+
const __wbindgen_enum_GpuPowerPreference = ["low-power", "high-performance"];
|
|
4266
|
+
|
|
4267
|
+
|
|
4268
|
+
const __wbindgen_enum_GpuPrimitiveTopology = ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"];
|
|
4269
|
+
|
|
4270
|
+
|
|
4271
|
+
const __wbindgen_enum_GpuSamplerBindingType = ["filtering", "non-filtering", "comparison"];
|
|
4272
|
+
|
|
4273
|
+
|
|
4274
|
+
const __wbindgen_enum_GpuStencilOperation = ["keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap"];
|
|
4275
|
+
|
|
4276
|
+
|
|
4277
|
+
const __wbindgen_enum_GpuStorageTextureAccess = ["write-only", "read-only", "read-write"];
|
|
4278
|
+
|
|
4279
|
+
|
|
4280
|
+
const __wbindgen_enum_GpuStoreOp = ["store", "discard"];
|
|
4281
|
+
|
|
4282
|
+
|
|
4283
|
+
const __wbindgen_enum_GpuTextureAspect = ["all", "stencil-only", "depth-only"];
|
|
4284
|
+
|
|
4285
|
+
|
|
4286
|
+
const __wbindgen_enum_GpuTextureDimension = ["1d", "2d", "3d"];
|
|
4287
|
+
|
|
4288
|
+
|
|
4289
|
+
const __wbindgen_enum_GpuTextureFormat = ["r8unorm", "r8snorm", "r8uint", "r8sint", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32uint", "r32sint", "r32float", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb9e5ufloat", "rgb10a2uint", "rgb10a2unorm", "rg11b10ufloat", "rg32uint", "rg32sint", "rg32float", "rgba16uint", "rgba16sint", "rgba16float", "rgba32uint", "rgba32sint", "rgba32float", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth32float", "depth32float-stencil8", "bc1-rgba-unorm", "bc1-rgba-unorm-srgb", "bc2-rgba-unorm", "bc2-rgba-unorm-srgb", "bc3-rgba-unorm", "bc3-rgba-unorm-srgb", "bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm", "bc6h-rgb-ufloat", "bc6h-rgb-float", "bc7-rgba-unorm", "bc7-rgba-unorm-srgb", "etc2-rgb8unorm", "etc2-rgb8unorm-srgb", "etc2-rgb8a1unorm", "etc2-rgb8a1unorm-srgb", "etc2-rgba8unorm", "etc2-rgba8unorm-srgb", "eac-r11unorm", "eac-r11snorm", "eac-rg11unorm", "eac-rg11snorm", "astc-4x4-unorm", "astc-4x4-unorm-srgb", "astc-5x4-unorm", "astc-5x4-unorm-srgb", "astc-5x5-unorm", "astc-5x5-unorm-srgb", "astc-6x5-unorm", "astc-6x5-unorm-srgb", "astc-6x6-unorm", "astc-6x6-unorm-srgb", "astc-8x5-unorm", "astc-8x5-unorm-srgb", "astc-8x6-unorm", "astc-8x6-unorm-srgb", "astc-8x8-unorm", "astc-8x8-unorm-srgb", "astc-10x5-unorm", "astc-10x5-unorm-srgb", "astc-10x6-unorm", "astc-10x6-unorm-srgb", "astc-10x8-unorm", "astc-10x8-unorm-srgb", "astc-10x10-unorm", "astc-10x10-unorm-srgb", "astc-12x10-unorm", "astc-12x10-unorm-srgb", "astc-12x12-unorm", "astc-12x12-unorm-srgb"];
|
|
4290
|
+
|
|
4291
|
+
|
|
4292
|
+
const __wbindgen_enum_GpuTextureSampleType = ["float", "unfilterable-float", "depth", "sint", "uint"];
|
|
4293
|
+
|
|
4294
|
+
|
|
4295
|
+
const __wbindgen_enum_GpuTextureViewDimension = ["1d", "2d", "2d-array", "cube", "cube-array", "3d"];
|
|
4296
|
+
|
|
4297
|
+
|
|
4298
|
+
const __wbindgen_enum_GpuVertexFormat = ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
|
|
4299
|
+
|
|
4300
|
+
|
|
4301
|
+
const __wbindgen_enum_GpuVertexStepMode = ["vertex", "instance"];
|
|
4302
|
+
const CredentialVaultFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
4303
|
+
? { register: () => {}, unregister: () => {} }
|
|
4304
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_credentialvault_free(ptr, 1));
|
|
641
4305
|
const KernelFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
642
4306
|
? { register: () => {}, unregister: () => {} }
|
|
643
4307
|
: new FinalizationRegistry(ptr => wasm.__wbg_kernel_free(ptr, 1));
|
|
4308
|
+
const MemoryStoreFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
4309
|
+
? { register: () => {}, unregister: () => {} }
|
|
4310
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_memorystore_free(ptr, 1));
|
|
644
4311
|
const ServerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
645
4312
|
? { register: () => {}, unregister: () => {} }
|
|
646
4313
|
: new FinalizationRegistry(ptr => wasm.__wbg_server_free(ptr, 1));
|
|
647
4314
|
|
|
4315
|
+
function addToExternrefTable0(obj) {
|
|
4316
|
+
const idx = wasm.__externref_table_alloc();
|
|
4317
|
+
wasm.__wbindgen_externrefs.set(idx, obj);
|
|
4318
|
+
return idx;
|
|
4319
|
+
}
|
|
4320
|
+
|
|
4321
|
+
const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
|
|
4322
|
+
? { register: () => {}, unregister: () => {} }
|
|
4323
|
+
: new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
|
|
4324
|
+
|
|
4325
|
+
function debugString(val) {
|
|
4326
|
+
// primitive types
|
|
4327
|
+
const type = typeof val;
|
|
4328
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
|
4329
|
+
return `${val}`;
|
|
4330
|
+
}
|
|
4331
|
+
if (type == 'string') {
|
|
4332
|
+
return `"${val}"`;
|
|
4333
|
+
}
|
|
4334
|
+
if (type == 'symbol') {
|
|
4335
|
+
const description = val.description;
|
|
4336
|
+
if (description == null) {
|
|
4337
|
+
return 'Symbol';
|
|
4338
|
+
} else {
|
|
4339
|
+
return `Symbol(${description})`;
|
|
4340
|
+
}
|
|
4341
|
+
}
|
|
4342
|
+
if (type == 'function') {
|
|
4343
|
+
const name = val.name;
|
|
4344
|
+
if (typeof name == 'string' && name.length > 0) {
|
|
4345
|
+
return `Function(${name})`;
|
|
4346
|
+
} else {
|
|
4347
|
+
return 'Function';
|
|
4348
|
+
}
|
|
4349
|
+
}
|
|
4350
|
+
// objects
|
|
4351
|
+
if (Array.isArray(val)) {
|
|
4352
|
+
const length = val.length;
|
|
4353
|
+
let debug = '[';
|
|
4354
|
+
if (length > 0) {
|
|
4355
|
+
debug += debugString(val[0]);
|
|
4356
|
+
}
|
|
4357
|
+
for(let i = 1; i < length; i++) {
|
|
4358
|
+
debug += ', ' + debugString(val[i]);
|
|
4359
|
+
}
|
|
4360
|
+
debug += ']';
|
|
4361
|
+
return debug;
|
|
4362
|
+
}
|
|
4363
|
+
// Test for built-in
|
|
4364
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
4365
|
+
let className;
|
|
4366
|
+
if (builtInMatches && builtInMatches.length > 1) {
|
|
4367
|
+
className = builtInMatches[1];
|
|
4368
|
+
} else {
|
|
4369
|
+
// Failed to match the standard '[object ClassName]'
|
|
4370
|
+
return toString.call(val);
|
|
4371
|
+
}
|
|
4372
|
+
if (className == 'Object') {
|
|
4373
|
+
// we're a user defined class or Object
|
|
4374
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
|
4375
|
+
// easier than looping through ownProperties of `val`.
|
|
4376
|
+
try {
|
|
4377
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
|
4378
|
+
} catch (_) {
|
|
4379
|
+
return 'Object';
|
|
4380
|
+
}
|
|
4381
|
+
}
|
|
4382
|
+
// errors
|
|
4383
|
+
if (val instanceof Error) {
|
|
4384
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
4385
|
+
}
|
|
4386
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
4387
|
+
return className;
|
|
4388
|
+
}
|
|
4389
|
+
|
|
4390
|
+
function getArrayU32FromWasm0(ptr, len) {
|
|
4391
|
+
ptr = ptr >>> 0;
|
|
4392
|
+
return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
4393
|
+
}
|
|
4394
|
+
|
|
4395
|
+
function getArrayU8FromWasm0(ptr, len) {
|
|
4396
|
+
ptr = ptr >>> 0;
|
|
4397
|
+
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
4398
|
+
}
|
|
4399
|
+
|
|
4400
|
+
let cachedDataViewMemory0 = null;
|
|
4401
|
+
function getDataViewMemory0() {
|
|
4402
|
+
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
4403
|
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
4404
|
+
}
|
|
4405
|
+
return cachedDataViewMemory0;
|
|
4406
|
+
}
|
|
4407
|
+
|
|
648
4408
|
function getStringFromWasm0(ptr, len) {
|
|
649
4409
|
return decodeText(ptr >>> 0, len);
|
|
650
4410
|
}
|
|
651
4411
|
|
|
4412
|
+
let cachedUint32ArrayMemory0 = null;
|
|
4413
|
+
function getUint32ArrayMemory0() {
|
|
4414
|
+
if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
|
|
4415
|
+
cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
|
|
4416
|
+
}
|
|
4417
|
+
return cachedUint32ArrayMemory0;
|
|
4418
|
+
}
|
|
4419
|
+
|
|
652
4420
|
let cachedUint8ArrayMemory0 = null;
|
|
653
4421
|
function getUint8ArrayMemory0() {
|
|
654
4422
|
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
@@ -657,10 +4425,47 @@ function getUint8ArrayMemory0() {
|
|
|
657
4425
|
return cachedUint8ArrayMemory0;
|
|
658
4426
|
}
|
|
659
4427
|
|
|
4428
|
+
function handleError(f, args) {
|
|
4429
|
+
try {
|
|
4430
|
+
return f.apply(this, args);
|
|
4431
|
+
} catch (e) {
|
|
4432
|
+
const idx = addToExternrefTable0(e);
|
|
4433
|
+
wasm.__wbindgen_exn_store(idx);
|
|
4434
|
+
}
|
|
4435
|
+
}
|
|
4436
|
+
|
|
660
4437
|
function isLikeNone(x) {
|
|
661
4438
|
return x === undefined || x === null;
|
|
662
4439
|
}
|
|
663
4440
|
|
|
4441
|
+
function makeMutClosure(arg0, arg1, f) {
|
|
4442
|
+
const state = { a: arg0, b: arg1, cnt: 1 };
|
|
4443
|
+
const real = (...args) => {
|
|
4444
|
+
|
|
4445
|
+
// First up with a closure we increment the internal reference
|
|
4446
|
+
// count. This ensures that the Rust closure environment won't
|
|
4447
|
+
// be deallocated while we're invoking it.
|
|
4448
|
+
state.cnt++;
|
|
4449
|
+
const a = state.a;
|
|
4450
|
+
state.a = 0;
|
|
4451
|
+
try {
|
|
4452
|
+
return f(a, state.b, ...args);
|
|
4453
|
+
} finally {
|
|
4454
|
+
state.a = a;
|
|
4455
|
+
real._wbg_cb_unref();
|
|
4456
|
+
}
|
|
4457
|
+
};
|
|
4458
|
+
real._wbg_cb_unref = () => {
|
|
4459
|
+
if (--state.cnt === 0) {
|
|
4460
|
+
wasm.__wbindgen_destroy_closure(state.a, state.b);
|
|
4461
|
+
state.a = 0;
|
|
4462
|
+
CLOSURE_DTORS.unregister(state);
|
|
4463
|
+
}
|
|
4464
|
+
};
|
|
4465
|
+
CLOSURE_DTORS.register(real, state, state);
|
|
4466
|
+
return real;
|
|
4467
|
+
}
|
|
4468
|
+
|
|
664
4469
|
function passStringToWasm0(arg, malloc, realloc) {
|
|
665
4470
|
if (realloc === undefined) {
|
|
666
4471
|
const buf = cachedTextEncoder.encode(arg);
|
|
@@ -738,6 +4543,8 @@ function __wbg_finalize_init(instance, module) {
|
|
|
738
4543
|
wasmInstance = instance;
|
|
739
4544
|
wasm = instance.exports;
|
|
740
4545
|
wasmModule = module;
|
|
4546
|
+
cachedDataViewMemory0 = null;
|
|
4547
|
+
cachedUint32ArrayMemory0 = null;
|
|
741
4548
|
cachedUint8ArrayMemory0 = null;
|
|
742
4549
|
wasm.__wbindgen_start();
|
|
743
4550
|
return wasm;
|