lebai_sdk 0.1.8 → 0.1.9

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,15 +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
27
  function isLikeNone(x) {
37
28
  return x === undefined || x === null;
38
29
  }
@@ -87,14 +78,14 @@ function passStringToWasm0(arg, malloc, realloc) {
87
78
 
88
79
  if (realloc === undefined) {
89
80
  const buf = cachedTextEncoder.encode(arg);
90
- const ptr = malloc(buf.length);
81
+ const ptr = malloc(buf.length) >>> 0;
91
82
  getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
92
83
  WASM_VECTOR_LEN = buf.length;
93
84
  return ptr;
94
85
  }
95
86
 
96
87
  let len = arg.length;
97
- let ptr = malloc(len);
88
+ let ptr = malloc(len) >>> 0;
98
89
 
99
90
  const mem = getUint8Memory0();
100
91
 
@@ -110,7 +101,7 @@ function passStringToWasm0(arg, malloc, realloc) {
110
101
  if (offset !== 0) {
111
102
  arg = arg.slice(offset);
112
103
  }
113
- ptr = realloc(ptr, len, len = offset + arg.length * 3);
104
+ ptr = realloc(ptr, len, len = offset + arg.length * 3) >>> 0;
114
105
  const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
115
106
  const ret = encodeString(arg, view);
116
107
 
@@ -121,6 +112,15 @@ function passStringToWasm0(arg, malloc, realloc) {
121
112
  return ptr;
122
113
  }
123
114
 
115
+ function addHeapObject(obj) {
116
+ if (heap_next === heap.length) heap.push(heap.length + 1);
117
+ const idx = heap_next;
118
+ heap_next = heap[idx];
119
+
120
+ heap[idx] = obj;
121
+ return idx;
122
+ }
123
+
124
124
  const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
125
125
 
126
126
  let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -128,6 +128,7 @@ let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true
128
128
  cachedTextDecoder.decode();
129
129
 
130
130
  function getStringFromWasm0(ptr, len) {
131
+ ptr = ptr >>> 0;
131
132
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
132
133
  }
133
134
 
@@ -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__h591085db9e83f904(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_55(arg0, arg1) {
238
+ wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h84dcb03881894fab(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__hf05c1ef7b6113485(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__hb0748eb214c10bca(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_221(arg0, arg1, arg2, arg3) {
326
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h0410428e43c38f3f(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,7 @@ 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);
676
687
  return takeObject(ret);
677
688
  }
678
689
  /**
@@ -680,7 +691,7 @@ export class Robot {
680
691
  * @returns {Promise<number>}
681
692
  */
682
693
  get_signal(index) {
683
- const ret = wasm.robot_get_signal(this.ptr, index);
694
+ const ret = wasm.robot_get_signal(this.__wbg_ptr, index);
684
695
  return takeObject(ret);
685
696
  }
686
697
  /**
@@ -689,7 +700,7 @@ export class Robot {
689
700
  * @returns {Promise<void>}
690
701
  */
691
702
  add_signal(index, value) {
692
- const ret = wasm.robot_add_signal(this.ptr, index, value);
703
+ const ret = wasm.robot_add_signal(this.__wbg_ptr, index, value);
693
704
  return takeObject(ret);
694
705
  }
695
706
  /**
@@ -705,7 +716,7 @@ export class Robot {
705
716
  const len0 = WASM_VECTOR_LEN;
706
717
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
707
718
  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);
719
+ 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);
709
720
  return takeObject(ret);
710
721
  }
711
722
  /**
@@ -713,7 +724,51 @@ export class Robot {
713
724
  * @returns {Promise<string>}
714
725
  */
715
726
  get_task_state(id) {
716
- const ret = wasm.robot_get_task_state(this.ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
727
+ const ret = wasm.robot_get_task_state(this.__wbg_ptr, !isLikeNone(id), isLikeNone(id) ? 0 : id);
728
+ return takeObject(ret);
729
+ }
730
+ /**
731
+ * @param {string} device
732
+ * @param {number} baud_rate
733
+ * @returns {Promise<void>}
734
+ */
735
+ set_serial_baud_rate(device, baud_rate) {
736
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
737
+ const len0 = WASM_VECTOR_LEN;
738
+ const ret = wasm.robot_set_serial_baud_rate(this.__wbg_ptr, ptr0, len0, baud_rate);
739
+ return takeObject(ret);
740
+ }
741
+ /**
742
+ * @param {string} device
743
+ * @param {any} parity
744
+ * @returns {Promise<void>}
745
+ */
746
+ set_serial_parity(device, parity) {
747
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
748
+ const len0 = WASM_VECTOR_LEN;
749
+ const ret = wasm.robot_set_serial_parity(this.__wbg_ptr, ptr0, len0, addHeapObject(parity));
750
+ return takeObject(ret);
751
+ }
752
+ /**
753
+ * @param {string} device
754
+ * @param {any} data
755
+ * @returns {Promise<void>}
756
+ */
757
+ write_serial(device, data) {
758
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
759
+ const len0 = WASM_VECTOR_LEN;
760
+ const ret = wasm.robot_write_serial(this.__wbg_ptr, ptr0, len0, addHeapObject(data));
761
+ return takeObject(ret);
762
+ }
763
+ /**
764
+ * @param {string} device
765
+ * @param {number} len
766
+ * @returns {Promise<any>}
767
+ */
768
+ read_serial(device, len) {
769
+ const ptr0 = passStringToWasm0(device, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
770
+ const len0 = WASM_VECTOR_LEN;
771
+ const ret = wasm.robot_read_serial(this.__wbg_ptr, ptr0, len0, len);
717
772
  return takeObject(ret);
718
773
  }
719
774
  /**
@@ -727,7 +782,7 @@ export class Robot {
727
782
  const len0 = WASM_VECTOR_LEN;
728
783
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
729
784
  const len1 = WASM_VECTOR_LEN;
730
- const ret = wasm.robot_write_single_coil(this.ptr, ptr0, len0, ptr1, len1, value);
785
+ const ret = wasm.robot_write_single_coil(this.__wbg_ptr, ptr0, len0, ptr1, len1, value);
731
786
  return takeObject(ret);
732
787
  }
733
788
  /**
@@ -741,7 +796,7 @@ export class Robot {
741
796
  const len0 = WASM_VECTOR_LEN;
742
797
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
743
798
  const len1 = WASM_VECTOR_LEN;
744
- const ret = wasm.robot_write_multiple_coils(this.ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
799
+ const ret = wasm.robot_write_multiple_coils(this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
745
800
  return takeObject(ret);
746
801
  }
747
802
  /**
@@ -755,7 +810,7 @@ export class Robot {
755
810
  const len0 = WASM_VECTOR_LEN;
756
811
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
757
812
  const len1 = WASM_VECTOR_LEN;
758
- const ret = wasm.robot_read_coils(this.ptr, ptr0, len0, ptr1, len1, count);
813
+ const ret = wasm.robot_read_coils(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
759
814
  return takeObject(ret);
760
815
  }
761
816
  /**
@@ -769,7 +824,7 @@ export class Robot {
769
824
  const len0 = WASM_VECTOR_LEN;
770
825
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
771
826
  const len1 = WASM_VECTOR_LEN;
772
- const ret = wasm.robot_read_discrete_inputs(this.ptr, ptr0, len0, ptr1, len1, count);
827
+ const ret = wasm.robot_read_discrete_inputs(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
773
828
  return takeObject(ret);
774
829
  }
775
830
  /**
@@ -783,7 +838,7 @@ export class Robot {
783
838
  const len0 = WASM_VECTOR_LEN;
784
839
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
785
840
  const len1 = WASM_VECTOR_LEN;
786
- const ret = wasm.robot_write_single_register(this.ptr, ptr0, len0, ptr1, len1, value);
841
+ const ret = wasm.robot_write_single_register(this.__wbg_ptr, ptr0, len0, ptr1, len1, value);
787
842
  return takeObject(ret);
788
843
  }
789
844
  /**
@@ -797,7 +852,7 @@ export class Robot {
797
852
  const len0 = WASM_VECTOR_LEN;
798
853
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
799
854
  const len1 = WASM_VECTOR_LEN;
800
- const ret = wasm.robot_write_multiple_registers(this.ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
855
+ const ret = wasm.robot_write_multiple_registers(this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(values));
801
856
  return takeObject(ret);
802
857
  }
803
858
  /**
@@ -811,7 +866,7 @@ export class Robot {
811
866
  const len0 = WASM_VECTOR_LEN;
812
867
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
813
868
  const len1 = WASM_VECTOR_LEN;
814
- const ret = wasm.robot_read_holding_registers(this.ptr, ptr0, len0, ptr1, len1, count);
869
+ const ret = wasm.robot_read_holding_registers(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
815
870
  return takeObject(ret);
816
871
  }
817
872
  /**
@@ -825,7 +880,7 @@ export class Robot {
825
880
  const len0 = WASM_VECTOR_LEN;
826
881
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
827
882
  const len1 = WASM_VECTOR_LEN;
828
- const ret = wasm.robot_read_input_registers(this.ptr, ptr0, len0, ptr1, len1, count);
883
+ const ret = wasm.robot_read_input_registers(this.__wbg_ptr, ptr0, len0, ptr1, len1, count);
829
884
  return takeObject(ret);
830
885
  }
831
886
  /**
@@ -834,14 +889,14 @@ export class Robot {
834
889
  * @returns {Promise<void>}
835
890
  */
836
891
  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);
892
+ const ret = wasm.robot_set_claw(this.__wbg_ptr, !isLikeNone(force), isLikeNone(force) ? 0 : force, !isLikeNone(amplitude), isLikeNone(amplitude) ? 0 : amplitude);
838
893
  return takeObject(ret);
839
894
  }
840
895
  /**
841
896
  * @returns {Promise<any>}
842
897
  */
843
898
  get_claw() {
844
- const ret = wasm.robot_get_claw(this.ptr);
899
+ const ret = wasm.robot_get_claw(this.__wbg_ptr);
845
900
  return takeObject(ret);
846
901
  }
847
902
  /**
@@ -854,7 +909,7 @@ export class Robot {
854
909
  const len0 = WASM_VECTOR_LEN;
855
910
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
856
911
  var len1 = WASM_VECTOR_LEN;
857
- const ret = wasm.robot_load_led_style(this.ptr, ptr0, len0, ptr1, len1);
912
+ const ret = wasm.robot_load_led_style(this.__wbg_ptr, ptr0, len0, ptr1, len1);
858
913
  return takeObject(ret);
859
914
  }
860
915
  /**
@@ -862,7 +917,7 @@ export class Robot {
862
917
  * @returns {Promise<void>}
863
918
  */
864
919
  set_led_style(style) {
865
- const ret = wasm.robot_set_led_style(this.ptr, addHeapObject(style));
920
+ const ret = wasm.robot_set_led_style(this.__wbg_ptr, addHeapObject(style));
866
921
  return takeObject(ret);
867
922
  }
868
923
  /**
@@ -874,7 +929,7 @@ export class Robot {
874
929
  set_led(mode, speed, colors) {
875
930
  const ptr0 = passArray32ToWasm0(colors, wasm.__wbindgen_malloc);
876
931
  const len0 = WASM_VECTOR_LEN;
877
- const ret = wasm.robot_set_led(this.ptr, mode, speed, ptr0, len0);
932
+ const ret = wasm.robot_set_led(this.__wbg_ptr, mode, speed, ptr0, len0);
878
933
  return takeObject(ret);
879
934
  }
880
935
  /**
@@ -883,7 +938,7 @@ export class Robot {
883
938
  * @returns {Promise<void>}
884
939
  */
885
940
  set_voice(voice, volume) {
886
- const ret = wasm.robot_set_voice(this.ptr, voice, volume);
941
+ const ret = wasm.robot_set_voice(this.__wbg_ptr, voice, volume);
887
942
  return takeObject(ret);
888
943
  }
889
944
  /**
@@ -891,49 +946,49 @@ export class Robot {
891
946
  * @returns {Promise<void>}
892
947
  */
893
948
  set_fan(mode) {
894
- const ret = wasm.robot_set_fan(this.ptr, mode);
949
+ const ret = wasm.robot_set_fan(this.__wbg_ptr, mode);
895
950
  return takeObject(ret);
896
951
  }
897
952
  /**
898
953
  * @returns {Promise<void>}
899
954
  */
900
955
  start_sys() {
901
- const ret = wasm.robot_start_sys(this.ptr);
956
+ const ret = wasm.robot_start_sys(this.__wbg_ptr);
902
957
  return takeObject(ret);
903
958
  }
904
959
  /**
905
960
  * @returns {Promise<void>}
906
961
  */
907
962
  stop_sys() {
908
- const ret = wasm.robot_stop_sys(this.ptr);
963
+ const ret = wasm.robot_stop_sys(this.__wbg_ptr);
909
964
  return takeObject(ret);
910
965
  }
911
966
  /**
912
967
  * @returns {Promise<void>}
913
968
  */
914
969
  powerdown() {
915
- const ret = wasm.robot_powerdown(this.ptr);
970
+ const ret = wasm.robot_powerdown(this.__wbg_ptr);
916
971
  return takeObject(ret);
917
972
  }
918
973
  /**
919
974
  * @returns {Promise<void>}
920
975
  */
921
976
  reboot() {
922
- const ret = wasm.robot_reboot(this.ptr);
977
+ const ret = wasm.robot_reboot(this.__wbg_ptr);
923
978
  return takeObject(ret);
924
979
  }
925
980
  /**
926
981
  * @returns {Promise<void>}
927
982
  */
928
983
  stop() {
929
- const ret = wasm.robot_stop(this.ptr);
984
+ const ret = wasm.robot_stop(this.__wbg_ptr);
930
985
  return takeObject(ret);
931
986
  }
932
987
  /**
933
988
  * @returns {Promise<void>}
934
989
  */
935
990
  estop() {
936
- const ret = wasm.robot_estop(this.ptr);
991
+ const ret = wasm.robot_estop(this.__wbg_ptr);
937
992
  return takeObject(ret);
938
993
  }
939
994
  /**
@@ -946,7 +1001,7 @@ export class Robot {
946
1001
  const len0 = WASM_VECTOR_LEN;
947
1002
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
948
1003
  var len1 = WASM_VECTOR_LEN;
949
- const ret = wasm.robot_load_tcp(this.ptr, ptr0, len0, ptr1, len1);
1004
+ const ret = wasm.robot_load_tcp(this.__wbg_ptr, ptr0, len0, ptr1, len1);
950
1005
  return takeObject(ret);
951
1006
  }
952
1007
  /**
@@ -954,14 +1009,14 @@ export class Robot {
954
1009
  * @returns {Promise<void>}
955
1010
  */
956
1011
  set_tcp(pose) {
957
- const ret = wasm.robot_set_tcp(this.ptr, addHeapObject(pose));
1012
+ const ret = wasm.robot_set_tcp(this.__wbg_ptr, addHeapObject(pose));
958
1013
  return takeObject(ret);
959
1014
  }
960
1015
  /**
961
1016
  * @returns {Promise<any>}
962
1017
  */
963
1018
  get_tcp() {
964
- const ret = wasm.robot_get_tcp(this.ptr);
1019
+ const ret = wasm.robot_get_tcp(this.__wbg_ptr);
965
1020
  return takeObject(ret);
966
1021
  }
967
1022
  /**
@@ -969,14 +1024,14 @@ export class Robot {
969
1024
  * @returns {Promise<void>}
970
1025
  */
971
1026
  set_velocity_factor(speed_factor) {
972
- const ret = wasm.robot_set_velocity_factor(this.ptr, speed_factor);
1027
+ const ret = wasm.robot_set_velocity_factor(this.__wbg_ptr, speed_factor);
973
1028
  return takeObject(ret);
974
1029
  }
975
1030
  /**
976
1031
  * @returns {Promise<number>}
977
1032
  */
978
1033
  get_velocity_factor() {
979
- const ret = wasm.robot_get_velocity_factor(this.ptr);
1034
+ const ret = wasm.robot_get_velocity_factor(this.__wbg_ptr);
980
1035
  return takeObject(ret);
981
1036
  }
982
1037
  /**
@@ -989,7 +1044,7 @@ export class Robot {
989
1044
  const len0 = WASM_VECTOR_LEN;
990
1045
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
991
1046
  var len1 = WASM_VECTOR_LEN;
992
- const ret = wasm.robot_load_payload(this.ptr, ptr0, len0, ptr1, len1);
1047
+ const ret = wasm.robot_load_payload(this.__wbg_ptr, ptr0, len0, ptr1, len1);
993
1048
  return takeObject(ret);
994
1049
  }
995
1050
  /**
@@ -998,14 +1053,14 @@ export class Robot {
998
1053
  * @returns {Promise<void>}
999
1054
  */
1000
1055
  set_payload(mass, cog) {
1001
- const ret = wasm.robot_set_payload(this.ptr, !isLikeNone(mass), isLikeNone(mass) ? 0 : mass, isLikeNone(cog) ? 0 : addHeapObject(cog));
1056
+ const ret = wasm.robot_set_payload(this.__wbg_ptr, !isLikeNone(mass), isLikeNone(mass) ? 0 : mass, isLikeNone(cog) ? 0 : addHeapObject(cog));
1002
1057
  return takeObject(ret);
1003
1058
  }
1004
1059
  /**
1005
1060
  * @returns {Promise<any>}
1006
1061
  */
1007
1062
  get_payload() {
1008
- const ret = wasm.robot_get_payload(this.ptr);
1063
+ const ret = wasm.robot_get_payload(this.__wbg_ptr);
1009
1064
  return takeObject(ret);
1010
1065
  }
1011
1066
  /**
@@ -1013,14 +1068,14 @@ export class Robot {
1013
1068
  * @returns {Promise<void>}
1014
1069
  */
1015
1070
  set_gravity(pose) {
1016
- const ret = wasm.robot_set_gravity(this.ptr, addHeapObject(pose));
1071
+ const ret = wasm.robot_set_gravity(this.__wbg_ptr, addHeapObject(pose));
1017
1072
  return takeObject(ret);
1018
1073
  }
1019
1074
  /**
1020
1075
  * @returns {Promise<any>}
1021
1076
  */
1022
1077
  get_gravity() {
1023
- const ret = wasm.robot_get_gravity(this.ptr);
1078
+ const ret = wasm.robot_get_gravity(this.__wbg_ptr);
1024
1079
  return takeObject(ret);
1025
1080
  }
1026
1081
  }
@@ -1029,15 +1084,16 @@ export class Robot {
1029
1084
  export class RobotSubscription {
1030
1085
 
1031
1086
  static __wrap(ptr) {
1087
+ ptr = ptr >>> 0;
1032
1088
  const obj = Object.create(RobotSubscription.prototype);
1033
- obj.ptr = ptr;
1089
+ obj.__wbg_ptr = ptr;
1034
1090
 
1035
1091
  return obj;
1036
1092
  }
1037
1093
 
1038
1094
  __destroy_into_raw() {
1039
- const ptr = this.ptr;
1040
- this.ptr = 0;
1095
+ const ptr = this.__wbg_ptr;
1096
+ this.__wbg_ptr = 0;
1041
1097
 
1042
1098
  return ptr;
1043
1099
  }
@@ -1050,7 +1106,7 @@ export class RobotSubscription {
1050
1106
  * @returns {Promise<string | undefined>}
1051
1107
  */
1052
1108
  next() {
1053
- const ret = wasm.robotsubscription_next(this.ptr);
1109
+ const ret = wasm.robotsubscription_next(this.__wbg_ptr);
1054
1110
  return takeObject(ret);
1055
1111
  }
1056
1112
  }
@@ -1059,25 +1115,11 @@ export function __wbindgen_object_drop_ref(arg0) {
1059
1115
  takeObject(arg0);
1060
1116
  };
1061
1117
 
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;
1076
- };
1077
-
1078
- export function __wbindgen_number_new(arg0) {
1079
- const ret = arg0;
1080
- return addHeapObject(ret);
1118
+ export function __wbindgen_number_get(arg0, arg1) {
1119
+ const obj = getObject(arg1);
1120
+ const ret = typeof(obj) === 'number' ? obj : undefined;
1121
+ getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
1122
+ getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
1081
1123
  };
1082
1124
 
1083
1125
  export function __wbindgen_boolean_get(arg0) {
@@ -1086,39 +1128,38 @@ export function __wbindgen_boolean_get(arg0) {
1086
1128
  return ret;
1087
1129
  };
1088
1130
 
1089
- export function __wbindgen_is_bigint(arg0) {
1090
- const ret = typeof(getObject(arg0)) === 'bigint';
1091
- return ret;
1131
+ export function __wbindgen_string_get(arg0, arg1) {
1132
+ const obj = getObject(arg1);
1133
+ const ret = typeof(obj) === 'string' ? obj : undefined;
1134
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1135
+ var len1 = WASM_VECTOR_LEN;
1136
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
1137
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
1092
1138
  };
1093
1139
 
1094
- export function __wbindgen_bigint_from_i64(arg0) {
1140
+ export function __wbindgen_number_new(arg0) {
1095
1141
  const ret = arg0;
1096
1142
  return addHeapObject(ret);
1097
1143
  };
1098
1144
 
1099
- export function __wbindgen_jsval_eq(arg0, arg1) {
1100
- const ret = getObject(arg0) === getObject(arg1);
1101
- return ret;
1145
+ export function __wbg_robotsubscription_new(arg0) {
1146
+ const ret = RobotSubscription.__wrap(arg0);
1147
+ return addHeapObject(ret);
1102
1148
  };
1103
1149
 
1104
- export function __wbindgen_number_get(arg0, arg1) {
1105
- const obj = getObject(arg1);
1106
- const ret = typeof(obj) === 'number' ? obj : undefined;
1107
- getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
1108
- getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
1150
+ export function __wbg_robot_new(arg0) {
1151
+ const ret = Robot.__wrap(arg0);
1152
+ return addHeapObject(ret);
1109
1153
  };
1110
1154
 
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;
1155
+ export function __wbindgen_is_object(arg0) {
1156
+ const val = getObject(arg0);
1157
+ const ret = typeof(val) === 'object' && val !== null;
1158
+ return ret;
1118
1159
  };
1119
1160
 
1120
- export function __wbindgen_bigint_from_u64(arg0) {
1121
- const ret = BigInt.asUintN(64, arg0);
1161
+ export function __wbindgen_string_new(arg0, arg1) {
1162
+ const ret = getStringFromWasm0(arg0, arg1);
1122
1163
  return addHeapObject(ret);
1123
1164
  };
1124
1165
 
@@ -1132,18 +1173,33 @@ export function __wbindgen_cb_drop(arg0) {
1132
1173
  return ret;
1133
1174
  };
1134
1175
 
1135
- export function __wbindgen_string_new(arg0, arg1) {
1136
- const ret = getStringFromWasm0(arg0, arg1);
1137
- return addHeapObject(ret);
1176
+ export function __wbindgen_is_undefined(arg0) {
1177
+ const ret = getObject(arg0) === undefined;
1178
+ return ret;
1138
1179
  };
1139
1180
 
1140
- export function __wbg_robot_new(arg0) {
1141
- const ret = Robot.__wrap(arg0);
1181
+ export function __wbindgen_in(arg0, arg1) {
1182
+ const ret = getObject(arg0) in getObject(arg1);
1183
+ return ret;
1184
+ };
1185
+
1186
+ export function __wbindgen_is_bigint(arg0) {
1187
+ const ret = typeof(getObject(arg0)) === 'bigint';
1188
+ return ret;
1189
+ };
1190
+
1191
+ export function __wbindgen_bigint_from_i64(arg0) {
1192
+ const ret = arg0;
1142
1193
  return addHeapObject(ret);
1143
1194
  };
1144
1195
 
1145
- export function __wbg_robotsubscription_new(arg0) {
1146
- const ret = RobotSubscription.__wrap(arg0);
1196
+ export function __wbindgen_jsval_eq(arg0, arg1) {
1197
+ const ret = getObject(arg0) === getObject(arg1);
1198
+ return ret;
1199
+ };
1200
+
1201
+ export function __wbindgen_bigint_from_u64(arg0) {
1202
+ const ret = BigInt.asUintN(64, arg0);
1147
1203
  return addHeapObject(ret);
1148
1204
  };
1149
1205
 
@@ -1162,73 +1218,73 @@ export function __wbindgen_object_clone_ref(arg0) {
1162
1218
  return addHeapObject(ret);
1163
1219
  };
1164
1220
 
1165
- export function __wbg_addEventListener_615d4590d38da1c9() { return handleError(function (arg0, arg1, arg2, arg3) {
1221
+ export function __wbg_addEventListener_d25d1ffe6c69ae96() { return handleError(function (arg0, arg1, arg2, arg3) {
1166
1222
  getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
1167
1223
  }, arguments) };
1168
1224
 
1169
- export function __wbg_addEventListener_cf5b03cd29763277() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
1225
+ export function __wbg_addEventListener_3a7d7c4177ce91d1() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
1170
1226
  getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
1171
1227
  }, arguments) };
1172
1228
 
1173
- export function __wbg_dispatchEvent_615d1ccbba577081() { return handleError(function (arg0, arg1) {
1229
+ export function __wbg_dispatchEvent_cfc38228a531c8c8() { return handleError(function (arg0, arg1) {
1174
1230
  const ret = getObject(arg0).dispatchEvent(getObject(arg1));
1175
1231
  return ret;
1176
1232
  }, arguments) };
1177
1233
 
1178
- export function __wbg_removeEventListener_86fd19ed073cd1ed() { return handleError(function (arg0, arg1, arg2, arg3) {
1234
+ export function __wbg_removeEventListener_7a381df5fdb6037f() { return handleError(function (arg0, arg1, arg2, arg3) {
1179
1235
  getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
1180
1236
  }, arguments) };
1181
1237
 
1182
- export function __wbg_wasClean_17e8b22af0b82315(arg0) {
1238
+ export function __wbg_wasClean_133b4529d739de9e(arg0) {
1183
1239
  const ret = getObject(arg0).wasClean;
1184
1240
  return ret;
1185
1241
  };
1186
1242
 
1187
- export function __wbg_code_9743a5678b87b9e9(arg0) {
1243
+ export function __wbg_code_5921daf18e5a3378(arg0) {
1188
1244
  const ret = getObject(arg0).code;
1189
1245
  return ret;
1190
1246
  };
1191
1247
 
1192
- export function __wbg_reason_8585c102803c11b5(arg0, arg1) {
1248
+ export function __wbg_reason_c07db343645d6e25(arg0, arg1) {
1193
1249
  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;
1250
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1251
+ const len1 = WASM_VECTOR_LEN;
1252
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
1253
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
1198
1254
  };
1199
1255
 
1200
- export function __wbg_newwitheventinitdict_0e8e2070ae66ce38() { return handleError(function (arg0, arg1, arg2) {
1256
+ export function __wbg_newwitheventinitdict_6b770a22a3426955() { return handleError(function (arg0, arg1, arg2) {
1201
1257
  const ret = new CloseEvent(getStringFromWasm0(arg0, arg1), getObject(arg2));
1202
1258
  return addHeapObject(ret);
1203
1259
  }, arguments) };
1204
1260
 
1205
- export function __wbg_readyState_b3671943d2cedc2b(arg0) {
1261
+ export function __wbg_readyState_ad4a43cf245ed346(arg0) {
1206
1262
  const ret = getObject(arg0).readyState;
1207
1263
  return ret;
1208
1264
  };
1209
1265
 
1210
- export function __wbg_setbinaryType_c9b2fa398c277601(arg0, arg1) {
1266
+ export function __wbg_setbinaryType_912a58ff49a07245(arg0, arg1) {
1211
1267
  getObject(arg0).binaryType = takeObject(arg1);
1212
1268
  };
1213
1269
 
1214
- export function __wbg_new_8ad026ef33da9ab1() { return handleError(function (arg0, arg1) {
1270
+ export function __wbg_new_c70a4fdc1ed8f3bb() { return handleError(function (arg0, arg1) {
1215
1271
  const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
1216
1272
  return addHeapObject(ret);
1217
1273
  }, arguments) };
1218
1274
 
1219
- export function __wbg_close_546591d4b4350b36() { return handleError(function (arg0) {
1275
+ export function __wbg_close_b57426e46b2cde05() { return handleError(function (arg0) {
1220
1276
  getObject(arg0).close();
1221
1277
  }, arguments) };
1222
1278
 
1223
- export function __wbg_send_36f8bcb566f8afa0() { return handleError(function (arg0, arg1, arg2) {
1279
+ export function __wbg_send_1cc5e505b0cbc15c() { return handleError(function (arg0, arg1, arg2) {
1224
1280
  getObject(arg0).send(getStringFromWasm0(arg1, arg2));
1225
1281
  }, arguments) };
1226
1282
 
1227
- export function __wbg_send_c1c0838681688262() { return handleError(function (arg0, arg1, arg2) {
1283
+ export function __wbg_send_43a6924260160efb() { return handleError(function (arg0, arg1, arg2) {
1228
1284
  getObject(arg0).send(getArrayU8FromWasm0(arg1, arg2));
1229
1285
  }, arguments) };
1230
1286
 
1231
- export function __wbg_data_af909e5dfe73e68c(arg0) {
1287
+ export function __wbg_data_338d13609f6165a6(arg0) {
1232
1288
  const ret = getObject(arg0).data;
1233
1289
  return addHeapObject(ret);
1234
1290
  };
@@ -1257,17 +1313,17 @@ export function __wbg_set_841ac57cff3d672b(arg0, arg1, arg2) {
1257
1313
  getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
1258
1314
  };
1259
1315
 
1260
- export function __wbg_get_27fe3dac1c4d0224(arg0, arg1) {
1316
+ export function __wbg_get_7303ed2ef026b2f5(arg0, arg1) {
1261
1317
  const ret = getObject(arg0)[arg1 >>> 0];
1262
1318
  return addHeapObject(ret);
1263
1319
  };
1264
1320
 
1265
- export function __wbg_length_e498fbc24f9c1d4f(arg0) {
1321
+ export function __wbg_length_820c786973abdd8a(arg0) {
1266
1322
  const ret = getObject(arg0).length;
1267
1323
  return ret;
1268
1324
  };
1269
1325
 
1270
- export function __wbg_new_b525de17f44a8943() {
1326
+ export function __wbg_new_0394642eae39db16() {
1271
1327
  const ret = new Array();
1272
1328
  return addHeapObject(ret);
1273
1329
  };
@@ -1277,56 +1333,56 @@ export function __wbindgen_is_function(arg0) {
1277
1333
  return ret;
1278
1334
  };
1279
1335
 
1280
- export function __wbg_next_b7d530c04fd8b217(arg0) {
1336
+ export function __wbg_next_f4bc0e96ea67da68(arg0) {
1281
1337
  const ret = getObject(arg0).next;
1282
1338
  return addHeapObject(ret);
1283
1339
  };
1284
1340
 
1285
- export function __wbg_next_88560ec06a094dea() { return handleError(function (arg0) {
1341
+ export function __wbg_next_ec061e48a0e72a96() { return handleError(function (arg0) {
1286
1342
  const ret = getObject(arg0).next();
1287
1343
  return addHeapObject(ret);
1288
1344
  }, arguments) };
1289
1345
 
1290
- export function __wbg_done_1ebec03bbd919843(arg0) {
1346
+ export function __wbg_done_b6abb27d42b63867(arg0) {
1291
1347
  const ret = getObject(arg0).done;
1292
1348
  return ret;
1293
1349
  };
1294
1350
 
1295
- export function __wbg_value_6ac8da5cc5b3efda(arg0) {
1351
+ export function __wbg_value_2f4ef2036bfad28e(arg0) {
1296
1352
  const ret = getObject(arg0).value;
1297
1353
  return addHeapObject(ret);
1298
1354
  };
1299
1355
 
1300
- export function __wbg_iterator_55f114446221aa5a() {
1356
+ export function __wbg_iterator_7c7e58f62eb84700() {
1301
1357
  const ret = Symbol.iterator;
1302
1358
  return addHeapObject(ret);
1303
1359
  };
1304
1360
 
1305
- export function __wbg_get_baf4855f9a986186() { return handleError(function (arg0, arg1) {
1361
+ export function __wbg_get_f53c921291c381bd() { return handleError(function (arg0, arg1) {
1306
1362
  const ret = Reflect.get(getObject(arg0), getObject(arg1));
1307
1363
  return addHeapObject(ret);
1308
1364
  }, arguments) };
1309
1365
 
1310
- export function __wbg_call_95d1ea488d03e4e8() { return handleError(function (arg0, arg1) {
1366
+ export function __wbg_call_557a2f2deacc4912() { return handleError(function (arg0, arg1) {
1311
1367
  const ret = getObject(arg0).call(getObject(arg1));
1312
1368
  return addHeapObject(ret);
1313
1369
  }, arguments) };
1314
1370
 
1315
- export function __wbg_new_f9876326328f45ed() {
1371
+ export function __wbg_new_2b6fea4ea03b1b95() {
1316
1372
  const ret = new Object();
1317
1373
  return addHeapObject(ret);
1318
1374
  };
1319
1375
 
1320
- export function __wbg_set_17224bc548dd1d7b(arg0, arg1, arg2) {
1376
+ export function __wbg_set_b4da98d504ac6091(arg0, arg1, arg2) {
1321
1377
  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1322
1378
  };
1323
1379
 
1324
- export function __wbg_isArray_39d28997bf6b96b4(arg0) {
1380
+ export function __wbg_isArray_04e59fb73f78ab5b(arg0) {
1325
1381
  const ret = Array.isArray(getObject(arg0));
1326
1382
  return ret;
1327
1383
  };
1328
1384
 
1329
- export function __wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065(arg0) {
1385
+ export function __wbg_instanceof_ArrayBuffer_ef2632aa0d4bfff8(arg0) {
1330
1386
  let result;
1331
1387
  try {
1332
1388
  result = getObject(arg0) instanceof ArrayBuffer;
@@ -1337,7 +1393,7 @@ export function __wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065(arg0) {
1337
1393
  return ret;
1338
1394
  };
1339
1395
 
1340
- export function __wbg_instanceof_Error_749a7378f4439ee0(arg0) {
1396
+ export function __wbg_instanceof_Error_fac23a8832b241da(arg0) {
1341
1397
  let result;
1342
1398
  try {
1343
1399
  result = getObject(arg0) instanceof Error;
@@ -1348,44 +1404,44 @@ export function __wbg_instanceof_Error_749a7378f4439ee0(arg0) {
1348
1404
  return ret;
1349
1405
  };
1350
1406
 
1351
- export function __wbg_message_a95c3ef248e4b57a(arg0) {
1407
+ export function __wbg_message_eab7d45ec69a2135(arg0) {
1352
1408
  const ret = getObject(arg0).message;
1353
1409
  return addHeapObject(ret);
1354
1410
  };
1355
1411
 
1356
- export function __wbg_name_c69a20c4b1197dc0(arg0) {
1412
+ export function __wbg_name_8e6176d4db1a502d(arg0) {
1357
1413
  const ret = getObject(arg0).name;
1358
1414
  return addHeapObject(ret);
1359
1415
  };
1360
1416
 
1361
- export function __wbg_toString_cec163b212643722(arg0) {
1417
+ export function __wbg_toString_506566b763774a16(arg0) {
1362
1418
  const ret = getObject(arg0).toString();
1363
1419
  return addHeapObject(ret);
1364
1420
  };
1365
1421
 
1366
- export function __wbg_call_9495de66fdbe016b() { return handleError(function (arg0, arg1, arg2) {
1422
+ export function __wbg_call_587b30eea3e09332() { return handleError(function (arg0, arg1, arg2) {
1367
1423
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
1368
1424
  return addHeapObject(ret);
1369
1425
  }, arguments) };
1370
1426
 
1371
- export function __wbg_isSafeInteger_8c4789029e885159(arg0) {
1427
+ export function __wbg_isSafeInteger_2088b01008075470(arg0) {
1372
1428
  const ret = Number.isSafeInteger(getObject(arg0));
1373
1429
  return ret;
1374
1430
  };
1375
1431
 
1376
- export function __wbg_entries_4e1315b774245952(arg0) {
1432
+ export function __wbg_entries_13e011453776468f(arg0) {
1377
1433
  const ret = Object.entries(getObject(arg0));
1378
1434
  return addHeapObject(ret);
1379
1435
  };
1380
1436
 
1381
- export function __wbg_new_9d3a9ce4282a18a8(arg0, arg1) {
1437
+ export function __wbg_new_2b55e405e4af4986(arg0, arg1) {
1382
1438
  try {
1383
1439
  var state0 = {a: arg0, b: arg1};
1384
1440
  var cb0 = (arg0, arg1) => {
1385
1441
  const a = state0.a;
1386
1442
  state0.a = 0;
1387
1443
  try {
1388
- return __wbg_adapter_217(a, state0.b, arg0, arg1);
1444
+ return __wbg_adapter_221(a, state0.b, arg0, arg1);
1389
1445
  } finally {
1390
1446
  state0.a = a;
1391
1447
  }
@@ -1397,36 +1453,36 @@ export function __wbg_new_9d3a9ce4282a18a8(arg0, arg1) {
1397
1453
  }
1398
1454
  };
1399
1455
 
1400
- export function __wbg_resolve_fd40f858d9db1a04(arg0) {
1456
+ export function __wbg_resolve_ae38ad63c43ff98b(arg0) {
1401
1457
  const ret = Promise.resolve(getObject(arg0));
1402
1458
  return addHeapObject(ret);
1403
1459
  };
1404
1460
 
1405
- export function __wbg_then_ec5db6d509eb475f(arg0, arg1) {
1461
+ export function __wbg_then_8df675b8bb5d5e3c(arg0, arg1) {
1406
1462
  const ret = getObject(arg0).then(getObject(arg1));
1407
1463
  return addHeapObject(ret);
1408
1464
  };
1409
1465
 
1410
- export function __wbg_buffer_cf65c07de34b9a08(arg0) {
1466
+ export function __wbg_buffer_55ba7a6b1b92e2ac(arg0) {
1411
1467
  const ret = getObject(arg0).buffer;
1412
1468
  return addHeapObject(ret);
1413
1469
  };
1414
1470
 
1415
- export function __wbg_new_537b7341ce90bb31(arg0) {
1471
+ export function __wbg_new_09938a7d020f049b(arg0) {
1416
1472
  const ret = new Uint8Array(getObject(arg0));
1417
1473
  return addHeapObject(ret);
1418
1474
  };
1419
1475
 
1420
- export function __wbg_set_17499e8aa4003ebd(arg0, arg1, arg2) {
1476
+ export function __wbg_set_3698e3ca519b3c3c(arg0, arg1, arg2) {
1421
1477
  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
1422
1478
  };
1423
1479
 
1424
- export function __wbg_length_27a2afe8ab42b09f(arg0) {
1480
+ export function __wbg_length_0aab7ffd65ad19ed(arg0) {
1425
1481
  const ret = getObject(arg0).length;
1426
1482
  return ret;
1427
1483
  };
1428
1484
 
1429
- export function __wbg_instanceof_Uint8Array_01cebe79ca606cca(arg0) {
1485
+ export function __wbg_instanceof_Uint8Array_1349640af2da2e88(arg0) {
1430
1486
  let result;
1431
1487
  try {
1432
1488
  result = getObject(arg0) instanceof Uint8Array;
@@ -1437,7 +1493,7 @@ export function __wbg_instanceof_Uint8Array_01cebe79ca606cca(arg0) {
1437
1493
  return ret;
1438
1494
  };
1439
1495
 
1440
- export function __wbg_set_6aa458a4ebdb65cb() { return handleError(function (arg0, arg1, arg2) {
1496
+ export function __wbg_set_07da13cc24b69217() { return handleError(function (arg0, arg1, arg2) {
1441
1497
  const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1442
1498
  return ret;
1443
1499
  }, arguments) };
@@ -1451,10 +1507,10 @@ export function __wbindgen_bigint_get_as_i64(arg0, arg1) {
1451
1507
 
1452
1508
  export function __wbindgen_debug_string(arg0, arg1) {
1453
1509
  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;
1510
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1511
+ const len1 = WASM_VECTOR_LEN;
1512
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
1513
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
1458
1514
  };
1459
1515
 
1460
1516
  export function __wbindgen_throw(arg0, arg1) {
@@ -1466,33 +1522,33 @@ export function __wbindgen_memory() {
1466
1522
  return addHeapObject(ret);
1467
1523
  };
1468
1524
 
1469
- export function __wbindgen_closure_wrapper1504(arg0, arg1, arg2) {
1470
- const ret = makeMutClosure(arg0, arg1, 570, __wbg_adapter_48);
1525
+ export function __wbindgen_closure_wrapper1552(arg0, arg1, arg2) {
1526
+ const ret = makeMutClosure(arg0, arg1, 588, __wbg_adapter_48);
1471
1527
  return addHeapObject(ret);
1472
1528
  };
1473
1529
 
1474
- export function __wbindgen_closure_wrapper1506(arg0, arg1, arg2) {
1475
- const ret = makeMutClosure(arg0, arg1, 570, __wbg_adapter_51);
1530
+ export function __wbindgen_closure_wrapper1554(arg0, arg1, arg2) {
1531
+ const ret = makeMutClosure(arg0, arg1, 588, __wbg_adapter_48);
1476
1532
  return addHeapObject(ret);
1477
1533
  };
1478
1534
 
1479
- export function __wbindgen_closure_wrapper1508(arg0, arg1, arg2) {
1480
- const ret = makeMutClosure(arg0, arg1, 570, __wbg_adapter_51);
1535
+ export function __wbindgen_closure_wrapper1556(arg0, arg1, arg2) {
1536
+ const ret = makeMutClosure(arg0, arg1, 588, __wbg_adapter_48);
1481
1537
  return addHeapObject(ret);
1482
1538
  };
1483
1539
 
1484
- export function __wbindgen_closure_wrapper1510(arg0, arg1, arg2) {
1485
- const ret = makeMutClosure(arg0, arg1, 570, __wbg_adapter_51);
1540
+ export function __wbindgen_closure_wrapper1558(arg0, arg1, arg2) {
1541
+ const ret = makeMutClosure(arg0, arg1, 588, __wbg_adapter_55);
1486
1542
  return addHeapObject(ret);
1487
1543
  };
1488
1544
 
1489
- export function __wbindgen_closure_wrapper1989(arg0, arg1, arg2) {
1490
- const ret = makeMutClosure(arg0, arg1, 664, __wbg_adapter_58);
1545
+ export function __wbindgen_closure_wrapper2026(arg0, arg1, arg2) {
1546
+ const ret = makeMutClosure(arg0, arg1, 663, __wbg_adapter_58);
1491
1547
  return addHeapObject(ret);
1492
1548
  };
1493
1549
 
1494
- export function __wbindgen_closure_wrapper2023(arg0, arg1, arg2) {
1495
- const ret = makeMutClosure(arg0, arg1, 678, __wbg_adapter_61);
1550
+ export function __wbindgen_closure_wrapper2061(arg0, arg1, arg2) {
1551
+ const ret = makeMutClosure(arg0, arg1, 677, __wbg_adapter_61);
1496
1552
  return addHeapObject(ret);
1497
1553
  };
1498
1554