lebai_sdk 0.1.8 → 0.1.10

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/lebai_sdk_bg.js CHANGED
@@ -24,37 +24,6 @@ function takeObject(idx) {
24
24
  return ret;
25
25
  }
26
26
 
27
- function addHeapObject(obj) {
28
- if (heap_next === heap.length) heap.push(heap.length + 1);
29
- const idx = heap_next;
30
- heap_next = heap[idx];
31
-
32
- heap[idx] = obj;
33
- return idx;
34
- }
35
-
36
- function isLikeNone(x) {
37
- return x === undefined || x === null;
38
- }
39
-
40
- let cachedFloat64Memory0 = null;
41
-
42
- function getFloat64Memory0() {
43
- if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
44
- cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
45
- }
46
- return cachedFloat64Memory0;
47
- }
48
-
49
- let cachedInt32Memory0 = null;
50
-
51
- function getInt32Memory0() {
52
- if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
53
- cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
54
- }
55
- return cachedInt32Memory0;
56
- }
57
-
58
27
  let WASM_VECTOR_LEN = 0;
59
28
 
60
29
  let cachedUint8Memory0 = null;
@@ -87,14 +56,14 @@ function passStringToWasm0(arg, malloc, realloc) {
87
56
 
88
57
  if (realloc === undefined) {
89
58
  const buf = cachedTextEncoder.encode(arg);
90
- const ptr = malloc(buf.length);
59
+ const ptr = malloc(buf.length) >>> 0;
91
60
  getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
92
61
  WASM_VECTOR_LEN = buf.length;
93
62
  return ptr;
94
63
  }
95
64
 
96
65
  let len = arg.length;
97
- let ptr = malloc(len);
66
+ let ptr = malloc(len) >>> 0;
98
67
 
99
68
  const mem = getUint8Memory0();
100
69
 
@@ -110,7 +79,7 @@ function passStringToWasm0(arg, malloc, realloc) {
110
79
  if (offset !== 0) {
111
80
  arg = arg.slice(offset);
112
81
  }
113
- ptr = realloc(ptr, len, len = offset + arg.length * 3);
82
+ ptr = realloc(ptr, len, len = offset + arg.length * 3) >>> 0;
114
83
  const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
115
84
  const ret = encodeString(arg, view);
116
85
 
@@ -121,6 +90,19 @@ function passStringToWasm0(arg, malloc, realloc) {
121
90
  return ptr;
122
91
  }
123
92
 
93
+ function isLikeNone(x) {
94
+ return x === undefined || x === null;
95
+ }
96
+
97
+ let cachedInt32Memory0 = null;
98
+
99
+ function getInt32Memory0() {
100
+ if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
101
+ cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
102
+ }
103
+ return cachedInt32Memory0;
104
+ }
105
+
124
106
  const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
125
107
 
126
108
  let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -128,9 +110,28 @@ let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true
128
110
  cachedTextDecoder.decode();
129
111
 
130
112
  function getStringFromWasm0(ptr, len) {
113
+ ptr = ptr >>> 0;
131
114
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
132
115
  }
133
116
 
117
+ function addHeapObject(obj) {
118
+ if (heap_next === heap.length) heap.push(heap.length + 1);
119
+ const idx = heap_next;
120
+ heap_next = heap[idx];
121
+
122
+ heap[idx] = obj;
123
+ return idx;
124
+ }
125
+
126
+ let cachedFloat64Memory0 = null;
127
+
128
+ function getFloat64Memory0() {
129
+ if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
130
+ cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
131
+ }
132
+ return cachedFloat64Memory0;
133
+ }
134
+
134
135
  let cachedBigInt64Memory0 = null;
135
136
 
136
137
  function getBigInt64Memory0() {
@@ -229,20 +230,20 @@ function makeMutClosure(arg0, arg1, dtor, f) {
229
230
 
230
231
  return real;
231
232
  }
232
- function __wbg_adapter_48(arg0, arg1) {
233
- wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h39f5d915b9118494(arg0, arg1);
233
+ function __wbg_adapter_48(arg0, arg1, arg2) {
234
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h320f8689b9e2fb21(arg0, arg1, addHeapObject(arg2));
234
235
  }
235
236
 
236
- function __wbg_adapter_51(arg0, arg1, arg2) {
237
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h0a70a922144212b1(arg0, arg1, addHeapObject(arg2));
237
+ function __wbg_adapter_53(arg0, arg1) {
238
+ wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h997c007119b10a6c(arg0, arg1);
238
239
  }
239
240
 
240
241
  function __wbg_adapter_58(arg0, arg1, arg2) {
241
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hbaa19d2314244e0e(arg0, arg1, addHeapObject(arg2));
242
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hfd59a92c9507ac6c(arg0, arg1, addHeapObject(arg2));
242
243
  }
243
244
 
244
245
  function __wbg_adapter_61(arg0, arg1) {
245
- wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb103ecbb8424f107(arg0, arg1);
246
+ wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hac13e1f13aca36fa(arg0, arg1);
246
247
  }
247
248
 
248
249
  let cachedUint32Memory0 = null;
@@ -255,7 +256,7 @@ function getUint32Memory0() {
255
256
  }
256
257
 
257
258
  function passArray32ToWasm0(arg, malloc) {
258
- const ptr = malloc(arg.length * 4);
259
+ const ptr = malloc(arg.length * 4) >>> 0;
259
260
  getUint32Memory0().set(arg, ptr / 4);
260
261
  WASM_VECTOR_LEN = arg.length;
261
262
  return ptr;
@@ -285,6 +286,8 @@ export function discover_devices(time) {
285
286
  * @returns {string}
286
287
  */
287
288
  export function version() {
289
+ let deferred2_0;
290
+ let deferred2_1;
288
291
  try {
289
292
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
290
293
  wasm.version(retptr);
@@ -292,16 +295,18 @@ export function version() {
292
295
  var r1 = getInt32Memory0()[retptr / 4 + 1];
293
296
  var r2 = getInt32Memory0()[retptr / 4 + 2];
294
297
  var r3 = getInt32Memory0()[retptr / 4 + 3];
295
- var ptr0 = r0;
296
- var len0 = r1;
298
+ var ptr1 = r0;
299
+ var len1 = r1;
297
300
  if (r3) {
298
- ptr0 = 0; len0 = 0;
301
+ ptr1 = 0; len1 = 0;
299
302
  throw takeObject(r2);
300
303
  }
301
- return getStringFromWasm0(ptr0, len0);
304
+ deferred2_0 = ptr1;
305
+ deferred2_1 = len1;
306
+ return getStringFromWasm0(ptr1, len1);
302
307
  } finally {
303
308
  wasm.__wbindgen_add_to_stack_pointer(16);
304
- wasm.__wbindgen_free(ptr0, len0);
309
+ wasm.__wbindgen_free(deferred2_0, deferred2_1);
305
310
  }
306
311
  }
307
312
 
@@ -314,10 +319,11 @@ function handleError(f, args) {
314
319
  }
315
320
 
316
321
  function getArrayU8FromWasm0(ptr, len) {
322
+ ptr = ptr >>> 0;
317
323
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
318
324
  }
319
- function __wbg_adapter_217(arg0, arg1, arg2, arg3) {
320
- wasm.wasm_bindgen__convert__closures__invoke2_mut__hbe1345a0d36fb2f6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
325
+ function __wbg_adapter_229(arg0, arg1, arg2, arg3) {
326
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h16f5953fde5af953(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
321
327
  }
322
328
 
323
329
  /**
@@ -325,15 +331,16 @@ function __wbg_adapter_217(arg0, arg1, arg2, arg3) {
325
331
  export class Robot {
326
332
 
327
333
  static __wrap(ptr) {
334
+ ptr = ptr >>> 0;
328
335
  const obj = Object.create(Robot.prototype);
329
- obj.ptr = ptr;
336
+ obj.__wbg_ptr = ptr;
330
337
 
331
338
  return obj;
332
339
  }
333
340
 
334
341
  __destroy_into_raw() {
335
- const ptr = this.ptr;
336
- this.ptr = 0;
342
+ const ptr = this.__wbg_ptr;
343
+ this.__wbg_ptr = 0;
337
344
 
338
345
  return ptr;
339
346
  }
@@ -352,7 +359,7 @@ export class Robot {
352
359
  const len0 = WASM_VECTOR_LEN;
353
360
  var ptr1 = isLikeNone(param) ? 0 : passStringToWasm0(param, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
354
361
  var len1 = WASM_VECTOR_LEN;
355
- const ret = wasm.robot_call(this.ptr, ptr0, len0, ptr1, len1);
362
+ const ret = wasm.robot_call(this.__wbg_ptr, ptr0, len0, ptr1, len1);
356
363
  return takeObject(ret);
357
364
  }
358
365
  /**
@@ -365,7 +372,7 @@ export class Robot {
365
372
  const len0 = WASM_VECTOR_LEN;
366
373
  var ptr1 = isLikeNone(param) ? 0 : passStringToWasm0(param, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
367
374
  var len1 = WASM_VECTOR_LEN;
368
- const ret = wasm.robot_subscribe(this.ptr, ptr0, len0, ptr1, len1);
375
+ const ret = wasm.robot_subscribe(this.__wbg_ptr, ptr0, len0, ptr1, len1);
369
376
  return takeObject(ret);
370
377
  }
371
378
  /**
@@ -373,7 +380,7 @@ export class Robot {
373
380
  * @returns {Promise<any>}
374
381
  */
375
382
  kinematics_forward(p) {
376
- const ret = wasm.robot_kinematics_forward(this.ptr, addHeapObject(p));
383
+ const ret = wasm.robot_kinematics_forward(this.__wbg_ptr, addHeapObject(p));
377
384
  return takeObject(ret);
378
385
  }
379
386
  /**
@@ -382,7 +389,7 @@ export class Robot {
382
389
  * @returns {Promise<any>}
383
390
  */
384
391
  kinematics_inverse(p, refer) {
385
- const ret = wasm.robot_kinematics_inverse(this.ptr, addHeapObject(p), isLikeNone(refer) ? 0 : addHeapObject(refer));
392
+ const ret = wasm.robot_kinematics_inverse(this.__wbg_ptr, addHeapObject(p), isLikeNone(refer) ? 0 : addHeapObject(refer));
386
393
  return takeObject(ret);
387
394
  }
388
395
  /**
@@ -391,7 +398,7 @@ export class Robot {
391
398
  * @returns {Promise<any>}
392
399
  */
393
400
  pose_trans(from, to) {
394
- const ret = wasm.robot_pose_trans(this.ptr, addHeapObject(from), addHeapObject(to));
401
+ const ret = wasm.robot_pose_trans(this.__wbg_ptr, addHeapObject(from), addHeapObject(to));
395
402
  return takeObject(ret);
396
403
  }
397
404
  /**
@@ -401,7 +408,7 @@ export class Robot {
401
408
  * @returns {Promise<any>}
402
409
  */
403
410
  pose_add(pose, frame, delta) {
404
- const ret = wasm.robot_pose_add(this.ptr, addHeapObject(pose), addHeapObject(frame), addHeapObject(delta));
411
+ const ret = wasm.robot_pose_add(this.__wbg_ptr, addHeapObject(pose), addHeapObject(frame), addHeapObject(delta));
405
412
  return takeObject(ret);
406
413
  }
407
414
  /**
@@ -409,7 +416,7 @@ export class Robot {
409
416
  * @returns {Promise<any>}
410
417
  */
411
418
  pose_inverse(p) {
412
- const ret = wasm.robot_pose_inverse(this.ptr, addHeapObject(p));
419
+ const ret = wasm.robot_pose_inverse(this.__wbg_ptr, addHeapObject(p));
413
420
  return takeObject(ret);
414
421
  }
415
422
  /**
@@ -422,7 +429,7 @@ export class Robot {
422
429
  const len0 = WASM_VECTOR_LEN;
423
430
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
424
431
  var len1 = WASM_VECTOR_LEN;
425
- const ret = wasm.robot_load_pose(this.ptr, ptr0, len0, ptr1, len1);
432
+ const ret = wasm.robot_load_pose(this.__wbg_ptr, ptr0, len0, ptr1, len1);
426
433
  return takeObject(ret);
427
434
  }
428
435
  /**
@@ -435,14 +442,14 @@ export class Robot {
435
442
  const len0 = WASM_VECTOR_LEN;
436
443
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
437
444
  var len1 = WASM_VECTOR_LEN;
438
- const ret = wasm.robot_load_frame(this.ptr, ptr0, len0, ptr1, len1);
445
+ const ret = wasm.robot_load_frame(this.__wbg_ptr, ptr0, len0, ptr1, len1);
439
446
  return takeObject(ret);
440
447
  }
441
448
  /**
442
449
  * @returns {Promise<void>}
443
450
  */
444
451
  stop_move() {
445
- const ret = wasm.robot_stop_move(this.ptr);
452
+ const ret = wasm.robot_stop_move(this.__wbg_ptr);
446
453
  return takeObject(ret);
447
454
  }
448
455
  /**
@@ -450,14 +457,14 @@ export class Robot {
450
457
  * @returns {Promise<void>}
451
458
  */
452
459
  wait_move(id) {
453
- const ret = wasm.robot_wait_move(this.ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
460
+ const ret = wasm.robot_wait_move(this.__wbg_ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
454
461
  return takeObject(ret);
455
462
  }
456
463
  /**
457
464
  * @returns {Promise<number>}
458
465
  */
459
466
  get_running_motion() {
460
- const ret = wasm.robot_get_running_motion(this.ptr);
467
+ const ret = wasm.robot_get_running_motion(this.__wbg_ptr);
461
468
  return takeObject(ret);
462
469
  }
463
470
  /**
@@ -465,43 +472,43 @@ export class Robot {
465
472
  * @returns {Promise<string>}
466
473
  */
467
474
  get_motion_state(id) {
468
- const ret = wasm.robot_get_motion_state(this.ptr, id);
475
+ const ret = wasm.robot_get_motion_state(this.__wbg_ptr, id);
469
476
  return takeObject(ret);
470
477
  }
471
478
  /**
472
479
  * @param {any} p
473
480
  * @param {number} a
474
481
  * @param {number} v
475
- * @param {number} t
482
+ * @param {number | undefined} t
476
483
  * @param {number | undefined} r
477
484
  * @returns {Promise<number>}
478
485
  */
479
486
  towardj(p, a, v, t, r) {
480
- const ret = wasm.robot_towardj(this.ptr, addHeapObject(p), a, v, t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
487
+ const ret = wasm.robot_towardj(this.__wbg_ptr, addHeapObject(p), a, v, !isLikeNone(t), isLikeNone(t) ? 0 : t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
481
488
  return takeObject(ret);
482
489
  }
483
490
  /**
484
491
  * @param {any} p
485
492
  * @param {number} a
486
493
  * @param {number} v
487
- * @param {number} t
494
+ * @param {number | undefined} t
488
495
  * @param {number | undefined} r
489
496
  * @returns {Promise<number>}
490
497
  */
491
498
  movej(p, a, v, t, r) {
492
- const ret = wasm.robot_movej(this.ptr, addHeapObject(p), a, v, t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
499
+ const ret = wasm.robot_movej(this.__wbg_ptr, addHeapObject(p), a, v, !isLikeNone(t), isLikeNone(t) ? 0 : t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
493
500
  return takeObject(ret);
494
501
  }
495
502
  /**
496
503
  * @param {any} p
497
504
  * @param {number} a
498
505
  * @param {number} v
499
- * @param {number} t
506
+ * @param {number | undefined} t
500
507
  * @param {number | undefined} r
501
508
  * @returns {Promise<number>}
502
509
  */
503
510
  movel(p, a, v, t, r) {
504
- const ret = wasm.robot_movel(this.ptr, addHeapObject(p), a, v, t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
511
+ const ret = wasm.robot_movel(this.__wbg_ptr, addHeapObject(p), a, v, !isLikeNone(t), isLikeNone(t) ? 0 : t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
505
512
  return takeObject(ret);
506
513
  }
507
514
  /**
@@ -510,12 +517,12 @@ export class Robot {
510
517
  * @param {number} rad
511
518
  * @param {number} a
512
519
  * @param {number} v
513
- * @param {number} t
520
+ * @param {number | undefined} t
514
521
  * @param {number | undefined} r
515
522
  * @returns {Promise<number>}
516
523
  */
517
524
  movec(via, p, rad, a, v, t, r) {
518
- const ret = wasm.robot_movec(this.ptr, addHeapObject(via), addHeapObject(p), rad, a, v, t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
525
+ const ret = wasm.robot_movec(this.__wbg_ptr, addHeapObject(via), addHeapObject(p), rad, a, v, !isLikeNone(t), isLikeNone(t) ? 0 : t, !isLikeNone(r), isLikeNone(r) ? 0 : r);
519
526
  return takeObject(ret);
520
527
  }
521
528
  /**
@@ -525,7 +532,7 @@ export class Robot {
525
532
  * @returns {Promise<void>}
526
533
  */
527
534
  move_pvt(p, v, t) {
528
- const ret = wasm.robot_move_pvt(this.ptr, addHeapObject(p), addHeapObject(v), t);
535
+ const ret = wasm.robot_move_pvt(this.__wbg_ptr, addHeapObject(p), addHeapObject(v), t);
529
536
  return takeObject(ret);
530
537
  }
531
538
  /**
@@ -536,38 +543,42 @@ export class Robot {
536
543
  * @returns {Promise<void>}
537
544
  */
538
545
  move_pvat(p, v, a, t) {
539
- const ret = wasm.robot_move_pvat(this.ptr, addHeapObject(p), addHeapObject(v), addHeapObject(a), t);
546
+ const ret = wasm.robot_move_pvat(this.__wbg_ptr, addHeapObject(p), addHeapObject(v), addHeapObject(a), t);
540
547
  return takeObject(ret);
541
548
  }
542
549
  /**
550
+ * @param {number} a
543
551
  * @param {any} v
544
- * @returns {Promise<void>}
552
+ * @param {number | undefined} t
553
+ * @returns {Promise<number>}
545
554
  */
546
- speedj(v) {
547
- const ret = wasm.robot_speedj(this.ptr, addHeapObject(v));
555
+ speedj(a, v, t) {
556
+ const ret = wasm.robot_speedj(this.__wbg_ptr, a, addHeapObject(v), !isLikeNone(t), isLikeNone(t) ? 0 : t);
548
557
  return takeObject(ret);
549
558
  }
550
559
  /**
560
+ * @param {number} a
551
561
  * @param {any} v
562
+ * @param {number | undefined} t
552
563
  * @param {any | undefined} frame
553
- * @returns {Promise<void>}
564
+ * @returns {Promise<number>}
554
565
  */
555
- speedl(v, frame) {
556
- const ret = wasm.robot_speedl(this.ptr, addHeapObject(v), isLikeNone(frame) ? 0 : addHeapObject(frame));
566
+ speedl(a, v, t, frame) {
567
+ const ret = wasm.robot_speedl(this.__wbg_ptr, a, addHeapObject(v), !isLikeNone(t), isLikeNone(t) ? 0 : t, isLikeNone(frame) ? 0 : addHeapObject(frame));
557
568
  return takeObject(ret);
558
569
  }
559
570
  /**
560
571
  * @returns {Promise<void>}
561
572
  */
562
573
  start_teach_mode() {
563
- const ret = wasm.robot_start_teach_mode(this.ptr);
574
+ const ret = wasm.robot_start_teach_mode(this.__wbg_ptr);
564
575
  return takeObject(ret);
565
576
  }
566
577
  /**
567
578
  * @returns {Promise<void>}
568
579
  */
569
580
  end_teach_mode() {
570
- const ret = wasm.robot_end_teach_mode(this.ptr);
581
+ const ret = wasm.robot_end_teach_mode(this.__wbg_ptr);
571
582
  return takeObject(ret);
572
583
  }
573
584
  /**
@@ -577,7 +588,7 @@ export class Robot {
577
588
  * @returns {Promise<void>}
578
589
  */
579
590
  set_do(device, pin, value) {
580
- const ret = wasm.robot_set_do(this.ptr, addHeapObject(device), pin, value);
591
+ const ret = wasm.robot_set_do(this.__wbg_ptr, addHeapObject(device), pin, value);
581
592
  return takeObject(ret);
582
593
  }
583
594
  /**
@@ -586,7 +597,7 @@ export class Robot {
586
597
  * @returns {Promise<number>}
587
598
  */
588
599
  get_do(device, pin) {
589
- const ret = wasm.robot_get_do(this.ptr, addHeapObject(device), pin);
600
+ const ret = wasm.robot_get_do(this.__wbg_ptr, addHeapObject(device), pin);
590
601
  return takeObject(ret);
591
602
  }
592
603
  /**
@@ -596,7 +607,7 @@ export class Robot {
596
607
  * @returns {Promise<any>}
597
608
  */
598
609
  get_dos(device, pin, num) {
599
- const ret = wasm.robot_get_dos(this.ptr, addHeapObject(device), pin, num);
610
+ const ret = wasm.robot_get_dos(this.__wbg_ptr, addHeapObject(device), pin, num);
600
611
  return takeObject(ret);
601
612
  }
602
613
  /**
@@ -605,7 +616,7 @@ export class Robot {
605
616
  * @returns {Promise<number>}
606
617
  */
607
618
  get_di(device, pin) {
608
- const ret = wasm.robot_get_di(this.ptr, addHeapObject(device), pin);
619
+ const ret = wasm.robot_get_di(this.__wbg_ptr, addHeapObject(device), pin);
609
620
  return takeObject(ret);
610
621
  }
611
622
  /**
@@ -615,7 +626,7 @@ export class Robot {
615
626
  * @returns {Promise<any>}
616
627
  */
617
628
  get_dis(device, pin, num) {
618
- const ret = wasm.robot_get_dis(this.ptr, addHeapObject(device), pin, num);
629
+ const ret = wasm.robot_get_dis(this.__wbg_ptr, addHeapObject(device), pin, num);
619
630
  return takeObject(ret);
620
631
  }
621
632
  /**
@@ -625,7 +636,7 @@ export class Robot {
625
636
  * @returns {Promise<void>}
626
637
  */
627
638
  set_ao(device, pin, value) {
628
- const ret = wasm.robot_set_ao(this.ptr, addHeapObject(device), pin, value);
639
+ const ret = wasm.robot_set_ao(this.__wbg_ptr, addHeapObject(device), pin, value);
629
640
  return takeObject(ret);
630
641
  }
631
642
  /**
@@ -634,7 +645,7 @@ export class Robot {
634
645
  * @returns {Promise<number>}
635
646
  */
636
647
  get_ao(device, pin) {
637
- const ret = wasm.robot_get_ao(this.ptr, addHeapObject(device), pin);
648
+ const ret = wasm.robot_get_ao(this.__wbg_ptr, addHeapObject(device), pin);
638
649
  return takeObject(ret);
639
650
  }
640
651
  /**
@@ -644,7 +655,7 @@ export class Robot {
644
655
  * @returns {Promise<any>}
645
656
  */
646
657
  get_aos(device, pin, num) {
647
- const ret = wasm.robot_get_aos(this.ptr, addHeapObject(device), pin, num);
658
+ const ret = wasm.robot_get_aos(this.__wbg_ptr, addHeapObject(device), pin, num);
648
659
  return takeObject(ret);
649
660
  }
650
661
  /**
@@ -653,7 +664,7 @@ export class Robot {
653
664
  * @returns {Promise<number>}
654
665
  */
655
666
  get_ai(device, pin) {
656
- const ret = wasm.robot_get_ai(this.ptr, addHeapObject(device), pin);
667
+ const ret = wasm.robot_get_ai(this.__wbg_ptr, addHeapObject(device), pin);
657
668
  return takeObject(ret);
658
669
  }
659
670
  /**
@@ -663,7 +674,7 @@ export class Robot {
663
674
  * @returns {Promise<any>}
664
675
  */
665
676
  get_ais(device, pin, num) {
666
- const ret = wasm.robot_get_ais(this.ptr, addHeapObject(device), pin, num);
677
+ const ret = wasm.robot_get_ais(this.__wbg_ptr, addHeapObject(device), pin, num);
667
678
  return takeObject(ret);
668
679
  }
669
680
  /**
@@ -672,7 +683,16 @@ export class Robot {
672
683
  * @returns {Promise<void>}
673
684
  */
674
685
  set_signal(index, value) {
675
- const ret = wasm.robot_set_signal(this.ptr, index, value);
686
+ const ret = wasm.robot_set_signal(this.__wbg_ptr, index, value);
687
+ return takeObject(ret);
688
+ }
689
+ /**
690
+ * @param {number} index
691
+ * @param {any} values
692
+ * @returns {Promise<void>}
693
+ */
694
+ set_signals(index, values) {
695
+ const ret = wasm.robot_set_signals(this.__wbg_ptr, index, addHeapObject(values));
676
696
  return takeObject(ret);
677
697
  }
678
698
  /**
@@ -680,7 +700,16 @@ export class Robot {
680
700
  * @returns {Promise<number>}
681
701
  */
682
702
  get_signal(index) {
683
- const ret = wasm.robot_get_signal(this.ptr, index);
703
+ const ret = wasm.robot_get_signal(this.__wbg_ptr, index);
704
+ return takeObject(ret);
705
+ }
706
+ /**
707
+ * @param {number} index
708
+ * @param {number} len
709
+ * @returns {Promise<any>}
710
+ */
711
+ get_signals(index, len) {
712
+ const ret = wasm.robot_get_signals(this.__wbg_ptr, index, len);
684
713
  return takeObject(ret);
685
714
  }
686
715
  /**
@@ -689,7 +718,7 @@ export class Robot {
689
718
  * @returns {Promise<void>}
690
719
  */
691
720
  add_signal(index, value) {
692
- const ret = wasm.robot_add_signal(this.ptr, index, value);
721
+ const ret = wasm.robot_add_signal(this.__wbg_ptr, index, value);
693
722
  return takeObject(ret);
694
723
  }
695
724
  /**
@@ -705,7 +734,15 @@ export class Robot {
705
734
  const len0 = WASM_VECTOR_LEN;
706
735
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
707
736
  var len1 = WASM_VECTOR_LEN;
708
- 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);
737
+ const ret = wasm.robot_start_task(this.__wbg_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);
738
+ return takeObject(ret);
739
+ }
740
+ /**
741
+ * @param {number | undefined} id
742
+ * @returns {Promise<string>}
743
+ */
744
+ wait_task(id) {
745
+ const ret = wasm.robot_wait_task(this.__wbg_ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
709
746
  return takeObject(ret);
710
747
  }
711
748
  /**
@@ -713,7 +750,73 @@ export class Robot {
713
750
  * @returns {Promise<string>}
714
751
  */
715
752
  get_task_state(id) {
716
- const ret = wasm.robot_get_task_state(this.ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
753
+ const ret = wasm.robot_get_task_state(this.__wbg_ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
754
+ return takeObject(ret);
755
+ }
756
+ /**
757
+ * @param {string} device
758
+ * @param {number} timeout
759
+ * @returns {Promise<void>}
760
+ */
761
+ set_serial_timeout(device, timeout) {
762
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
763
+ const len0 = WASM_VECTOR_LEN;
764
+ const ret = wasm.robot_set_serial_timeout(this.__wbg_ptr, ptr0, len0, timeout);
765
+ return takeObject(ret);
766
+ }
767
+ /**
768
+ * @param {string} device
769
+ * @param {number} baud_rate
770
+ * @returns {Promise<void>}
771
+ */
772
+ set_serial_baud_rate(device, baud_rate) {
773
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
774
+ const len0 = WASM_VECTOR_LEN;
775
+ const ret = wasm.robot_set_serial_baud_rate(this.__wbg_ptr, ptr0, len0, baud_rate);
776
+ return takeObject(ret);
777
+ }
778
+ /**
779
+ * @param {string} device
780
+ * @param {any} parity
781
+ * @returns {Promise<void>}
782
+ */
783
+ set_serial_parity(device, parity) {
784
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
785
+ const len0 = WASM_VECTOR_LEN;
786
+ const ret = wasm.robot_set_serial_parity(this.__wbg_ptr, ptr0, len0, addHeapObject(parity));
787
+ return takeObject(ret);
788
+ }
789
+ /**
790
+ * @param {string} device
791
+ * @param {any} data
792
+ * @returns {Promise<void>}
793
+ */
794
+ write_serial(device, data) {
795
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
796
+ const len0 = WASM_VECTOR_LEN;
797
+ const ret = wasm.robot_write_serial(this.__wbg_ptr, ptr0, len0, addHeapObject(data));
798
+ return takeObject(ret);
799
+ }
800
+ /**
801
+ * @param {string} device
802
+ * @param {number} len
803
+ * @returns {Promise<any>}
804
+ */
805
+ read_serial(device, len) {
806
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
807
+ const len0 = WASM_VECTOR_LEN;
808
+ const ret = wasm.robot_read_serial(this.__wbg_ptr, ptr0, len0, len);
809
+ return takeObject(ret);
810
+ }
811
+ /**
812
+ * @param {string} device
813
+ * @param {number} timeout
814
+ * @returns {Promise<void>}
815
+ */
816
+ set_modbus_timeout(device, timeout) {
817
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
818
+ const len0 = WASM_VECTOR_LEN;
819
+ const ret = wasm.robot_set_modbus_timeout(this.__wbg_ptr, ptr0, len0, timeout);
717
820
  return takeObject(ret);
718
821
  }
719
822
  /**
@@ -727,7 +830,7 @@ export class Robot {
727
830
  const len0 = WASM_VECTOR_LEN;
728
831
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
729
832
  const len1 = WASM_VECTOR_LEN;
730
- const ret = wasm.robot_write_single_coil(this.ptr, ptr0, len0, ptr1, len1, value);
833
+ const ret = wasm.robot_write_single_coil(this.__wbg_ptr, ptr0, len0, ptr1, len1, value);
731
834
  return takeObject(ret);
732
835
  }
733
836
  /**
@@ -741,7 +844,7 @@ export class Robot {
741
844
  const len0 = WASM_VECTOR_LEN;
742
845
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
743
846
  const len1 = WASM_VECTOR_LEN;
744
- const ret = wasm.robot_write_multiple_coils(this.ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
847
+ const ret = wasm.robot_write_multiple_coils(this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
745
848
  return takeObject(ret);
746
849
  }
747
850
  /**
@@ -755,7 +858,7 @@ export class Robot {
755
858
  const len0 = WASM_VECTOR_LEN;
756
859
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
757
860
  const len1 = WASM_VECTOR_LEN;
758
- const ret = wasm.robot_read_coils(this.ptr, ptr0, len0, ptr1, len1, count);
861
+ const ret = wasm.robot_read_coils(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
759
862
  return takeObject(ret);
760
863
  }
761
864
  /**
@@ -769,7 +872,7 @@ export class Robot {
769
872
  const len0 = WASM_VECTOR_LEN;
770
873
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
771
874
  const len1 = WASM_VECTOR_LEN;
772
- const ret = wasm.robot_read_discrete_inputs(this.ptr, ptr0, len0, ptr1, len1, count);
875
+ const ret = wasm.robot_read_discrete_inputs(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
773
876
  return takeObject(ret);
774
877
  }
775
878
  /**
@@ -783,7 +886,7 @@ export class Robot {
783
886
  const len0 = WASM_VECTOR_LEN;
784
887
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
785
888
  const len1 = WASM_VECTOR_LEN;
786
- const ret = wasm.robot_write_single_register(this.ptr, ptr0, len0, ptr1, len1, value);
889
+ const ret = wasm.robot_write_single_register(this.__wbg_ptr, ptr0, len0, ptr1, len1, value);
787
890
  return takeObject(ret);
788
891
  }
789
892
  /**
@@ -797,7 +900,7 @@ export class Robot {
797
900
  const len0 = WASM_VECTOR_LEN;
798
901
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
799
902
  const len1 = WASM_VECTOR_LEN;
800
- const ret = wasm.robot_write_multiple_registers(this.ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
903
+ const ret = wasm.robot_write_multiple_registers(this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
801
904
  return takeObject(ret);
802
905
  }
803
906
  /**
@@ -811,7 +914,7 @@ export class Robot {
811
914
  const len0 = WASM_VECTOR_LEN;
812
915
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
813
916
  const len1 = WASM_VECTOR_LEN;
814
- const ret = wasm.robot_read_holding_registers(this.ptr, ptr0, len0, ptr1, len1, count);
917
+ const ret = wasm.robot_read_holding_registers(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
815
918
  return takeObject(ret);
816
919
  }
817
920
  /**
@@ -825,7 +928,15 @@ export class Robot {
825
928
  const len0 = WASM_VECTOR_LEN;
826
929
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
827
930
  const len1 = WASM_VECTOR_LEN;
828
- const ret = wasm.robot_read_input_registers(this.ptr, ptr0, len0, ptr1, len1, count);
931
+ const ret = wasm.robot_read_input_registers(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
932
+ return takeObject(ret);
933
+ }
934
+ /**
935
+ * @param {boolean | undefined} force
936
+ * @returns {Promise<void>}
937
+ */
938
+ init_claw(force) {
939
+ const ret = wasm.robot_init_claw(this.__wbg_ptr, isLikeNone(force) ? 0xFFFFFF : force ? 1 : 0);
829
940
  return takeObject(ret);
830
941
  }
831
942
  /**
@@ -834,14 +945,14 @@ export class Robot {
834
945
  * @returns {Promise<void>}
835
946
  */
836
947
  set_claw(force, amplitude) {
837
- const ret = wasm.robot_set_claw(this.ptr, !isLikeNone(force), isLikeNone(force) ? 0 : force, !isLikeNone(amplitude), isLikeNone(amplitude) ? 0 : amplitude);
948
+ const ret = wasm.robot_set_claw(this.__wbg_ptr, !isLikeNone(force), isLikeNone(force) ? 0 : force, !isLikeNone(amplitude), isLikeNone(amplitude) ? 0 : amplitude);
838
949
  return takeObject(ret);
839
950
  }
840
951
  /**
841
952
  * @returns {Promise<any>}
842
953
  */
843
954
  get_claw() {
844
- const ret = wasm.robot_get_claw(this.ptr);
955
+ const ret = wasm.robot_get_claw(this.__wbg_ptr);
845
956
  return takeObject(ret);
846
957
  }
847
958
  /**
@@ -854,7 +965,7 @@ export class Robot {
854
965
  const len0 = WASM_VECTOR_LEN;
855
966
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
856
967
  var len1 = WASM_VECTOR_LEN;
857
- const ret = wasm.robot_load_led_style(this.ptr, ptr0, len0, ptr1, len1);
968
+ const ret = wasm.robot_load_led_style(this.__wbg_ptr, ptr0, len0, ptr1, len1);
858
969
  return takeObject(ret);
859
970
  }
860
971
  /**
@@ -862,7 +973,7 @@ export class Robot {
862
973
  * @returns {Promise<void>}
863
974
  */
864
975
  set_led_style(style) {
865
- const ret = wasm.robot_set_led_style(this.ptr, addHeapObject(style));
976
+ const ret = wasm.robot_set_led_style(this.__wbg_ptr, addHeapObject(style));
866
977
  return takeObject(ret);
867
978
  }
868
979
  /**
@@ -874,7 +985,7 @@ export class Robot {
874
985
  set_led(mode, speed, colors) {
875
986
  const ptr0 = passArray32ToWasm0(colors, wasm.__wbindgen_malloc);
876
987
  const len0 = WASM_VECTOR_LEN;
877
- const ret = wasm.robot_set_led(this.ptr, mode, speed, ptr0, len0);
988
+ const ret = wasm.robot_set_led(this.__wbg_ptr, mode, speed, ptr0, len0);
878
989
  return takeObject(ret);
879
990
  }
880
991
  /**
@@ -883,7 +994,7 @@ export class Robot {
883
994
  * @returns {Promise<void>}
884
995
  */
885
996
  set_voice(voice, volume) {
886
- const ret = wasm.robot_set_voice(this.ptr, voice, volume);
997
+ const ret = wasm.robot_set_voice(this.__wbg_ptr, voice, volume);
887
998
  return takeObject(ret);
888
999
  }
889
1000
  /**
@@ -891,49 +1002,49 @@ export class Robot {
891
1002
  * @returns {Promise<void>}
892
1003
  */
893
1004
  set_fan(mode) {
894
- const ret = wasm.robot_set_fan(this.ptr, mode);
1005
+ const ret = wasm.robot_set_fan(this.__wbg_ptr, mode);
895
1006
  return takeObject(ret);
896
1007
  }
897
1008
  /**
898
1009
  * @returns {Promise<void>}
899
1010
  */
900
1011
  start_sys() {
901
- const ret = wasm.robot_start_sys(this.ptr);
1012
+ const ret = wasm.robot_start_sys(this.__wbg_ptr);
902
1013
  return takeObject(ret);
903
1014
  }
904
1015
  /**
905
1016
  * @returns {Promise<void>}
906
1017
  */
907
1018
  stop_sys() {
908
- const ret = wasm.robot_stop_sys(this.ptr);
1019
+ const ret = wasm.robot_stop_sys(this.__wbg_ptr);
909
1020
  return takeObject(ret);
910
1021
  }
911
1022
  /**
912
1023
  * @returns {Promise<void>}
913
1024
  */
914
1025
  powerdown() {
915
- const ret = wasm.robot_powerdown(this.ptr);
1026
+ const ret = wasm.robot_powerdown(this.__wbg_ptr);
916
1027
  return takeObject(ret);
917
1028
  }
918
1029
  /**
919
1030
  * @returns {Promise<void>}
920
1031
  */
921
1032
  reboot() {
922
- const ret = wasm.robot_reboot(this.ptr);
1033
+ const ret = wasm.robot_reboot(this.__wbg_ptr);
923
1034
  return takeObject(ret);
924
1035
  }
925
1036
  /**
926
1037
  * @returns {Promise<void>}
927
1038
  */
928
1039
  stop() {
929
- const ret = wasm.robot_stop(this.ptr);
1040
+ const ret = wasm.robot_stop(this.__wbg_ptr);
930
1041
  return takeObject(ret);
931
1042
  }
932
1043
  /**
933
1044
  * @returns {Promise<void>}
934
1045
  */
935
1046
  estop() {
936
- const ret = wasm.robot_estop(this.ptr);
1047
+ const ret = wasm.robot_estop(this.__wbg_ptr);
937
1048
  return takeObject(ret);
938
1049
  }
939
1050
  /**
@@ -946,7 +1057,7 @@ export class Robot {
946
1057
  const len0 = WASM_VECTOR_LEN;
947
1058
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
948
1059
  var len1 = WASM_VECTOR_LEN;
949
- const ret = wasm.robot_load_tcp(this.ptr, ptr0, len0, ptr1, len1);
1060
+ const ret = wasm.robot_load_tcp(this.__wbg_ptr, ptr0, len0, ptr1, len1);
950
1061
  return takeObject(ret);
951
1062
  }
952
1063
  /**
@@ -954,14 +1065,14 @@ export class Robot {
954
1065
  * @returns {Promise<void>}
955
1066
  */
956
1067
  set_tcp(pose) {
957
- const ret = wasm.robot_set_tcp(this.ptr, addHeapObject(pose));
1068
+ const ret = wasm.robot_set_tcp(this.__wbg_ptr, addHeapObject(pose));
958
1069
  return takeObject(ret);
959
1070
  }
960
1071
  /**
961
1072
  * @returns {Promise<any>}
962
1073
  */
963
1074
  get_tcp() {
964
- const ret = wasm.robot_get_tcp(this.ptr);
1075
+ const ret = wasm.robot_get_tcp(this.__wbg_ptr);
965
1076
  return takeObject(ret);
966
1077
  }
967
1078
  /**
@@ -969,14 +1080,28 @@ export class Robot {
969
1080
  * @returns {Promise<void>}
970
1081
  */
971
1082
  set_velocity_factor(speed_factor) {
972
- const ret = wasm.robot_set_velocity_factor(this.ptr, speed_factor);
1083
+ const ret = wasm.robot_set_velocity_factor(this.__wbg_ptr, speed_factor);
973
1084
  return takeObject(ret);
974
1085
  }
975
1086
  /**
976
1087
  * @returns {Promise<number>}
977
1088
  */
978
1089
  get_velocity_factor() {
979
- const ret = wasm.robot_get_velocity_factor(this.ptr);
1090
+ const ret = wasm.robot_get_velocity_factor(this.__wbg_ptr);
1091
+ return takeObject(ret);
1092
+ }
1093
+ /**
1094
+ * @returns {Promise<any>}
1095
+ */
1096
+ get_kin_data() {
1097
+ const ret = wasm.robot_get_kin_data(this.__wbg_ptr);
1098
+ return takeObject(ret);
1099
+ }
1100
+ /**
1101
+ * @returns {Promise<any>}
1102
+ */
1103
+ get_robot_state() {
1104
+ const ret = wasm.robot_get_robot_state(this.__wbg_ptr);
980
1105
  return takeObject(ret);
981
1106
  }
982
1107
  /**
@@ -989,7 +1114,7 @@ export class Robot {
989
1114
  const len0 = WASM_VECTOR_LEN;
990
1115
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
991
1116
  var len1 = WASM_VECTOR_LEN;
992
- const ret = wasm.robot_load_payload(this.ptr, ptr0, len0, ptr1, len1);
1117
+ const ret = wasm.robot_load_payload(this.__wbg_ptr, ptr0, len0, ptr1, len1);
993
1118
  return takeObject(ret);
994
1119
  }
995
1120
  /**
@@ -998,14 +1123,14 @@ export class Robot {
998
1123
  * @returns {Promise<void>}
999
1124
  */
1000
1125
  set_payload(mass, cog) {
1001
- const ret = wasm.robot_set_payload(this.ptr, !isLikeNone(mass), isLikeNone(mass) ? 0 : mass, isLikeNone(cog) ? 0 : addHeapObject(cog));
1126
+ const ret = wasm.robot_set_payload(this.__wbg_ptr, !isLikeNone(mass), isLikeNone(mass) ? 0 : mass, isLikeNone(cog) ? 0 : addHeapObject(cog));
1002
1127
  return takeObject(ret);
1003
1128
  }
1004
1129
  /**
1005
1130
  * @returns {Promise<any>}
1006
1131
  */
1007
1132
  get_payload() {
1008
- const ret = wasm.robot_get_payload(this.ptr);
1133
+ const ret = wasm.robot_get_payload(this.__wbg_ptr);
1009
1134
  return takeObject(ret);
1010
1135
  }
1011
1136
  /**
@@ -1013,14 +1138,14 @@ export class Robot {
1013
1138
  * @returns {Promise<void>}
1014
1139
  */
1015
1140
  set_gravity(pose) {
1016
- const ret = wasm.robot_set_gravity(this.ptr, addHeapObject(pose));
1141
+ const ret = wasm.robot_set_gravity(this.__wbg_ptr, addHeapObject(pose));
1017
1142
  return takeObject(ret);
1018
1143
  }
1019
1144
  /**
1020
1145
  * @returns {Promise<any>}
1021
1146
  */
1022
1147
  get_gravity() {
1023
- const ret = wasm.robot_get_gravity(this.ptr);
1148
+ const ret = wasm.robot_get_gravity(this.__wbg_ptr);
1024
1149
  return takeObject(ret);
1025
1150
  }
1026
1151
  }
@@ -1029,15 +1154,16 @@ export class Robot {
1029
1154
  export class RobotSubscription {
1030
1155
 
1031
1156
  static __wrap(ptr) {
1157
+ ptr = ptr >>> 0;
1032
1158
  const obj = Object.create(RobotSubscription.prototype);
1033
- obj.ptr = ptr;
1159
+ obj.__wbg_ptr = ptr;
1034
1160
 
1035
1161
  return obj;
1036
1162
  }
1037
1163
 
1038
1164
  __destroy_into_raw() {
1039
- const ptr = this.ptr;
1040
- this.ptr = 0;
1165
+ const ptr = this.__wbg_ptr;
1166
+ this.__wbg_ptr = 0;
1041
1167
 
1042
1168
  return ptr;
1043
1169
  }
@@ -1050,7 +1176,7 @@ export class RobotSubscription {
1050
1176
  * @returns {Promise<string | undefined>}
1051
1177
  */
1052
1178
  next() {
1053
- const ret = wasm.robotsubscription_next(this.ptr);
1179
+ const ret = wasm.robotsubscription_next(this.__wbg_ptr);
1054
1180
  return takeObject(ret);
1055
1181
  }
1056
1182
  }
@@ -1059,24 +1185,17 @@ export function __wbindgen_object_drop_ref(arg0) {
1059
1185
  takeObject(arg0);
1060
1186
  };
1061
1187
 
1062
- export function __wbindgen_is_object(arg0) {
1063
- const val = getObject(arg0);
1064
- const ret = typeof(val) === 'object' && val !== null;
1065
- return ret;
1066
- };
1067
-
1068
- export function __wbindgen_is_undefined(arg0) {
1069
- const ret = getObject(arg0) === undefined;
1070
- return ret;
1071
- };
1072
-
1073
- export function __wbindgen_in(arg0, arg1) {
1074
- const ret = getObject(arg0) in getObject(arg1);
1075
- return ret;
1188
+ export function __wbindgen_string_get(arg0, arg1) {
1189
+ const obj = getObject(arg1);
1190
+ const ret = typeof(obj) === 'string' ? obj : undefined;
1191
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1192
+ var len1 = WASM_VECTOR_LEN;
1193
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
1194
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
1076
1195
  };
1077
1196
 
1078
- export function __wbindgen_number_new(arg0) {
1079
- const ret = arg0;
1197
+ export function __wbindgen_string_new(arg0, arg1) {
1198
+ const ret = getStringFromWasm0(arg0, arg1);
1080
1199
  return addHeapObject(ret);
1081
1200
  };
1082
1201
 
@@ -1086,19 +1205,14 @@ export function __wbindgen_boolean_get(arg0) {
1086
1205
  return ret;
1087
1206
  };
1088
1207
 
1089
- export function __wbindgen_is_bigint(arg0) {
1090
- const ret = typeof(getObject(arg0)) === 'bigint';
1091
- return ret;
1092
- };
1093
-
1094
- export function __wbindgen_bigint_from_i64(arg0) {
1095
- const ret = arg0;
1208
+ export function __wbg_robotsubscription_new(arg0) {
1209
+ const ret = RobotSubscription.__wrap(arg0);
1096
1210
  return addHeapObject(ret);
1097
1211
  };
1098
1212
 
1099
- export function __wbindgen_jsval_eq(arg0, arg1) {
1100
- const ret = getObject(arg0) === getObject(arg1);
1101
- return ret;
1213
+ export function __wbg_robot_new(arg0) {
1214
+ const ret = Robot.__wrap(arg0);
1215
+ return addHeapObject(ret);
1102
1216
  };
1103
1217
 
1104
1218
  export function __wbindgen_number_get(arg0, arg1) {
@@ -1108,17 +1222,14 @@ export function __wbindgen_number_get(arg0, arg1) {
1108
1222
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
1109
1223
  };
1110
1224
 
1111
- export function __wbindgen_string_get(arg0, arg1) {
1112
- const obj = getObject(arg1);
1113
- const ret = typeof(obj) === 'string' ? obj : undefined;
1114
- var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1115
- var len0 = WASM_VECTOR_LEN;
1116
- getInt32Memory0()[arg0 / 4 + 1] = len0;
1117
- getInt32Memory0()[arg0 / 4 + 0] = ptr0;
1225
+ export function __wbindgen_is_object(arg0) {
1226
+ const val = getObject(arg0);
1227
+ const ret = typeof(val) === 'object' && val !== null;
1228
+ return ret;
1118
1229
  };
1119
1230
 
1120
- export function __wbindgen_bigint_from_u64(arg0) {
1121
- const ret = BigInt.asUintN(64, arg0);
1231
+ export function __wbindgen_number_new(arg0) {
1232
+ const ret = arg0;
1122
1233
  return addHeapObject(ret);
1123
1234
  };
1124
1235
 
@@ -1132,21 +1243,36 @@ export function __wbindgen_cb_drop(arg0) {
1132
1243
  return ret;
1133
1244
  };
1134
1245
 
1135
- export function __wbindgen_string_new(arg0, arg1) {
1136
- const ret = getStringFromWasm0(arg0, arg1);
1137
- return addHeapObject(ret);
1246
+ export function __wbindgen_is_bigint(arg0) {
1247
+ const ret = typeof(getObject(arg0)) === 'bigint';
1248
+ return ret;
1138
1249
  };
1139
1250
 
1140
- export function __wbg_robot_new(arg0) {
1141
- const ret = Robot.__wrap(arg0);
1251
+ export function __wbindgen_bigint_from_i64(arg0) {
1252
+ const ret = arg0;
1142
1253
  return addHeapObject(ret);
1143
1254
  };
1144
1255
 
1145
- export function __wbg_robotsubscription_new(arg0) {
1146
- const ret = RobotSubscription.__wrap(arg0);
1256
+ export function __wbindgen_jsval_eq(arg0, arg1) {
1257
+ const ret = getObject(arg0) === getObject(arg1);
1258
+ return ret;
1259
+ };
1260
+
1261
+ export function __wbindgen_in(arg0, arg1) {
1262
+ const ret = getObject(arg0) in getObject(arg1);
1263
+ return ret;
1264
+ };
1265
+
1266
+ export function __wbindgen_bigint_from_u64(arg0) {
1267
+ const ret = BigInt.asUintN(64, arg0);
1147
1268
  return addHeapObject(ret);
1148
1269
  };
1149
1270
 
1271
+ export function __wbindgen_is_undefined(arg0) {
1272
+ const ret = getObject(arg0) === undefined;
1273
+ return ret;
1274
+ };
1275
+
1150
1276
  export function __wbindgen_error_new(arg0, arg1) {
1151
1277
  const ret = new Error(getStringFromWasm0(arg0, arg1));
1152
1278
  return addHeapObject(ret);
@@ -1162,73 +1288,73 @@ export function __wbindgen_object_clone_ref(arg0) {
1162
1288
  return addHeapObject(ret);
1163
1289
  };
1164
1290
 
1165
- export function __wbg_addEventListener_615d4590d38da1c9() { return handleError(function (arg0, arg1, arg2, arg3) {
1291
+ export function __wbg_addEventListener_d25d1ffe6c69ae96() { return handleError(function (arg0, arg1, arg2, arg3) {
1166
1292
  getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
1167
1293
  }, arguments) };
1168
1294
 
1169
- export function __wbg_addEventListener_cf5b03cd29763277() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
1295
+ export function __wbg_addEventListener_3a7d7c4177ce91d1() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
1170
1296
  getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
1171
1297
  }, arguments) };
1172
1298
 
1173
- export function __wbg_dispatchEvent_615d1ccbba577081() { return handleError(function (arg0, arg1) {
1299
+ export function __wbg_dispatchEvent_cfc38228a531c8c8() { return handleError(function (arg0, arg1) {
1174
1300
  const ret = getObject(arg0).dispatchEvent(getObject(arg1));
1175
1301
  return ret;
1176
1302
  }, arguments) };
1177
1303
 
1178
- export function __wbg_removeEventListener_86fd19ed073cd1ed() { return handleError(function (arg0, arg1, arg2, arg3) {
1304
+ export function __wbg_removeEventListener_7a381df5fdb6037f() { return handleError(function (arg0, arg1, arg2, arg3) {
1179
1305
  getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
1180
1306
  }, arguments) };
1181
1307
 
1182
- export function __wbg_wasClean_17e8b22af0b82315(arg0) {
1308
+ export function __wbg_wasClean_133b4529d739de9e(arg0) {
1183
1309
  const ret = getObject(arg0).wasClean;
1184
1310
  return ret;
1185
1311
  };
1186
1312
 
1187
- export function __wbg_code_9743a5678b87b9e9(arg0) {
1313
+ export function __wbg_code_5921daf18e5a3378(arg0) {
1188
1314
  const ret = getObject(arg0).code;
1189
1315
  return ret;
1190
1316
  };
1191
1317
 
1192
- export function __wbg_reason_8585c102803c11b5(arg0, arg1) {
1318
+ export function __wbg_reason_c07db343645d6e25(arg0, arg1) {
1193
1319
  const ret = getObject(arg1).reason;
1194
- const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1195
- const len0 = WASM_VECTOR_LEN;
1196
- getInt32Memory0()[arg0 / 4 + 1] = len0;
1197
- getInt32Memory0()[arg0 / 4 + 0] = ptr0;
1320
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1321
+ const len1 = WASM_VECTOR_LEN;
1322
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
1323
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
1198
1324
  };
1199
1325
 
1200
- export function __wbg_newwitheventinitdict_0e8e2070ae66ce38() { return handleError(function (arg0, arg1, arg2) {
1326
+ export function __wbg_newwitheventinitdict_6b770a22a3426955() { return handleError(function (arg0, arg1, arg2) {
1201
1327
  const ret = new CloseEvent(getStringFromWasm0(arg0, arg1), getObject(arg2));
1202
1328
  return addHeapObject(ret);
1203
1329
  }, arguments) };
1204
1330
 
1205
- export function __wbg_readyState_b3671943d2cedc2b(arg0) {
1331
+ export function __wbg_readyState_ad4a43cf245ed346(arg0) {
1206
1332
  const ret = getObject(arg0).readyState;
1207
1333
  return ret;
1208
1334
  };
1209
1335
 
1210
- export function __wbg_setbinaryType_c9b2fa398c277601(arg0, arg1) {
1336
+ export function __wbg_setbinaryType_912a58ff49a07245(arg0, arg1) {
1211
1337
  getObject(arg0).binaryType = takeObject(arg1);
1212
1338
  };
1213
1339
 
1214
- export function __wbg_new_8ad026ef33da9ab1() { return handleError(function (arg0, arg1) {
1340
+ export function __wbg_new_c70a4fdc1ed8f3bb() { return handleError(function (arg0, arg1) {
1215
1341
  const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
1216
1342
  return addHeapObject(ret);
1217
1343
  }, arguments) };
1218
1344
 
1219
- export function __wbg_close_546591d4b4350b36() { return handleError(function (arg0) {
1345
+ export function __wbg_close_b57426e46b2cde05() { return handleError(function (arg0) {
1220
1346
  getObject(arg0).close();
1221
1347
  }, arguments) };
1222
1348
 
1223
- export function __wbg_send_36f8bcb566f8afa0() { return handleError(function (arg0, arg1, arg2) {
1349
+ export function __wbg_send_1cc5e505b0cbc15c() { return handleError(function (arg0, arg1, arg2) {
1224
1350
  getObject(arg0).send(getStringFromWasm0(arg1, arg2));
1225
1351
  }, arguments) };
1226
1352
 
1227
- export function __wbg_send_c1c0838681688262() { return handleError(function (arg0, arg1, arg2) {
1353
+ export function __wbg_send_43a6924260160efb() { return handleError(function (arg0, arg1, arg2) {
1228
1354
  getObject(arg0).send(getArrayU8FromWasm0(arg1, arg2));
1229
1355
  }, arguments) };
1230
1356
 
1231
- export function __wbg_data_af909e5dfe73e68c(arg0) {
1357
+ export function __wbg_data_338d13609f6165a6(arg0) {
1232
1358
  const ret = getObject(arg0).data;
1233
1359
  return addHeapObject(ret);
1234
1360
  };
@@ -1257,17 +1383,17 @@ export function __wbg_set_841ac57cff3d672b(arg0, arg1, arg2) {
1257
1383
  getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
1258
1384
  };
1259
1385
 
1260
- export function __wbg_get_27fe3dac1c4d0224(arg0, arg1) {
1386
+ export function __wbg_get_7303ed2ef026b2f5(arg0, arg1) {
1261
1387
  const ret = getObject(arg0)[arg1 >>> 0];
1262
1388
  return addHeapObject(ret);
1263
1389
  };
1264
1390
 
1265
- export function __wbg_length_e498fbc24f9c1d4f(arg0) {
1391
+ export function __wbg_length_820c786973abdd8a(arg0) {
1266
1392
  const ret = getObject(arg0).length;
1267
1393
  return ret;
1268
1394
  };
1269
1395
 
1270
- export function __wbg_new_b525de17f44a8943() {
1396
+ export function __wbg_new_0394642eae39db16() {
1271
1397
  const ret = new Array();
1272
1398
  return addHeapObject(ret);
1273
1399
  };
@@ -1277,56 +1403,56 @@ export function __wbindgen_is_function(arg0) {
1277
1403
  return ret;
1278
1404
  };
1279
1405
 
1280
- export function __wbg_next_b7d530c04fd8b217(arg0) {
1406
+ export function __wbg_next_f4bc0e96ea67da68(arg0) {
1281
1407
  const ret = getObject(arg0).next;
1282
1408
  return addHeapObject(ret);
1283
1409
  };
1284
1410
 
1285
- export function __wbg_next_88560ec06a094dea() { return handleError(function (arg0) {
1411
+ export function __wbg_next_ec061e48a0e72a96() { return handleError(function (arg0) {
1286
1412
  const ret = getObject(arg0).next();
1287
1413
  return addHeapObject(ret);
1288
1414
  }, arguments) };
1289
1415
 
1290
- export function __wbg_done_1ebec03bbd919843(arg0) {
1416
+ export function __wbg_done_b6abb27d42b63867(arg0) {
1291
1417
  const ret = getObject(arg0).done;
1292
1418
  return ret;
1293
1419
  };
1294
1420
 
1295
- export function __wbg_value_6ac8da5cc5b3efda(arg0) {
1421
+ export function __wbg_value_2f4ef2036bfad28e(arg0) {
1296
1422
  const ret = getObject(arg0).value;
1297
1423
  return addHeapObject(ret);
1298
1424
  };
1299
1425
 
1300
- export function __wbg_iterator_55f114446221aa5a() {
1426
+ export function __wbg_iterator_7c7e58f62eb84700() {
1301
1427
  const ret = Symbol.iterator;
1302
1428
  return addHeapObject(ret);
1303
1429
  };
1304
1430
 
1305
- export function __wbg_get_baf4855f9a986186() { return handleError(function (arg0, arg1) {
1431
+ export function __wbg_get_f53c921291c381bd() { return handleError(function (arg0, arg1) {
1306
1432
  const ret = Reflect.get(getObject(arg0), getObject(arg1));
1307
1433
  return addHeapObject(ret);
1308
1434
  }, arguments) };
1309
1435
 
1310
- export function __wbg_call_95d1ea488d03e4e8() { return handleError(function (arg0, arg1) {
1436
+ export function __wbg_call_557a2f2deacc4912() { return handleError(function (arg0, arg1) {
1311
1437
  const ret = getObject(arg0).call(getObject(arg1));
1312
1438
  return addHeapObject(ret);
1313
1439
  }, arguments) };
1314
1440
 
1315
- export function __wbg_new_f9876326328f45ed() {
1441
+ export function __wbg_new_2b6fea4ea03b1b95() {
1316
1442
  const ret = new Object();
1317
1443
  return addHeapObject(ret);
1318
1444
  };
1319
1445
 
1320
- export function __wbg_set_17224bc548dd1d7b(arg0, arg1, arg2) {
1446
+ export function __wbg_set_b4da98d504ac6091(arg0, arg1, arg2) {
1321
1447
  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1322
1448
  };
1323
1449
 
1324
- export function __wbg_isArray_39d28997bf6b96b4(arg0) {
1450
+ export function __wbg_isArray_04e59fb73f78ab5b(arg0) {
1325
1451
  const ret = Array.isArray(getObject(arg0));
1326
1452
  return ret;
1327
1453
  };
1328
1454
 
1329
- export function __wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065(arg0) {
1455
+ export function __wbg_instanceof_ArrayBuffer_ef2632aa0d4bfff8(arg0) {
1330
1456
  let result;
1331
1457
  try {
1332
1458
  result = getObject(arg0) instanceof ArrayBuffer;
@@ -1337,7 +1463,7 @@ export function __wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065(arg0) {
1337
1463
  return ret;
1338
1464
  };
1339
1465
 
1340
- export function __wbg_instanceof_Error_749a7378f4439ee0(arg0) {
1466
+ export function __wbg_instanceof_Error_fac23a8832b241da(arg0) {
1341
1467
  let result;
1342
1468
  try {
1343
1469
  result = getObject(arg0) instanceof Error;
@@ -1348,44 +1474,44 @@ export function __wbg_instanceof_Error_749a7378f4439ee0(arg0) {
1348
1474
  return ret;
1349
1475
  };
1350
1476
 
1351
- export function __wbg_message_a95c3ef248e4b57a(arg0) {
1477
+ export function __wbg_message_eab7d45ec69a2135(arg0) {
1352
1478
  const ret = getObject(arg0).message;
1353
1479
  return addHeapObject(ret);
1354
1480
  };
1355
1481
 
1356
- export function __wbg_name_c69a20c4b1197dc0(arg0) {
1482
+ export function __wbg_name_8e6176d4db1a502d(arg0) {
1357
1483
  const ret = getObject(arg0).name;
1358
1484
  return addHeapObject(ret);
1359
1485
  };
1360
1486
 
1361
- export function __wbg_toString_cec163b212643722(arg0) {
1487
+ export function __wbg_toString_506566b763774a16(arg0) {
1362
1488
  const ret = getObject(arg0).toString();
1363
1489
  return addHeapObject(ret);
1364
1490
  };
1365
1491
 
1366
- export function __wbg_call_9495de66fdbe016b() { return handleError(function (arg0, arg1, arg2) {
1492
+ export function __wbg_call_587b30eea3e09332() { return handleError(function (arg0, arg1, arg2) {
1367
1493
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
1368
1494
  return addHeapObject(ret);
1369
1495
  }, arguments) };
1370
1496
 
1371
- export function __wbg_isSafeInteger_8c4789029e885159(arg0) {
1497
+ export function __wbg_isSafeInteger_2088b01008075470(arg0) {
1372
1498
  const ret = Number.isSafeInteger(getObject(arg0));
1373
1499
  return ret;
1374
1500
  };
1375
1501
 
1376
- export function __wbg_entries_4e1315b774245952(arg0) {
1502
+ export function __wbg_entries_13e011453776468f(arg0) {
1377
1503
  const ret = Object.entries(getObject(arg0));
1378
1504
  return addHeapObject(ret);
1379
1505
  };
1380
1506
 
1381
- export function __wbg_new_9d3a9ce4282a18a8(arg0, arg1) {
1507
+ export function __wbg_new_2b55e405e4af4986(arg0, arg1) {
1382
1508
  try {
1383
1509
  var state0 = {a: arg0, b: arg1};
1384
1510
  var cb0 = (arg0, arg1) => {
1385
1511
  const a = state0.a;
1386
1512
  state0.a = 0;
1387
1513
  try {
1388
- return __wbg_adapter_217(a, state0.b, arg0, arg1);
1514
+ return __wbg_adapter_229(a, state0.b, arg0, arg1);
1389
1515
  } finally {
1390
1516
  state0.a = a;
1391
1517
  }
@@ -1397,36 +1523,36 @@ export function __wbg_new_9d3a9ce4282a18a8(arg0, arg1) {
1397
1523
  }
1398
1524
  };
1399
1525
 
1400
- export function __wbg_resolve_fd40f858d9db1a04(arg0) {
1526
+ export function __wbg_resolve_ae38ad63c43ff98b(arg0) {
1401
1527
  const ret = Promise.resolve(getObject(arg0));
1402
1528
  return addHeapObject(ret);
1403
1529
  };
1404
1530
 
1405
- export function __wbg_then_ec5db6d509eb475f(arg0, arg1) {
1531
+ export function __wbg_then_8df675b8bb5d5e3c(arg0, arg1) {
1406
1532
  const ret = getObject(arg0).then(getObject(arg1));
1407
1533
  return addHeapObject(ret);
1408
1534
  };
1409
1535
 
1410
- export function __wbg_buffer_cf65c07de34b9a08(arg0) {
1536
+ export function __wbg_buffer_55ba7a6b1b92e2ac(arg0) {
1411
1537
  const ret = getObject(arg0).buffer;
1412
1538
  return addHeapObject(ret);
1413
1539
  };
1414
1540
 
1415
- export function __wbg_new_537b7341ce90bb31(arg0) {
1541
+ export function __wbg_new_09938a7d020f049b(arg0) {
1416
1542
  const ret = new Uint8Array(getObject(arg0));
1417
1543
  return addHeapObject(ret);
1418
1544
  };
1419
1545
 
1420
- export function __wbg_set_17499e8aa4003ebd(arg0, arg1, arg2) {
1546
+ export function __wbg_set_3698e3ca519b3c3c(arg0, arg1, arg2) {
1421
1547
  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
1422
1548
  };
1423
1549
 
1424
- export function __wbg_length_27a2afe8ab42b09f(arg0) {
1550
+ export function __wbg_length_0aab7ffd65ad19ed(arg0) {
1425
1551
  const ret = getObject(arg0).length;
1426
1552
  return ret;
1427
1553
  };
1428
1554
 
1429
- export function __wbg_instanceof_Uint8Array_01cebe79ca606cca(arg0) {
1555
+ export function __wbg_instanceof_Uint8Array_1349640af2da2e88(arg0) {
1430
1556
  let result;
1431
1557
  try {
1432
1558
  result = getObject(arg0) instanceof Uint8Array;
@@ -1437,7 +1563,7 @@ export function __wbg_instanceof_Uint8Array_01cebe79ca606cca(arg0) {
1437
1563
  return ret;
1438
1564
  };
1439
1565
 
1440
- export function __wbg_set_6aa458a4ebdb65cb() { return handleError(function (arg0, arg1, arg2) {
1566
+ export function __wbg_set_07da13cc24b69217() { return handleError(function (arg0, arg1, arg2) {
1441
1567
  const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1442
1568
  return ret;
1443
1569
  }, arguments) };
@@ -1451,10 +1577,10 @@ export function __wbindgen_bigint_get_as_i64(arg0, arg1) {
1451
1577
 
1452
1578
  export function __wbindgen_debug_string(arg0, arg1) {
1453
1579
  const ret = debugString(getObject(arg1));
1454
- const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1455
- const len0 = WASM_VECTOR_LEN;
1456
- getInt32Memory0()[arg0 / 4 + 1] = len0;
1457
- getInt32Memory0()[arg0 / 4 + 0] = ptr0;
1580
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1581
+ const len1 = WASM_VECTOR_LEN;
1582
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
1583
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
1458
1584
  };
1459
1585
 
1460
1586
  export function __wbindgen_throw(arg0, arg1) {
@@ -1466,33 +1592,33 @@ export function __wbindgen_memory() {
1466
1592
  return addHeapObject(ret);
1467
1593
  };
1468
1594
 
1469
- export function __wbindgen_closure_wrapper1504(arg0, arg1, arg2) {
1470
- const ret = makeMutClosure(arg0, arg1, 570, __wbg_adapter_48);
1595
+ export function __wbindgen_closure_wrapper1685(arg0, arg1, arg2) {
1596
+ const ret = makeMutClosure(arg0, arg1, 631, __wbg_adapter_48);
1471
1597
  return addHeapObject(ret);
1472
1598
  };
1473
1599
 
1474
- export function __wbindgen_closure_wrapper1506(arg0, arg1, arg2) {
1475
- const ret = makeMutClosure(arg0, arg1, 570, __wbg_adapter_51);
1600
+ export function __wbindgen_closure_wrapper1687(arg0, arg1, arg2) {
1601
+ const ret = makeMutClosure(arg0, arg1, 631, __wbg_adapter_48);
1476
1602
  return addHeapObject(ret);
1477
1603
  };
1478
1604
 
1479
- export function __wbindgen_closure_wrapper1508(arg0, arg1, arg2) {
1480
- const ret = makeMutClosure(arg0, arg1, 570, __wbg_adapter_51);
1605
+ export function __wbindgen_closure_wrapper1689(arg0, arg1, arg2) {
1606
+ const ret = makeMutClosure(arg0, arg1, 631, __wbg_adapter_53);
1481
1607
  return addHeapObject(ret);
1482
1608
  };
1483
1609
 
1484
- export function __wbindgen_closure_wrapper1510(arg0, arg1, arg2) {
1485
- const ret = makeMutClosure(arg0, arg1, 570, __wbg_adapter_51);
1610
+ export function __wbindgen_closure_wrapper1691(arg0, arg1, arg2) {
1611
+ const ret = makeMutClosure(arg0, arg1, 631, __wbg_adapter_48);
1486
1612
  return addHeapObject(ret);
1487
1613
  };
1488
1614
 
1489
- export function __wbindgen_closure_wrapper1989(arg0, arg1, arg2) {
1490
- const ret = makeMutClosure(arg0, arg1, 664, __wbg_adapter_58);
1615
+ export function __wbindgen_closure_wrapper2166(arg0, arg1, arg2) {
1616
+ const ret = makeMutClosure(arg0, arg1, 706, __wbg_adapter_58);
1491
1617
  return addHeapObject(ret);
1492
1618
  };
1493
1619
 
1494
- export function __wbindgen_closure_wrapper2023(arg0, arg1, arg2) {
1495
- const ret = makeMutClosure(arg0, arg1, 678, __wbg_adapter_61);
1620
+ export function __wbindgen_closure_wrapper2201(arg0, arg1, arg2) {
1621
+ const ret = makeMutClosure(arg0, arg1, 720, __wbg_adapter_61);
1496
1622
  return addHeapObject(ret);
1497
1623
  };
1498
1624