lebai_sdk 0.1.2 → 0.1.4
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/LICENSE +127 -127
- package/README.md +3 -3
- package/lebai_sdk.js +2 -1427
- package/lebai_sdk_bg.js +1418 -0
- package/lebai_sdk_bg.wasm +0 -0
- package/package.json +4 -3
package/lebai_sdk_bg.js
ADDED
@@ -0,0 +1,1418 @@
|
|
1
|
+
import * as wasm from './lebai_sdk_bg.wasm';
|
2
|
+
|
3
|
+
const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
|
4
|
+
|
5
|
+
let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
6
|
+
|
7
|
+
cachedTextDecoder.decode();
|
8
|
+
|
9
|
+
let cachedUint8Memory0 = new Uint8Array();
|
10
|
+
|
11
|
+
function getUint8Memory0() {
|
12
|
+
if (cachedUint8Memory0.byteLength === 0) {
|
13
|
+
cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
|
14
|
+
}
|
15
|
+
return cachedUint8Memory0;
|
16
|
+
}
|
17
|
+
|
18
|
+
function getStringFromWasm0(ptr, len) {
|
19
|
+
return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
|
20
|
+
}
|
21
|
+
|
22
|
+
const heap = new Array(32).fill(undefined);
|
23
|
+
|
24
|
+
heap.push(undefined, null, true, false);
|
25
|
+
|
26
|
+
let heap_next = heap.length;
|
27
|
+
|
28
|
+
function addHeapObject(obj) {
|
29
|
+
if (heap_next === heap.length) heap.push(heap.length + 1);
|
30
|
+
const idx = heap_next;
|
31
|
+
heap_next = heap[idx];
|
32
|
+
|
33
|
+
heap[idx] = obj;
|
34
|
+
return idx;
|
35
|
+
}
|
36
|
+
|
37
|
+
function getObject(idx) { return heap[idx]; }
|
38
|
+
|
39
|
+
function dropObject(idx) {
|
40
|
+
if (idx < 36) return;
|
41
|
+
heap[idx] = heap_next;
|
42
|
+
heap_next = idx;
|
43
|
+
}
|
44
|
+
|
45
|
+
function takeObject(idx) {
|
46
|
+
const ret = getObject(idx);
|
47
|
+
dropObject(idx);
|
48
|
+
return ret;
|
49
|
+
}
|
50
|
+
|
51
|
+
let WASM_VECTOR_LEN = 0;
|
52
|
+
|
53
|
+
const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
|
54
|
+
|
55
|
+
let cachedTextEncoder = new lTextEncoder('utf-8');
|
56
|
+
|
57
|
+
const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
|
58
|
+
? function (arg, view) {
|
59
|
+
return cachedTextEncoder.encodeInto(arg, view);
|
60
|
+
}
|
61
|
+
: function (arg, view) {
|
62
|
+
const buf = cachedTextEncoder.encode(arg);
|
63
|
+
view.set(buf);
|
64
|
+
return {
|
65
|
+
read: arg.length,
|
66
|
+
written: buf.length
|
67
|
+
};
|
68
|
+
});
|
69
|
+
|
70
|
+
function passStringToWasm0(arg, malloc, realloc) {
|
71
|
+
|
72
|
+
if (realloc === undefined) {
|
73
|
+
const buf = cachedTextEncoder.encode(arg);
|
74
|
+
const ptr = malloc(buf.length);
|
75
|
+
getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
|
76
|
+
WASM_VECTOR_LEN = buf.length;
|
77
|
+
return ptr;
|
78
|
+
}
|
79
|
+
|
80
|
+
let len = arg.length;
|
81
|
+
let ptr = malloc(len);
|
82
|
+
|
83
|
+
const mem = getUint8Memory0();
|
84
|
+
|
85
|
+
let offset = 0;
|
86
|
+
|
87
|
+
for (; offset < len; offset++) {
|
88
|
+
const code = arg.charCodeAt(offset);
|
89
|
+
if (code > 0x7F) break;
|
90
|
+
mem[ptr + offset] = code;
|
91
|
+
}
|
92
|
+
|
93
|
+
if (offset !== len) {
|
94
|
+
if (offset !== 0) {
|
95
|
+
arg = arg.slice(offset);
|
96
|
+
}
|
97
|
+
ptr = realloc(ptr, len, len = offset + arg.length * 3);
|
98
|
+
const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
|
99
|
+
const ret = encodeString(arg, view);
|
100
|
+
|
101
|
+
offset += ret.written;
|
102
|
+
}
|
103
|
+
|
104
|
+
WASM_VECTOR_LEN = offset;
|
105
|
+
return ptr;
|
106
|
+
}
|
107
|
+
|
108
|
+
function isLikeNone(x) {
|
109
|
+
return x === undefined || x === null;
|
110
|
+
}
|
111
|
+
|
112
|
+
let cachedInt32Memory0 = new Int32Array();
|
113
|
+
|
114
|
+
function getInt32Memory0() {
|
115
|
+
if (cachedInt32Memory0.byteLength === 0) {
|
116
|
+
cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
|
117
|
+
}
|
118
|
+
return cachedInt32Memory0;
|
119
|
+
}
|
120
|
+
|
121
|
+
let cachedFloat64Memory0 = new Float64Array();
|
122
|
+
|
123
|
+
function getFloat64Memory0() {
|
124
|
+
if (cachedFloat64Memory0.byteLength === 0) {
|
125
|
+
cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
|
126
|
+
}
|
127
|
+
return cachedFloat64Memory0;
|
128
|
+
}
|
129
|
+
|
130
|
+
let cachedBigInt64Memory0 = new BigInt64Array();
|
131
|
+
|
132
|
+
function getBigInt64Memory0() {
|
133
|
+
if (cachedBigInt64Memory0.byteLength === 0) {
|
134
|
+
cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
|
135
|
+
}
|
136
|
+
return cachedBigInt64Memory0;
|
137
|
+
}
|
138
|
+
|
139
|
+
function debugString(val) {
|
140
|
+
// primitive types
|
141
|
+
const type = typeof val;
|
142
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
143
|
+
return `${val}`;
|
144
|
+
}
|
145
|
+
if (type == 'string') {
|
146
|
+
return `"${val}"`;
|
147
|
+
}
|
148
|
+
if (type == 'symbol') {
|
149
|
+
const description = val.description;
|
150
|
+
if (description == null) {
|
151
|
+
return 'Symbol';
|
152
|
+
} else {
|
153
|
+
return `Symbol(${description})`;
|
154
|
+
}
|
155
|
+
}
|
156
|
+
if (type == 'function') {
|
157
|
+
const name = val.name;
|
158
|
+
if (typeof name == 'string' && name.length > 0) {
|
159
|
+
return `Function(${name})`;
|
160
|
+
} else {
|
161
|
+
return 'Function';
|
162
|
+
}
|
163
|
+
}
|
164
|
+
// objects
|
165
|
+
if (Array.isArray(val)) {
|
166
|
+
const length = val.length;
|
167
|
+
let debug = '[';
|
168
|
+
if (length > 0) {
|
169
|
+
debug += debugString(val[0]);
|
170
|
+
}
|
171
|
+
for(let i = 1; i < length; i++) {
|
172
|
+
debug += ', ' + debugString(val[i]);
|
173
|
+
}
|
174
|
+
debug += ']';
|
175
|
+
return debug;
|
176
|
+
}
|
177
|
+
// Test for built-in
|
178
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
179
|
+
let className;
|
180
|
+
if (builtInMatches.length > 1) {
|
181
|
+
className = builtInMatches[1];
|
182
|
+
} else {
|
183
|
+
// Failed to match the standard '[object ClassName]'
|
184
|
+
return toString.call(val);
|
185
|
+
}
|
186
|
+
if (className == 'Object') {
|
187
|
+
// we're a user defined class or Object
|
188
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
189
|
+
// easier than looping through ownProperties of `val`.
|
190
|
+
try {
|
191
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
192
|
+
} catch (_) {
|
193
|
+
return 'Object';
|
194
|
+
}
|
195
|
+
}
|
196
|
+
// errors
|
197
|
+
if (val instanceof Error) {
|
198
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
199
|
+
}
|
200
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
201
|
+
return className;
|
202
|
+
}
|
203
|
+
|
204
|
+
function makeMutClosure(arg0, arg1, dtor, f) {
|
205
|
+
const state = { a: arg0, b: arg1, cnt: 1, dtor };
|
206
|
+
const real = (...args) => {
|
207
|
+
// First up with a closure we increment the internal reference
|
208
|
+
// count. This ensures that the Rust closure environment won't
|
209
|
+
// be deallocated while we're invoking it.
|
210
|
+
state.cnt++;
|
211
|
+
const a = state.a;
|
212
|
+
state.a = 0;
|
213
|
+
try {
|
214
|
+
return f(a, state.b, ...args);
|
215
|
+
} finally {
|
216
|
+
if (--state.cnt === 0) {
|
217
|
+
wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
|
218
|
+
|
219
|
+
} else {
|
220
|
+
state.a = a;
|
221
|
+
}
|
222
|
+
}
|
223
|
+
};
|
224
|
+
real.original = state;
|
225
|
+
|
226
|
+
return real;
|
227
|
+
}
|
228
|
+
function __wbg_adapter_48(arg0, arg1, arg2) {
|
229
|
+
wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h39f562a67e2006da(arg0, arg1, addHeapObject(arg2));
|
230
|
+
}
|
231
|
+
|
232
|
+
function __wbg_adapter_55(arg0, arg1) {
|
233
|
+
wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb9d8d10dde2de7ff(arg0, arg1);
|
234
|
+
}
|
235
|
+
|
236
|
+
function __wbg_adapter_58(arg0, arg1, arg2) {
|
237
|
+
wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hdb5e4912e141ff12(arg0, arg1, addHeapObject(arg2));
|
238
|
+
}
|
239
|
+
|
240
|
+
function __wbg_adapter_61(arg0, arg1) {
|
241
|
+
wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hcf457e62695755fb(arg0, arg1);
|
242
|
+
}
|
243
|
+
|
244
|
+
/**
|
245
|
+
* @param {string} ip
|
246
|
+
* @param {boolean} simu
|
247
|
+
* @returns {Promise<Robot>}
|
248
|
+
*/
|
249
|
+
export function connect(ip, simu) {
|
250
|
+
const ptr0 = passStringToWasm0(ip, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
251
|
+
const len0 = WASM_VECTOR_LEN;
|
252
|
+
const ret = wasm.connect(ptr0, len0, simu);
|
253
|
+
return takeObject(ret);
|
254
|
+
}
|
255
|
+
|
256
|
+
/**
|
257
|
+
* @param {number} time
|
258
|
+
* @returns {Promise<any>}
|
259
|
+
*/
|
260
|
+
export function discover_devices(time) {
|
261
|
+
const ret = wasm.discover_devices(time);
|
262
|
+
return takeObject(ret);
|
263
|
+
}
|
264
|
+
|
265
|
+
/**
|
266
|
+
* @returns {string}
|
267
|
+
*/
|
268
|
+
export function version() {
|
269
|
+
try {
|
270
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
271
|
+
wasm.version(retptr);
|
272
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
273
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
274
|
+
var r2 = getInt32Memory0()[retptr / 4 + 2];
|
275
|
+
var r3 = getInt32Memory0()[retptr / 4 + 3];
|
276
|
+
var ptr0 = r0;
|
277
|
+
var len0 = r1;
|
278
|
+
if (r3) {
|
279
|
+
ptr0 = 0; len0 = 0;
|
280
|
+
throw takeObject(r2);
|
281
|
+
}
|
282
|
+
return getStringFromWasm0(ptr0, len0);
|
283
|
+
} finally {
|
284
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
285
|
+
wasm.__wbindgen_free(ptr0, len0);
|
286
|
+
}
|
287
|
+
}
|
288
|
+
|
289
|
+
function handleError(f, args) {
|
290
|
+
try {
|
291
|
+
return f.apply(this, args);
|
292
|
+
} catch (e) {
|
293
|
+
wasm.__wbindgen_exn_store(addHeapObject(e));
|
294
|
+
}
|
295
|
+
}
|
296
|
+
|
297
|
+
function getArrayU8FromWasm0(ptr, len) {
|
298
|
+
return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
|
299
|
+
}
|
300
|
+
|
301
|
+
function notDefined(what) { return () => { throw new Error(`${what} is not defined`); }; }
|
302
|
+
function __wbg_adapter_211(arg0, arg1, arg2, arg3) {
|
303
|
+
wasm.wasm_bindgen__convert__closures__invoke2_mut__h3122b00026f2b9b6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
|
304
|
+
}
|
305
|
+
|
306
|
+
/**
|
307
|
+
*/
|
308
|
+
export class Robot {
|
309
|
+
|
310
|
+
static __wrap(ptr) {
|
311
|
+
const obj = Object.create(Robot.prototype);
|
312
|
+
obj.ptr = ptr;
|
313
|
+
|
314
|
+
return obj;
|
315
|
+
}
|
316
|
+
|
317
|
+
__destroy_into_raw() {
|
318
|
+
const ptr = this.ptr;
|
319
|
+
this.ptr = 0;
|
320
|
+
|
321
|
+
return ptr;
|
322
|
+
}
|
323
|
+
|
324
|
+
free() {
|
325
|
+
const ptr = this.__destroy_into_raw();
|
326
|
+
wasm.__wbg_robot_free(ptr);
|
327
|
+
}
|
328
|
+
/**
|
329
|
+
* @param {string} method
|
330
|
+
* @param {string | undefined} param
|
331
|
+
* @returns {Promise<string>}
|
332
|
+
*/
|
333
|
+
call(method, param) {
|
334
|
+
const ptr0 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
335
|
+
const len0 = WASM_VECTOR_LEN;
|
336
|
+
var ptr1 = isLikeNone(param) ? 0 : passStringToWasm0(param, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
337
|
+
var len1 = WASM_VECTOR_LEN;
|
338
|
+
const ret = wasm.robot_call(this.ptr, ptr0, len0, ptr1, len1);
|
339
|
+
return takeObject(ret);
|
340
|
+
}
|
341
|
+
/**
|
342
|
+
* @param {string} method
|
343
|
+
* @param {string | undefined} param
|
344
|
+
* @returns {Promise<RobotSubscription>}
|
345
|
+
*/
|
346
|
+
subscribe(method, param) {
|
347
|
+
const ptr0 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
348
|
+
const len0 = WASM_VECTOR_LEN;
|
349
|
+
var ptr1 = isLikeNone(param) ? 0 : passStringToWasm0(param, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
350
|
+
var len1 = WASM_VECTOR_LEN;
|
351
|
+
const ret = wasm.robot_subscribe(this.ptr, ptr0, len0, ptr1, len1);
|
352
|
+
return takeObject(ret);
|
353
|
+
}
|
354
|
+
/**
|
355
|
+
* @param {any} p
|
356
|
+
* @returns {Promise<any>}
|
357
|
+
*/
|
358
|
+
kinematics_forward(p) {
|
359
|
+
const ret = wasm.robot_kinematics_forward(this.ptr, addHeapObject(p));
|
360
|
+
return takeObject(ret);
|
361
|
+
}
|
362
|
+
/**
|
363
|
+
* @param {any} p
|
364
|
+
* @param {any | undefined} refer
|
365
|
+
* @returns {Promise<any>}
|
366
|
+
*/
|
367
|
+
kinematics_inverse(p, refer) {
|
368
|
+
const ret = wasm.robot_kinematics_inverse(this.ptr, addHeapObject(p), isLikeNone(refer) ? 0 : addHeapObject(refer));
|
369
|
+
return takeObject(ret);
|
370
|
+
}
|
371
|
+
/**
|
372
|
+
* @param {any} from
|
373
|
+
* @param {any} to
|
374
|
+
* @returns {Promise<any>}
|
375
|
+
*/
|
376
|
+
pose_trans(from, to) {
|
377
|
+
const ret = wasm.robot_pose_trans(this.ptr, addHeapObject(from), addHeapObject(to));
|
378
|
+
return takeObject(ret);
|
379
|
+
}
|
380
|
+
/**
|
381
|
+
* @param {any} p
|
382
|
+
* @returns {Promise<any>}
|
383
|
+
*/
|
384
|
+
pose_inverse(p) {
|
385
|
+
const ret = wasm.robot_pose_inverse(this.ptr, addHeapObject(p));
|
386
|
+
return takeObject(ret);
|
387
|
+
}
|
388
|
+
/**
|
389
|
+
* @param {string} name
|
390
|
+
* @param {string | undefined} dir
|
391
|
+
* @returns {Promise<any>}
|
392
|
+
*/
|
393
|
+
load_pose(name, dir) {
|
394
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
395
|
+
const len0 = WASM_VECTOR_LEN;
|
396
|
+
var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
397
|
+
var len1 = WASM_VECTOR_LEN;
|
398
|
+
const ret = wasm.robot_load_pose(this.ptr, ptr0, len0, ptr1, len1);
|
399
|
+
return takeObject(ret);
|
400
|
+
}
|
401
|
+
/**
|
402
|
+
* @param {string} name
|
403
|
+
* @param {string | undefined} dir
|
404
|
+
* @returns {Promise<any>}
|
405
|
+
*/
|
406
|
+
load_frame(name, dir) {
|
407
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
408
|
+
const len0 = WASM_VECTOR_LEN;
|
409
|
+
var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
410
|
+
var len1 = WASM_VECTOR_LEN;
|
411
|
+
const ret = wasm.robot_load_frame(this.ptr, ptr0, len0, ptr1, len1);
|
412
|
+
return takeObject(ret);
|
413
|
+
}
|
414
|
+
/**
|
415
|
+
* @returns {Promise<void>}
|
416
|
+
*/
|
417
|
+
stop_move() {
|
418
|
+
const ret = wasm.robot_stop_move(this.ptr);
|
419
|
+
return takeObject(ret);
|
420
|
+
}
|
421
|
+
/**
|
422
|
+
* @param {number | undefined} id
|
423
|
+
* @returns {Promise<void>}
|
424
|
+
*/
|
425
|
+
wait_move(id) {
|
426
|
+
const ret = wasm.robot_wait_move(this.ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
|
427
|
+
return takeObject(ret);
|
428
|
+
}
|
429
|
+
/**
|
430
|
+
* @returns {Promise<number>}
|
431
|
+
*/
|
432
|
+
get_running_motion() {
|
433
|
+
const ret = wasm.robot_get_running_motion(this.ptr);
|
434
|
+
return takeObject(ret);
|
435
|
+
}
|
436
|
+
/**
|
437
|
+
* @param {number} id
|
438
|
+
* @returns {Promise<string>}
|
439
|
+
*/
|
440
|
+
get_motion_state(id) {
|
441
|
+
const ret = wasm.robot_get_motion_state(this.ptr, id);
|
442
|
+
return takeObject(ret);
|
443
|
+
}
|
444
|
+
/**
|
445
|
+
* @param {any} p
|
446
|
+
* @param {number} a
|
447
|
+
* @param {number} v
|
448
|
+
* @param {number} t
|
449
|
+
* @param {number | undefined} r
|
450
|
+
* @returns {Promise<number>}
|
451
|
+
*/
|
452
|
+
towardj(p, a, v, t, r) {
|
453
|
+
const ret = wasm.robot_towardj(this.ptr, addHeapObject(p), a, v, t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
|
454
|
+
return takeObject(ret);
|
455
|
+
}
|
456
|
+
/**
|
457
|
+
* @param {any} p
|
458
|
+
* @param {number} a
|
459
|
+
* @param {number} v
|
460
|
+
* @param {number} t
|
461
|
+
* @param {number | undefined} r
|
462
|
+
* @returns {Promise<number>}
|
463
|
+
*/
|
464
|
+
movej(p, a, v, t, r) {
|
465
|
+
const ret = wasm.robot_movej(this.ptr, addHeapObject(p), a, v, t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
|
466
|
+
return takeObject(ret);
|
467
|
+
}
|
468
|
+
/**
|
469
|
+
* @param {any} p
|
470
|
+
* @param {number} a
|
471
|
+
* @param {number} v
|
472
|
+
* @param {number} t
|
473
|
+
* @param {number | undefined} r
|
474
|
+
* @returns {Promise<number>}
|
475
|
+
*/
|
476
|
+
movel(p, a, v, t, r) {
|
477
|
+
const ret = wasm.robot_movel(this.ptr, addHeapObject(p), a, v, t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
|
478
|
+
return takeObject(ret);
|
479
|
+
}
|
480
|
+
/**
|
481
|
+
* @param {any} via
|
482
|
+
* @param {any} p
|
483
|
+
* @param {number} rad
|
484
|
+
* @param {number} a
|
485
|
+
* @param {number} v
|
486
|
+
* @param {number} t
|
487
|
+
* @param {number | undefined} r
|
488
|
+
* @returns {Promise<number>}
|
489
|
+
*/
|
490
|
+
movec(via, p, rad, a, v, t, r) {
|
491
|
+
const ret = wasm.robot_movec(this.ptr, addHeapObject(via), addHeapObject(p), rad, a, v, t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
|
492
|
+
return takeObject(ret);
|
493
|
+
}
|
494
|
+
/**
|
495
|
+
* @param {any} p
|
496
|
+
* @param {number} v
|
497
|
+
* @param {number} t
|
498
|
+
* @returns {Promise<void>}
|
499
|
+
*/
|
500
|
+
move_pvt(p, v, t) {
|
501
|
+
const ret = wasm.robot_move_pvt(this.ptr, addHeapObject(p), v, t);
|
502
|
+
return takeObject(ret);
|
503
|
+
}
|
504
|
+
/**
|
505
|
+
* @param {any} p
|
506
|
+
* @param {number} v
|
507
|
+
* @param {number} a
|
508
|
+
* @param {number} t
|
509
|
+
* @returns {Promise<void>}
|
510
|
+
*/
|
511
|
+
move_pvat(p, v, a, t) {
|
512
|
+
const ret = wasm.robot_move_pvat(this.ptr, addHeapObject(p), v, a, t);
|
513
|
+
return takeObject(ret);
|
514
|
+
}
|
515
|
+
/**
|
516
|
+
* @param {any} v
|
517
|
+
* @returns {Promise<void>}
|
518
|
+
*/
|
519
|
+
speedj(v) {
|
520
|
+
const ret = wasm.robot_speedj(this.ptr, addHeapObject(v));
|
521
|
+
return takeObject(ret);
|
522
|
+
}
|
523
|
+
/**
|
524
|
+
* @param {any} v
|
525
|
+
* @param {any | undefined} frame
|
526
|
+
* @returns {Promise<void>}
|
527
|
+
*/
|
528
|
+
speedl(v, frame) {
|
529
|
+
const ret = wasm.robot_speedl(this.ptr, addHeapObject(v), isLikeNone(frame) ? 0 : addHeapObject(frame));
|
530
|
+
return takeObject(ret);
|
531
|
+
}
|
532
|
+
/**
|
533
|
+
* @returns {Promise<void>}
|
534
|
+
*/
|
535
|
+
start_teach_mode() {
|
536
|
+
const ret = wasm.robot_start_teach_mode(this.ptr);
|
537
|
+
return takeObject(ret);
|
538
|
+
}
|
539
|
+
/**
|
540
|
+
* @returns {Promise<void>}
|
541
|
+
*/
|
542
|
+
end_teach_mode() {
|
543
|
+
const ret = wasm.robot_end_teach_mode(this.ptr);
|
544
|
+
return takeObject(ret);
|
545
|
+
}
|
546
|
+
/**
|
547
|
+
* @param {any} device
|
548
|
+
* @param {number} pin
|
549
|
+
* @param {number} value
|
550
|
+
* @returns {Promise<void>}
|
551
|
+
*/
|
552
|
+
set_do(device, pin, value) {
|
553
|
+
const ret = wasm.robot_set_do(this.ptr, addHeapObject(device), pin, value);
|
554
|
+
return takeObject(ret);
|
555
|
+
}
|
556
|
+
/**
|
557
|
+
* @param {any} device
|
558
|
+
* @param {number} pin
|
559
|
+
* @returns {Promise<number>}
|
560
|
+
*/
|
561
|
+
get_do(device, pin) {
|
562
|
+
const ret = wasm.robot_get_do(this.ptr, addHeapObject(device), pin);
|
563
|
+
return takeObject(ret);
|
564
|
+
}
|
565
|
+
/**
|
566
|
+
* @param {any} device
|
567
|
+
* @param {number} pin
|
568
|
+
* @param {number} num
|
569
|
+
* @returns {Promise<any>}
|
570
|
+
*/
|
571
|
+
get_dos(device, pin, num) {
|
572
|
+
const ret = wasm.robot_get_dos(this.ptr, addHeapObject(device), pin, num);
|
573
|
+
return takeObject(ret);
|
574
|
+
}
|
575
|
+
/**
|
576
|
+
* @param {any} device
|
577
|
+
* @param {number} pin
|
578
|
+
* @returns {Promise<number>}
|
579
|
+
*/
|
580
|
+
get_di(device, pin) {
|
581
|
+
const ret = wasm.robot_get_di(this.ptr, addHeapObject(device), pin);
|
582
|
+
return takeObject(ret);
|
583
|
+
}
|
584
|
+
/**
|
585
|
+
* @param {any} device
|
586
|
+
* @param {number} pin
|
587
|
+
* @param {number} num
|
588
|
+
* @returns {Promise<any>}
|
589
|
+
*/
|
590
|
+
get_dis(device, pin, num) {
|
591
|
+
const ret = wasm.robot_get_dis(this.ptr, addHeapObject(device), pin, num);
|
592
|
+
return takeObject(ret);
|
593
|
+
}
|
594
|
+
/**
|
595
|
+
* @param {any} device
|
596
|
+
* @param {number} pin
|
597
|
+
* @param {number} value
|
598
|
+
* @returns {Promise<void>}
|
599
|
+
*/
|
600
|
+
set_ao(device, pin, value) {
|
601
|
+
const ret = wasm.robot_set_ao(this.ptr, addHeapObject(device), pin, value);
|
602
|
+
return takeObject(ret);
|
603
|
+
}
|
604
|
+
/**
|
605
|
+
* @param {any} device
|
606
|
+
* @param {number} pin
|
607
|
+
* @returns {Promise<number>}
|
608
|
+
*/
|
609
|
+
get_ao(device, pin) {
|
610
|
+
const ret = wasm.robot_get_ao(this.ptr, addHeapObject(device), pin);
|
611
|
+
return takeObject(ret);
|
612
|
+
}
|
613
|
+
/**
|
614
|
+
* @param {any} device
|
615
|
+
* @param {number} pin
|
616
|
+
* @param {number} num
|
617
|
+
* @returns {Promise<any>}
|
618
|
+
*/
|
619
|
+
get_aos(device, pin, num) {
|
620
|
+
const ret = wasm.robot_get_aos(this.ptr, addHeapObject(device), pin, num);
|
621
|
+
return takeObject(ret);
|
622
|
+
}
|
623
|
+
/**
|
624
|
+
* @param {any} device
|
625
|
+
* @param {number} pin
|
626
|
+
* @returns {Promise<number>}
|
627
|
+
*/
|
628
|
+
get_ai(device, pin) {
|
629
|
+
const ret = wasm.robot_get_ai(this.ptr, addHeapObject(device), pin);
|
630
|
+
return takeObject(ret);
|
631
|
+
}
|
632
|
+
/**
|
633
|
+
* @param {any} device
|
634
|
+
* @param {number} pin
|
635
|
+
* @param {number} num
|
636
|
+
* @returns {Promise<any>}
|
637
|
+
*/
|
638
|
+
get_ais(device, pin, num) {
|
639
|
+
const ret = wasm.robot_get_ais(this.ptr, addHeapObject(device), pin, num);
|
640
|
+
return takeObject(ret);
|
641
|
+
}
|
642
|
+
/**
|
643
|
+
* @param {number} index
|
644
|
+
* @param {number} value
|
645
|
+
* @returns {Promise<void>}
|
646
|
+
*/
|
647
|
+
set_signal(index, value) {
|
648
|
+
const ret = wasm.robot_set_signal(this.ptr, index, value);
|
649
|
+
return takeObject(ret);
|
650
|
+
}
|
651
|
+
/**
|
652
|
+
* @param {number} index
|
653
|
+
* @returns {Promise<number>}
|
654
|
+
*/
|
655
|
+
get_signal(index) {
|
656
|
+
const ret = wasm.robot_get_signal(this.ptr, index);
|
657
|
+
return takeObject(ret);
|
658
|
+
}
|
659
|
+
/**
|
660
|
+
* @param {number} index
|
661
|
+
* @param {number} value
|
662
|
+
* @returns {Promise<void>}
|
663
|
+
*/
|
664
|
+
add_signal(index, value) {
|
665
|
+
const ret = wasm.robot_add_signal(this.ptr, index, value);
|
666
|
+
return takeObject(ret);
|
667
|
+
}
|
668
|
+
/**
|
669
|
+
* @param {string} scene
|
670
|
+
* @param {any | undefined} params
|
671
|
+
* @param {string | undefined} dir
|
672
|
+
* @param {boolean | undefined} is_parallel
|
673
|
+
* @param {number | undefined} loop_to
|
674
|
+
* @returns {Promise<number>}
|
675
|
+
*/
|
676
|
+
start_task(scene, params, dir, is_parallel, loop_to) {
|
677
|
+
const ptr0 = passStringToWasm0(scene, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
678
|
+
const len0 = WASM_VECTOR_LEN;
|
679
|
+
var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
680
|
+
var len1 = WASM_VECTOR_LEN;
|
681
|
+
const ret = wasm.robot_start_task(this.ptr, ptr0, len0, isLikeNone(params) ? 0 : addHeapObject(params), ptr1, len1, isLikeNone(is_parallel) ? 0xFFFFFF : is_parallel ? 1 : 0, !isLikeNone(loop_to), isLikeNone(loop_to) ? 0 : loop_to);
|
682
|
+
return takeObject(ret);
|
683
|
+
}
|
684
|
+
/**
|
685
|
+
* @param {number | undefined} id
|
686
|
+
* @returns {Promise<string>}
|
687
|
+
*/
|
688
|
+
get_task_state(id) {
|
689
|
+
const ret = wasm.robot_get_task_state(this.ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
|
690
|
+
return takeObject(ret);
|
691
|
+
}
|
692
|
+
/**
|
693
|
+
* @param {string} device
|
694
|
+
* @param {string} pin
|
695
|
+
* @param {boolean} value
|
696
|
+
* @returns {Promise<void>}
|
697
|
+
*/
|
698
|
+
write_single_coil(device, pin, value) {
|
699
|
+
const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
700
|
+
const len0 = WASM_VECTOR_LEN;
|
701
|
+
const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
702
|
+
const len1 = WASM_VECTOR_LEN;
|
703
|
+
const ret = wasm.robot_write_single_coil(this.ptr, ptr0, len0, ptr1, len1, value);
|
704
|
+
return takeObject(ret);
|
705
|
+
}
|
706
|
+
/**
|
707
|
+
* @param {string} device
|
708
|
+
* @param {string} pin
|
709
|
+
* @param {any} values
|
710
|
+
* @returns {Promise<void>}
|
711
|
+
*/
|
712
|
+
write_multiple_coils(device, pin, values) {
|
713
|
+
const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
714
|
+
const len0 = WASM_VECTOR_LEN;
|
715
|
+
const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
716
|
+
const len1 = WASM_VECTOR_LEN;
|
717
|
+
const ret = wasm.robot_write_multiple_coils(this.ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
|
718
|
+
return takeObject(ret);
|
719
|
+
}
|
720
|
+
/**
|
721
|
+
* @param {string} device
|
722
|
+
* @param {string} pin
|
723
|
+
* @param {number} count
|
724
|
+
* @returns {Promise<any>}
|
725
|
+
*/
|
726
|
+
read_coils(device, pin, count) {
|
727
|
+
const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
728
|
+
const len0 = WASM_VECTOR_LEN;
|
729
|
+
const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
730
|
+
const len1 = WASM_VECTOR_LEN;
|
731
|
+
const ret = wasm.robot_read_coils(this.ptr, ptr0, len0, ptr1, len1, count);
|
732
|
+
return takeObject(ret);
|
733
|
+
}
|
734
|
+
/**
|
735
|
+
* @param {string} device
|
736
|
+
* @param {string} pin
|
737
|
+
* @param {number} count
|
738
|
+
* @returns {Promise<any>}
|
739
|
+
*/
|
740
|
+
read_discrete_inputs(device, pin, count) {
|
741
|
+
const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
742
|
+
const len0 = WASM_VECTOR_LEN;
|
743
|
+
const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
744
|
+
const len1 = WASM_VECTOR_LEN;
|
745
|
+
const ret = wasm.robot_read_discrete_inputs(this.ptr, ptr0, len0, ptr1, len1, count);
|
746
|
+
return takeObject(ret);
|
747
|
+
}
|
748
|
+
/**
|
749
|
+
* @param {string} device
|
750
|
+
* @param {string} pin
|
751
|
+
* @param {number} value
|
752
|
+
* @returns {Promise<void>}
|
753
|
+
*/
|
754
|
+
write_single_register(device, pin, value) {
|
755
|
+
const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
756
|
+
const len0 = WASM_VECTOR_LEN;
|
757
|
+
const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
758
|
+
const len1 = WASM_VECTOR_LEN;
|
759
|
+
const ret = wasm.robot_write_single_register(this.ptr, ptr0, len0, ptr1, len1, value);
|
760
|
+
return takeObject(ret);
|
761
|
+
}
|
762
|
+
/**
|
763
|
+
* @param {string} device
|
764
|
+
* @param {string} pin
|
765
|
+
* @param {any} values
|
766
|
+
* @returns {Promise<void>}
|
767
|
+
*/
|
768
|
+
write_multiple_registers(device, pin, values) {
|
769
|
+
const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
770
|
+
const len0 = WASM_VECTOR_LEN;
|
771
|
+
const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
772
|
+
const len1 = WASM_VECTOR_LEN;
|
773
|
+
const ret = wasm.robot_write_multiple_registers(this.ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
|
774
|
+
return takeObject(ret);
|
775
|
+
}
|
776
|
+
/**
|
777
|
+
* @param {string} device
|
778
|
+
* @param {string} pin
|
779
|
+
* @param {number} count
|
780
|
+
* @returns {Promise<any>}
|
781
|
+
*/
|
782
|
+
read_holding_registers(device, pin, count) {
|
783
|
+
const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
784
|
+
const len0 = WASM_VECTOR_LEN;
|
785
|
+
const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
786
|
+
const len1 = WASM_VECTOR_LEN;
|
787
|
+
const ret = wasm.robot_read_holding_registers(this.ptr, ptr0, len0, ptr1, len1, count);
|
788
|
+
return takeObject(ret);
|
789
|
+
}
|
790
|
+
/**
|
791
|
+
* @param {string} device
|
792
|
+
* @param {string} pin
|
793
|
+
* @param {number} count
|
794
|
+
* @returns {Promise<any>}
|
795
|
+
*/
|
796
|
+
read_input_registers(device, pin, count) {
|
797
|
+
const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
798
|
+
const len0 = WASM_VECTOR_LEN;
|
799
|
+
const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
800
|
+
const len1 = WASM_VECTOR_LEN;
|
801
|
+
const ret = wasm.robot_read_input_registers(this.ptr, ptr0, len0, ptr1, len1, count);
|
802
|
+
return takeObject(ret);
|
803
|
+
}
|
804
|
+
/**
|
805
|
+
* @param {number | undefined} force
|
806
|
+
* @param {number | undefined} amplitude
|
807
|
+
* @returns {Promise<void>}
|
808
|
+
*/
|
809
|
+
set_claw(force, amplitude) {
|
810
|
+
const ret = wasm.robot_set_claw(this.ptr, !isLikeNone(force), isLikeNone(force) ? 0 : force, !isLikeNone(amplitude), isLikeNone(amplitude) ? 0 : amplitude);
|
811
|
+
return takeObject(ret);
|
812
|
+
}
|
813
|
+
/**
|
814
|
+
* @returns {Promise<any>}
|
815
|
+
*/
|
816
|
+
get_claw() {
|
817
|
+
const ret = wasm.robot_get_claw(this.ptr);
|
818
|
+
return takeObject(ret);
|
819
|
+
}
|
820
|
+
/**
|
821
|
+
* @returns {Promise<void>}
|
822
|
+
*/
|
823
|
+
start_sys() {
|
824
|
+
const ret = wasm.robot_start_sys(this.ptr);
|
825
|
+
return takeObject(ret);
|
826
|
+
}
|
827
|
+
/**
|
828
|
+
* @returns {Promise<void>}
|
829
|
+
*/
|
830
|
+
stop_sys() {
|
831
|
+
const ret = wasm.robot_stop_sys(this.ptr);
|
832
|
+
return takeObject(ret);
|
833
|
+
}
|
834
|
+
/**
|
835
|
+
* @returns {Promise<void>}
|
836
|
+
*/
|
837
|
+
powerdown() {
|
838
|
+
const ret = wasm.robot_powerdown(this.ptr);
|
839
|
+
return takeObject(ret);
|
840
|
+
}
|
841
|
+
/**
|
842
|
+
* @returns {Promise<void>}
|
843
|
+
*/
|
844
|
+
reboot() {
|
845
|
+
const ret = wasm.robot_reboot(this.ptr);
|
846
|
+
return takeObject(ret);
|
847
|
+
}
|
848
|
+
/**
|
849
|
+
* @returns {Promise<void>}
|
850
|
+
*/
|
851
|
+
stop() {
|
852
|
+
const ret = wasm.robot_stop(this.ptr);
|
853
|
+
return takeObject(ret);
|
854
|
+
}
|
855
|
+
/**
|
856
|
+
* @returns {Promise<void>}
|
857
|
+
*/
|
858
|
+
estop() {
|
859
|
+
const ret = wasm.robot_estop(this.ptr);
|
860
|
+
return takeObject(ret);
|
861
|
+
}
|
862
|
+
/**
|
863
|
+
* @param {string} name
|
864
|
+
* @param {string | undefined} dir
|
865
|
+
* @returns {Promise<any>}
|
866
|
+
*/
|
867
|
+
load_tcp(name, dir) {
|
868
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
869
|
+
const len0 = WASM_VECTOR_LEN;
|
870
|
+
var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
871
|
+
var len1 = WASM_VECTOR_LEN;
|
872
|
+
const ret = wasm.robot_load_tcp(this.ptr, ptr0, len0, ptr1, len1);
|
873
|
+
return takeObject(ret);
|
874
|
+
}
|
875
|
+
/**
|
876
|
+
* @param {any} pose
|
877
|
+
* @returns {Promise<void>}
|
878
|
+
*/
|
879
|
+
set_tcp(pose) {
|
880
|
+
const ret = wasm.robot_set_tcp(this.ptr, addHeapObject(pose));
|
881
|
+
return takeObject(ret);
|
882
|
+
}
|
883
|
+
/**
|
884
|
+
* @returns {Promise<any>}
|
885
|
+
*/
|
886
|
+
get_tcp() {
|
887
|
+
const ret = wasm.robot_get_tcp(this.ptr);
|
888
|
+
return takeObject(ret);
|
889
|
+
}
|
890
|
+
/**
|
891
|
+
* @param {number} speed_factor
|
892
|
+
* @returns {Promise<void>}
|
893
|
+
*/
|
894
|
+
set_velocity_factor(speed_factor) {
|
895
|
+
const ret = wasm.robot_set_velocity_factor(this.ptr, speed_factor);
|
896
|
+
return takeObject(ret);
|
897
|
+
}
|
898
|
+
/**
|
899
|
+
* @returns {Promise<number>}
|
900
|
+
*/
|
901
|
+
get_velocity_factor() {
|
902
|
+
const ret = wasm.robot_get_velocity_factor(this.ptr);
|
903
|
+
return takeObject(ret);
|
904
|
+
}
|
905
|
+
/**
|
906
|
+
* @param {string} name
|
907
|
+
* @param {string | undefined} dir
|
908
|
+
* @returns {Promise<any>}
|
909
|
+
*/
|
910
|
+
load_payload(name, dir) {
|
911
|
+
const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
912
|
+
const len0 = WASM_VECTOR_LEN;
|
913
|
+
var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
914
|
+
var len1 = WASM_VECTOR_LEN;
|
915
|
+
const ret = wasm.robot_load_payload(this.ptr, ptr0, len0, ptr1, len1);
|
916
|
+
return takeObject(ret);
|
917
|
+
}
|
918
|
+
/**
|
919
|
+
* @param {number | undefined} mass
|
920
|
+
* @param {any | undefined} cog
|
921
|
+
* @returns {Promise<void>}
|
922
|
+
*/
|
923
|
+
set_payload(mass, cog) {
|
924
|
+
const ret = wasm.robot_set_payload(this.ptr, !isLikeNone(mass), isLikeNone(mass) ? 0 : mass, isLikeNone(cog) ? 0 : addHeapObject(cog));
|
925
|
+
return takeObject(ret);
|
926
|
+
}
|
927
|
+
/**
|
928
|
+
* @returns {Promise<any>}
|
929
|
+
*/
|
930
|
+
get_payload() {
|
931
|
+
const ret = wasm.robot_get_payload(this.ptr);
|
932
|
+
return takeObject(ret);
|
933
|
+
}
|
934
|
+
/**
|
935
|
+
* @param {any} pose
|
936
|
+
* @returns {Promise<void>}
|
937
|
+
*/
|
938
|
+
set_gravity(pose) {
|
939
|
+
const ret = wasm.robot_set_gravity(this.ptr, addHeapObject(pose));
|
940
|
+
return takeObject(ret);
|
941
|
+
}
|
942
|
+
/**
|
943
|
+
* @returns {Promise<any>}
|
944
|
+
*/
|
945
|
+
get_gravity() {
|
946
|
+
const ret = wasm.robot_get_gravity(this.ptr);
|
947
|
+
return takeObject(ret);
|
948
|
+
}
|
949
|
+
}
|
950
|
+
/**
|
951
|
+
*/
|
952
|
+
export class RobotSubscription {
|
953
|
+
|
954
|
+
static __wrap(ptr) {
|
955
|
+
const obj = Object.create(RobotSubscription.prototype);
|
956
|
+
obj.ptr = ptr;
|
957
|
+
|
958
|
+
return obj;
|
959
|
+
}
|
960
|
+
|
961
|
+
__destroy_into_raw() {
|
962
|
+
const ptr = this.ptr;
|
963
|
+
this.ptr = 0;
|
964
|
+
|
965
|
+
return ptr;
|
966
|
+
}
|
967
|
+
|
968
|
+
free() {
|
969
|
+
const ptr = this.__destroy_into_raw();
|
970
|
+
wasm.__wbg_robotsubscription_free(ptr);
|
971
|
+
}
|
972
|
+
/**
|
973
|
+
* @returns {Promise<string | undefined>}
|
974
|
+
*/
|
975
|
+
next() {
|
976
|
+
const ret = wasm.robotsubscription_next(this.ptr);
|
977
|
+
return takeObject(ret);
|
978
|
+
}
|
979
|
+
}
|
980
|
+
|
981
|
+
export function __wbindgen_string_new(arg0, arg1) {
|
982
|
+
const ret = getStringFromWasm0(arg0, arg1);
|
983
|
+
return addHeapObject(ret);
|
984
|
+
};
|
985
|
+
|
986
|
+
export function __wbindgen_object_drop_ref(arg0) {
|
987
|
+
takeObject(arg0);
|
988
|
+
};
|
989
|
+
|
990
|
+
export function __wbindgen_number_new(arg0) {
|
991
|
+
const ret = arg0;
|
992
|
+
return addHeapObject(ret);
|
993
|
+
};
|
994
|
+
|
995
|
+
export function __wbg_robot_new(arg0) {
|
996
|
+
const ret = Robot.__wrap(arg0);
|
997
|
+
return addHeapObject(ret);
|
998
|
+
};
|
999
|
+
|
1000
|
+
export function __wbg_robotsubscription_new(arg0) {
|
1001
|
+
const ret = RobotSubscription.__wrap(arg0);
|
1002
|
+
return addHeapObject(ret);
|
1003
|
+
};
|
1004
|
+
|
1005
|
+
export function __wbindgen_string_get(arg0, arg1) {
|
1006
|
+
const obj = getObject(arg1);
|
1007
|
+
const ret = typeof(obj) === 'string' ? obj : undefined;
|
1008
|
+
var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
1009
|
+
var len0 = WASM_VECTOR_LEN;
|
1010
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1011
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1012
|
+
};
|
1013
|
+
|
1014
|
+
export function __wbindgen_error_new(arg0, arg1) {
|
1015
|
+
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
1016
|
+
return addHeapObject(ret);
|
1017
|
+
};
|
1018
|
+
|
1019
|
+
export function __wbindgen_cb_drop(arg0) {
|
1020
|
+
const obj = takeObject(arg0).original;
|
1021
|
+
if (obj.cnt-- == 1) {
|
1022
|
+
obj.a = 0;
|
1023
|
+
return true;
|
1024
|
+
}
|
1025
|
+
const ret = false;
|
1026
|
+
return ret;
|
1027
|
+
};
|
1028
|
+
|
1029
|
+
export function __wbindgen_number_get(arg0, arg1) {
|
1030
|
+
const obj = getObject(arg1);
|
1031
|
+
const ret = typeof(obj) === 'number' ? obj : undefined;
|
1032
|
+
getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
|
1033
|
+
getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
|
1034
|
+
};
|
1035
|
+
|
1036
|
+
export function __wbindgen_boolean_get(arg0) {
|
1037
|
+
const v = getObject(arg0);
|
1038
|
+
const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
|
1039
|
+
return ret;
|
1040
|
+
};
|
1041
|
+
|
1042
|
+
export function __wbindgen_is_bigint(arg0) {
|
1043
|
+
const ret = typeof(getObject(arg0)) === 'bigint';
|
1044
|
+
return ret;
|
1045
|
+
};
|
1046
|
+
|
1047
|
+
export function __wbindgen_bigint_from_i64(arg0) {
|
1048
|
+
const ret = arg0;
|
1049
|
+
return addHeapObject(ret);
|
1050
|
+
};
|
1051
|
+
|
1052
|
+
export function __wbindgen_jsval_eq(arg0, arg1) {
|
1053
|
+
const ret = getObject(arg0) === getObject(arg1);
|
1054
|
+
return ret;
|
1055
|
+
};
|
1056
|
+
|
1057
|
+
export function __wbindgen_is_object(arg0) {
|
1058
|
+
const val = getObject(arg0);
|
1059
|
+
const ret = typeof(val) === 'object' && val !== null;
|
1060
|
+
return ret;
|
1061
|
+
};
|
1062
|
+
|
1063
|
+
export function __wbindgen_in(arg0, arg1) {
|
1064
|
+
const ret = getObject(arg0) in getObject(arg1);
|
1065
|
+
return ret;
|
1066
|
+
};
|
1067
|
+
|
1068
|
+
export function __wbindgen_bigint_from_u64(arg0) {
|
1069
|
+
const ret = BigInt.asUintN(64, arg0);
|
1070
|
+
return addHeapObject(ret);
|
1071
|
+
};
|
1072
|
+
|
1073
|
+
export function __wbindgen_is_undefined(arg0) {
|
1074
|
+
const ret = getObject(arg0) === undefined;
|
1075
|
+
return ret;
|
1076
|
+
};
|
1077
|
+
|
1078
|
+
export function __wbindgen_is_string(arg0) {
|
1079
|
+
const ret = typeof(getObject(arg0)) === 'string';
|
1080
|
+
return ret;
|
1081
|
+
};
|
1082
|
+
|
1083
|
+
export function __wbindgen_object_clone_ref(arg0) {
|
1084
|
+
const ret = getObject(arg0);
|
1085
|
+
return addHeapObject(ret);
|
1086
|
+
};
|
1087
|
+
|
1088
|
+
export function __wbg_addEventListener_cbe4c6f619b032f3() { return handleError(function (arg0, arg1, arg2, arg3) {
|
1089
|
+
getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
|
1090
|
+
}, arguments) };
|
1091
|
+
|
1092
|
+
export function __wbg_addEventListener_1fc744729ac6dc27() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
1093
|
+
getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
|
1094
|
+
}, arguments) };
|
1095
|
+
|
1096
|
+
export function __wbg_dispatchEvent_9c61816a838ce0ce() { return handleError(function (arg0, arg1) {
|
1097
|
+
const ret = getObject(arg0).dispatchEvent(getObject(arg1));
|
1098
|
+
return ret;
|
1099
|
+
}, arguments) };
|
1100
|
+
|
1101
|
+
export function __wbg_removeEventListener_dd20475efce70084() { return handleError(function (arg0, arg1, arg2, arg3) {
|
1102
|
+
getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
|
1103
|
+
}, arguments) };
|
1104
|
+
|
1105
|
+
export function __wbg_wasClean_2af04e6cf2076497(arg0) {
|
1106
|
+
const ret = getObject(arg0).wasClean;
|
1107
|
+
return ret;
|
1108
|
+
};
|
1109
|
+
|
1110
|
+
export function __wbg_code_24e161f043adce8a(arg0) {
|
1111
|
+
const ret = getObject(arg0).code;
|
1112
|
+
return ret;
|
1113
|
+
};
|
1114
|
+
|
1115
|
+
export function __wbg_reason_40159cc3d2fc655d(arg0, arg1) {
|
1116
|
+
const ret = getObject(arg1).reason;
|
1117
|
+
const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
1118
|
+
const len0 = WASM_VECTOR_LEN;
|
1119
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1120
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1121
|
+
};
|
1122
|
+
|
1123
|
+
export function __wbg_newwitheventinitdict_36f3576f1bff6dbc() { return handleError(function (arg0, arg1, arg2) {
|
1124
|
+
const ret = new CloseEvent(getStringFromWasm0(arg0, arg1), getObject(arg2));
|
1125
|
+
return addHeapObject(ret);
|
1126
|
+
}, arguments) };
|
1127
|
+
|
1128
|
+
export function __wbg_readyState_9c0f66433e329c9e(arg0) {
|
1129
|
+
const ret = getObject(arg0).readyState;
|
1130
|
+
return ret;
|
1131
|
+
};
|
1132
|
+
|
1133
|
+
export function __wbg_setbinaryType_ee55743ddf4beb37(arg0, arg1) {
|
1134
|
+
getObject(arg0).binaryType = takeObject(arg1);
|
1135
|
+
};
|
1136
|
+
|
1137
|
+
export function __wbg_new_d29e507f6606de91() { return handleError(function (arg0, arg1) {
|
1138
|
+
const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
|
1139
|
+
return addHeapObject(ret);
|
1140
|
+
}, arguments) };
|
1141
|
+
|
1142
|
+
export function __wbg_close_45d053bea59e7746() { return handleError(function (arg0) {
|
1143
|
+
getObject(arg0).close();
|
1144
|
+
}, arguments) };
|
1145
|
+
|
1146
|
+
export function __wbg_send_80b256d87a6779e5() { return handleError(function (arg0, arg1, arg2) {
|
1147
|
+
getObject(arg0).send(getStringFromWasm0(arg1, arg2));
|
1148
|
+
}, arguments) };
|
1149
|
+
|
1150
|
+
export function __wbg_send_640853f8eb0f0385() { return handleError(function (arg0, arg1, arg2) {
|
1151
|
+
getObject(arg0).send(getArrayU8FromWasm0(arg1, arg2));
|
1152
|
+
}, arguments) };
|
1153
|
+
|
1154
|
+
export function __wbg_data_7b1f01f4e6a64fbe(arg0) {
|
1155
|
+
const ret = getObject(arg0).data;
|
1156
|
+
return addHeapObject(ret);
|
1157
|
+
};
|
1158
|
+
|
1159
|
+
export const __wbg_clearTimeout_23ee6db72c0ad922 = typeof clearTimeout == 'function' ? clearTimeout : notDefined('clearTimeout');
|
1160
|
+
|
1161
|
+
export function __wbg_setTimeout_09074a1669d0f224() { return handleError(function (arg0, arg1) {
|
1162
|
+
const ret = setTimeout(getObject(arg0), arg1);
|
1163
|
+
return ret;
|
1164
|
+
}, arguments) };
|
1165
|
+
|
1166
|
+
export function __wbindgen_jsval_loose_eq(arg0, arg1) {
|
1167
|
+
const ret = getObject(arg0) == getObject(arg1);
|
1168
|
+
return ret;
|
1169
|
+
};
|
1170
|
+
|
1171
|
+
export function __wbg_getwithrefkey_15c62c2b8546208d(arg0, arg1) {
|
1172
|
+
const ret = getObject(arg0)[getObject(arg1)];
|
1173
|
+
return addHeapObject(ret);
|
1174
|
+
};
|
1175
|
+
|
1176
|
+
export function __wbg_set_20cbc34131e76824(arg0, arg1, arg2) {
|
1177
|
+
getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
|
1178
|
+
};
|
1179
|
+
|
1180
|
+
export function __wbg_get_57245cc7d7c7619d(arg0, arg1) {
|
1181
|
+
const ret = getObject(arg0)[arg1 >>> 0];
|
1182
|
+
return addHeapObject(ret);
|
1183
|
+
};
|
1184
|
+
|
1185
|
+
export function __wbg_length_6e3bbe7c8bd4dbd8(arg0) {
|
1186
|
+
const ret = getObject(arg0).length;
|
1187
|
+
return ret;
|
1188
|
+
};
|
1189
|
+
|
1190
|
+
export function __wbg_new_1d9a920c6bfc44a8() {
|
1191
|
+
const ret = new Array();
|
1192
|
+
return addHeapObject(ret);
|
1193
|
+
};
|
1194
|
+
|
1195
|
+
export function __wbindgen_is_function(arg0) {
|
1196
|
+
const ret = typeof(getObject(arg0)) === 'function';
|
1197
|
+
return ret;
|
1198
|
+
};
|
1199
|
+
|
1200
|
+
export function __wbg_next_579e583d33566a86(arg0) {
|
1201
|
+
const ret = getObject(arg0).next;
|
1202
|
+
return addHeapObject(ret);
|
1203
|
+
};
|
1204
|
+
|
1205
|
+
export function __wbg_next_aaef7c8aa5e212ac() { return handleError(function (arg0) {
|
1206
|
+
const ret = getObject(arg0).next();
|
1207
|
+
return addHeapObject(ret);
|
1208
|
+
}, arguments) };
|
1209
|
+
|
1210
|
+
export function __wbg_done_1b73b0672e15f234(arg0) {
|
1211
|
+
const ret = getObject(arg0).done;
|
1212
|
+
return ret;
|
1213
|
+
};
|
1214
|
+
|
1215
|
+
export function __wbg_value_1ccc36bc03462d71(arg0) {
|
1216
|
+
const ret = getObject(arg0).value;
|
1217
|
+
return addHeapObject(ret);
|
1218
|
+
};
|
1219
|
+
|
1220
|
+
export function __wbg_iterator_6f9d4f28845f426c() {
|
1221
|
+
const ret = Symbol.iterator;
|
1222
|
+
return addHeapObject(ret);
|
1223
|
+
};
|
1224
|
+
|
1225
|
+
export function __wbg_get_765201544a2b6869() { return handleError(function (arg0, arg1) {
|
1226
|
+
const ret = Reflect.get(getObject(arg0), getObject(arg1));
|
1227
|
+
return addHeapObject(ret);
|
1228
|
+
}, arguments) };
|
1229
|
+
|
1230
|
+
export function __wbg_call_97ae9d8645dc388b() { return handleError(function (arg0, arg1) {
|
1231
|
+
const ret = getObject(arg0).call(getObject(arg1));
|
1232
|
+
return addHeapObject(ret);
|
1233
|
+
}, arguments) };
|
1234
|
+
|
1235
|
+
export function __wbg_new_0b9bfdd97583284e() {
|
1236
|
+
const ret = new Object();
|
1237
|
+
return addHeapObject(ret);
|
1238
|
+
};
|
1239
|
+
|
1240
|
+
export function __wbg_set_a68214f35c417fa9(arg0, arg1, arg2) {
|
1241
|
+
getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
|
1242
|
+
};
|
1243
|
+
|
1244
|
+
export function __wbg_isArray_27c46c67f498e15d(arg0) {
|
1245
|
+
const ret = Array.isArray(getObject(arg0));
|
1246
|
+
return ret;
|
1247
|
+
};
|
1248
|
+
|
1249
|
+
export function __wbg_instanceof_ArrayBuffer_e5e48f4762c5610b(arg0) {
|
1250
|
+
let result;
|
1251
|
+
try {
|
1252
|
+
result = getObject(arg0) instanceof ArrayBuffer;
|
1253
|
+
} catch {
|
1254
|
+
result = false;
|
1255
|
+
}
|
1256
|
+
const ret = result;
|
1257
|
+
return ret;
|
1258
|
+
};
|
1259
|
+
|
1260
|
+
export function __wbg_instanceof_Error_56b496a10a56de66(arg0) {
|
1261
|
+
let result;
|
1262
|
+
try {
|
1263
|
+
result = getObject(arg0) instanceof Error;
|
1264
|
+
} catch {
|
1265
|
+
result = false;
|
1266
|
+
}
|
1267
|
+
const ret = result;
|
1268
|
+
return ret;
|
1269
|
+
};
|
1270
|
+
|
1271
|
+
export function __wbg_message_fe2af63ccc8985bc(arg0) {
|
1272
|
+
const ret = getObject(arg0).message;
|
1273
|
+
return addHeapObject(ret);
|
1274
|
+
};
|
1275
|
+
|
1276
|
+
export function __wbg_name_48eda3ae6aa697ca(arg0) {
|
1277
|
+
const ret = getObject(arg0).name;
|
1278
|
+
return addHeapObject(ret);
|
1279
|
+
};
|
1280
|
+
|
1281
|
+
export function __wbg_toString_73c9b562dccf34bd(arg0) {
|
1282
|
+
const ret = getObject(arg0).toString();
|
1283
|
+
return addHeapObject(ret);
|
1284
|
+
};
|
1285
|
+
|
1286
|
+
export function __wbg_call_168da88779e35f61() { return handleError(function (arg0, arg1, arg2) {
|
1287
|
+
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
|
1288
|
+
return addHeapObject(ret);
|
1289
|
+
}, arguments) };
|
1290
|
+
|
1291
|
+
export function __wbg_isSafeInteger_dfa0593e8d7ac35a(arg0) {
|
1292
|
+
const ret = Number.isSafeInteger(getObject(arg0));
|
1293
|
+
return ret;
|
1294
|
+
};
|
1295
|
+
|
1296
|
+
export function __wbg_entries_65a76a413fc91037(arg0) {
|
1297
|
+
const ret = Object.entries(getObject(arg0));
|
1298
|
+
return addHeapObject(ret);
|
1299
|
+
};
|
1300
|
+
|
1301
|
+
export function __wbg_new_9962f939219f1820(arg0, arg1) {
|
1302
|
+
try {
|
1303
|
+
var state0 = {a: arg0, b: arg1};
|
1304
|
+
var cb0 = (arg0, arg1) => {
|
1305
|
+
const a = state0.a;
|
1306
|
+
state0.a = 0;
|
1307
|
+
try {
|
1308
|
+
return __wbg_adapter_211(a, state0.b, arg0, arg1);
|
1309
|
+
} finally {
|
1310
|
+
state0.a = a;
|
1311
|
+
}
|
1312
|
+
};
|
1313
|
+
const ret = new Promise(cb0);
|
1314
|
+
return addHeapObject(ret);
|
1315
|
+
} finally {
|
1316
|
+
state0.a = state0.b = 0;
|
1317
|
+
}
|
1318
|
+
};
|
1319
|
+
|
1320
|
+
export function __wbg_resolve_99fe17964f31ffc0(arg0) {
|
1321
|
+
const ret = Promise.resolve(getObject(arg0));
|
1322
|
+
return addHeapObject(ret);
|
1323
|
+
};
|
1324
|
+
|
1325
|
+
export function __wbg_then_11f7a54d67b4bfad(arg0, arg1) {
|
1326
|
+
const ret = getObject(arg0).then(getObject(arg1));
|
1327
|
+
return addHeapObject(ret);
|
1328
|
+
};
|
1329
|
+
|
1330
|
+
export function __wbg_buffer_3f3d764d4747d564(arg0) {
|
1331
|
+
const ret = getObject(arg0).buffer;
|
1332
|
+
return addHeapObject(ret);
|
1333
|
+
};
|
1334
|
+
|
1335
|
+
export function __wbg_new_8c3f0052272a457a(arg0) {
|
1336
|
+
const ret = new Uint8Array(getObject(arg0));
|
1337
|
+
return addHeapObject(ret);
|
1338
|
+
};
|
1339
|
+
|
1340
|
+
export function __wbg_set_83db9690f9353e79(arg0, arg1, arg2) {
|
1341
|
+
getObject(arg0).set(getObject(arg1), arg2 >>> 0);
|
1342
|
+
};
|
1343
|
+
|
1344
|
+
export function __wbg_length_9e1ae1900cb0fbd5(arg0) {
|
1345
|
+
const ret = getObject(arg0).length;
|
1346
|
+
return ret;
|
1347
|
+
};
|
1348
|
+
|
1349
|
+
export function __wbg_instanceof_Uint8Array_971eeda69eb75003(arg0) {
|
1350
|
+
let result;
|
1351
|
+
try {
|
1352
|
+
result = getObject(arg0) instanceof Uint8Array;
|
1353
|
+
} catch {
|
1354
|
+
result = false;
|
1355
|
+
}
|
1356
|
+
const ret = result;
|
1357
|
+
return ret;
|
1358
|
+
};
|
1359
|
+
|
1360
|
+
export function __wbg_set_bf3f89b92d5a34bf() { return handleError(function (arg0, arg1, arg2) {
|
1361
|
+
const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
|
1362
|
+
return ret;
|
1363
|
+
}, arguments) };
|
1364
|
+
|
1365
|
+
export function __wbindgen_bigint_get_as_i64(arg0, arg1) {
|
1366
|
+
const v = getObject(arg1);
|
1367
|
+
const ret = typeof(v) === 'bigint' ? v : undefined;
|
1368
|
+
getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0n : ret;
|
1369
|
+
getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
|
1370
|
+
};
|
1371
|
+
|
1372
|
+
export function __wbindgen_debug_string(arg0, arg1) {
|
1373
|
+
const ret = debugString(getObject(arg1));
|
1374
|
+
const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
1375
|
+
const len0 = WASM_VECTOR_LEN;
|
1376
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1377
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1378
|
+
};
|
1379
|
+
|
1380
|
+
export function __wbindgen_throw(arg0, arg1) {
|
1381
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
1382
|
+
};
|
1383
|
+
|
1384
|
+
export function __wbindgen_memory() {
|
1385
|
+
const ret = wasm.memory;
|
1386
|
+
return addHeapObject(ret);
|
1387
|
+
};
|
1388
|
+
|
1389
|
+
export function __wbindgen_closure_wrapper1400(arg0, arg1, arg2) {
|
1390
|
+
const ret = makeMutClosure(arg0, arg1, 532, __wbg_adapter_48);
|
1391
|
+
return addHeapObject(ret);
|
1392
|
+
};
|
1393
|
+
|
1394
|
+
export function __wbindgen_closure_wrapper1402(arg0, arg1, arg2) {
|
1395
|
+
const ret = makeMutClosure(arg0, arg1, 532, __wbg_adapter_48);
|
1396
|
+
return addHeapObject(ret);
|
1397
|
+
};
|
1398
|
+
|
1399
|
+
export function __wbindgen_closure_wrapper1404(arg0, arg1, arg2) {
|
1400
|
+
const ret = makeMutClosure(arg0, arg1, 532, __wbg_adapter_48);
|
1401
|
+
return addHeapObject(ret);
|
1402
|
+
};
|
1403
|
+
|
1404
|
+
export function __wbindgen_closure_wrapper1406(arg0, arg1, arg2) {
|
1405
|
+
const ret = makeMutClosure(arg0, arg1, 532, __wbg_adapter_55);
|
1406
|
+
return addHeapObject(ret);
|
1407
|
+
};
|
1408
|
+
|
1409
|
+
export function __wbindgen_closure_wrapper1872(arg0, arg1, arg2) {
|
1410
|
+
const ret = makeMutClosure(arg0, arg1, 626, __wbg_adapter_58);
|
1411
|
+
return addHeapObject(ret);
|
1412
|
+
};
|
1413
|
+
|
1414
|
+
export function __wbindgen_closure_wrapper1906(arg0, arg1, arg2) {
|
1415
|
+
const ret = makeMutClosure(arg0, arg1, 640, __wbg_adapter_61);
|
1416
|
+
return addHeapObject(ret);
|
1417
|
+
};
|
1418
|
+
|