lebai_sdk 0.1.7 → 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
@@ -78,14 +78,14 @@ function passStringToWasm0(arg, malloc, realloc) {
78
78
 
79
79
  if (realloc === undefined) {
80
80
  const buf = cachedTextEncoder.encode(arg);
81
- const ptr = malloc(buf.length);
81
+ const ptr = malloc(buf.length) >>> 0;
82
82
  getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
83
83
  WASM_VECTOR_LEN = buf.length;
84
84
  return ptr;
85
85
  }
86
86
 
87
87
  let len = arg.length;
88
- let ptr = malloc(len);
88
+ let ptr = malloc(len) >>> 0;
89
89
 
90
90
  const mem = getUint8Memory0();
91
91
 
@@ -101,7 +101,7 @@ function passStringToWasm0(arg, malloc, realloc) {
101
101
  if (offset !== 0) {
102
102
  arg = arg.slice(offset);
103
103
  }
104
- ptr = realloc(ptr, len, len = offset + arg.length * 3);
104
+ ptr = realloc(ptr, len, len = offset + arg.length * 3) >>> 0;
105
105
  const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
106
106
  const ret = encodeString(arg, view);
107
107
 
@@ -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
 
@@ -230,19 +231,19 @@ function makeMutClosure(arg0, arg1, dtor, f) {
230
231
  return real;
231
232
  }
232
233
  function __wbg_adapter_48(arg0, arg1, arg2) {
233
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h0c510e469e54a267(arg0, arg1, addHeapObject(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
237
  function __wbg_adapter_55(arg0, arg1) {
237
- wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hf364facd27a3f442(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__h2f7f6052cd504365(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__hd957d0ddc4719c47(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;
@@ -281,54 +282,12 @@ export function discover_devices(time) {
281
282
  return takeObject(ret);
282
283
  }
283
284
 
284
- /**
285
- * @param {bigint} ms
286
- * @returns {Promise<void>}
287
- */
288
- export function sleep_ms(ms) {
289
- const ret = wasm.sleep_ms(ms);
290
- return takeObject(ret);
291
- }
292
-
293
- /**
294
- * @returns {bigint}
295
- */
296
- export function timestamp() {
297
- try {
298
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
299
- wasm.timestamp(retptr);
300
- var r0 = getBigInt64Memory0()[retptr / 8 + 0];
301
- var r2 = getInt32Memory0()[retptr / 4 + 2];
302
- var r3 = getInt32Memory0()[retptr / 4 + 3];
303
- if (r3) {
304
- throw takeObject(r2);
305
- }
306
- return BigInt.asUintN(64, r0);
307
- } finally {
308
- wasm.__wbindgen_add_to_stack_pointer(16);
309
- }
310
- }
311
-
312
- /**
313
- */
314
- export function init() {
315
- try {
316
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
317
- wasm.init(retptr);
318
- var r0 = getInt32Memory0()[retptr / 4 + 0];
319
- var r1 = getInt32Memory0()[retptr / 4 + 1];
320
- if (r1) {
321
- throw takeObject(r0);
322
- }
323
- } finally {
324
- wasm.__wbindgen_add_to_stack_pointer(16);
325
- }
326
- }
327
-
328
285
  /**
329
286
  * @returns {string}
330
287
  */
331
288
  export function version() {
289
+ let deferred2_0;
290
+ let deferred2_1;
332
291
  try {
333
292
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
334
293
  wasm.version(retptr);
@@ -336,16 +295,18 @@ export function version() {
336
295
  var r1 = getInt32Memory0()[retptr / 4 + 1];
337
296
  var r2 = getInt32Memory0()[retptr / 4 + 2];
338
297
  var r3 = getInt32Memory0()[retptr / 4 + 3];
339
- var ptr0 = r0;
340
- var len0 = r1;
298
+ var ptr1 = r0;
299
+ var len1 = r1;
341
300
  if (r3) {
342
- ptr0 = 0; len0 = 0;
301
+ ptr1 = 0; len1 = 0;
343
302
  throw takeObject(r2);
344
303
  }
345
- return getStringFromWasm0(ptr0, len0);
304
+ deferred2_0 = ptr1;
305
+ deferred2_1 = len1;
306
+ return getStringFromWasm0(ptr1, len1);
346
307
  } finally {
347
308
  wasm.__wbindgen_add_to_stack_pointer(16);
348
- wasm.__wbindgen_free(ptr0, len0);
309
+ wasm.__wbindgen_free(deferred2_0, deferred2_1);
349
310
  }
350
311
  }
351
312
 
@@ -358,10 +319,11 @@ function handleError(f, args) {
358
319
  }
359
320
 
360
321
  function getArrayU8FromWasm0(ptr, len) {
322
+ ptr = ptr >>> 0;
361
323
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
362
324
  }
363
- function __wbg_adapter_220(arg0, arg1, arg2, arg3) {
364
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h1f4070fd0aa7ef09(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));
365
327
  }
366
328
 
367
329
  /**
@@ -369,15 +331,16 @@ function __wbg_adapter_220(arg0, arg1, arg2, arg3) {
369
331
  export class Robot {
370
332
 
371
333
  static __wrap(ptr) {
334
+ ptr = ptr >>> 0;
372
335
  const obj = Object.create(Robot.prototype);
373
- obj.ptr = ptr;
336
+ obj.__wbg_ptr = ptr;
374
337
 
375
338
  return obj;
376
339
  }
377
340
 
378
341
  __destroy_into_raw() {
379
- const ptr = this.ptr;
380
- this.ptr = 0;
342
+ const ptr = this.__wbg_ptr;
343
+ this.__wbg_ptr = 0;
381
344
 
382
345
  return ptr;
383
346
  }
@@ -396,7 +359,7 @@ export class Robot {
396
359
  const len0 = WASM_VECTOR_LEN;
397
360
  var ptr1 = isLikeNone(param) ? 0 : passStringToWasm0(param, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
398
361
  var len1 = WASM_VECTOR_LEN;
399
- const ret = wasm.robot_call(this.ptr, ptr0, len0, ptr1, len1);
362
+ const ret = wasm.robot_call(this.__wbg_ptr, ptr0, len0, ptr1, len1);
400
363
  return takeObject(ret);
401
364
  }
402
365
  /**
@@ -409,7 +372,7 @@ export class Robot {
409
372
  const len0 = WASM_VECTOR_LEN;
410
373
  var ptr1 = isLikeNone(param) ? 0 : passStringToWasm0(param, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
411
374
  var len1 = WASM_VECTOR_LEN;
412
- const ret = wasm.robot_subscribe(this.ptr, ptr0, len0, ptr1, len1);
375
+ const ret = wasm.robot_subscribe(this.__wbg_ptr, ptr0, len0, ptr1, len1);
413
376
  return takeObject(ret);
414
377
  }
415
378
  /**
@@ -417,7 +380,7 @@ export class Robot {
417
380
  * @returns {Promise<any>}
418
381
  */
419
382
  kinematics_forward(p) {
420
- const ret = wasm.robot_kinematics_forward(this.ptr, addHeapObject(p));
383
+ const ret = wasm.robot_kinematics_forward(this.__wbg_ptr, addHeapObject(p));
421
384
  return takeObject(ret);
422
385
  }
423
386
  /**
@@ -426,7 +389,7 @@ export class Robot {
426
389
  * @returns {Promise<any>}
427
390
  */
428
391
  kinematics_inverse(p, refer) {
429
- 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));
430
393
  return takeObject(ret);
431
394
  }
432
395
  /**
@@ -435,7 +398,7 @@ export class Robot {
435
398
  * @returns {Promise<any>}
436
399
  */
437
400
  pose_trans(from, to) {
438
- 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));
439
402
  return takeObject(ret);
440
403
  }
441
404
  /**
@@ -445,7 +408,7 @@ export class Robot {
445
408
  * @returns {Promise<any>}
446
409
  */
447
410
  pose_add(pose, frame, delta) {
448
- 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));
449
412
  return takeObject(ret);
450
413
  }
451
414
  /**
@@ -453,7 +416,7 @@ export class Robot {
453
416
  * @returns {Promise<any>}
454
417
  */
455
418
  pose_inverse(p) {
456
- const ret = wasm.robot_pose_inverse(this.ptr, addHeapObject(p));
419
+ const ret = wasm.robot_pose_inverse(this.__wbg_ptr, addHeapObject(p));
457
420
  return takeObject(ret);
458
421
  }
459
422
  /**
@@ -466,7 +429,7 @@ export class Robot {
466
429
  const len0 = WASM_VECTOR_LEN;
467
430
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
468
431
  var len1 = WASM_VECTOR_LEN;
469
- 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);
470
433
  return takeObject(ret);
471
434
  }
472
435
  /**
@@ -479,14 +442,14 @@ export class Robot {
479
442
  const len0 = WASM_VECTOR_LEN;
480
443
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
481
444
  var len1 = WASM_VECTOR_LEN;
482
- 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);
483
446
  return takeObject(ret);
484
447
  }
485
448
  /**
486
449
  * @returns {Promise<void>}
487
450
  */
488
451
  stop_move() {
489
- const ret = wasm.robot_stop_move(this.ptr);
452
+ const ret = wasm.robot_stop_move(this.__wbg_ptr);
490
453
  return takeObject(ret);
491
454
  }
492
455
  /**
@@ -494,14 +457,14 @@ export class Robot {
494
457
  * @returns {Promise<void>}
495
458
  */
496
459
  wait_move(id) {
497
- 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);
498
461
  return takeObject(ret);
499
462
  }
500
463
  /**
501
464
  * @returns {Promise<number>}
502
465
  */
503
466
  get_running_motion() {
504
- const ret = wasm.robot_get_running_motion(this.ptr);
467
+ const ret = wasm.robot_get_running_motion(this.__wbg_ptr);
505
468
  return takeObject(ret);
506
469
  }
507
470
  /**
@@ -509,43 +472,43 @@ export class Robot {
509
472
  * @returns {Promise<string>}
510
473
  */
511
474
  get_motion_state(id) {
512
- const ret = wasm.robot_get_motion_state(this.ptr, id);
475
+ const ret = wasm.robot_get_motion_state(this.__wbg_ptr, id);
513
476
  return takeObject(ret);
514
477
  }
515
478
  /**
516
479
  * @param {any} p
517
480
  * @param {number} a
518
481
  * @param {number} v
519
- * @param {number} t
482
+ * @param {number | undefined} t
520
483
  * @param {number | undefined} r
521
484
  * @returns {Promise<number>}
522
485
  */
523
486
  towardj(p, a, v, t, r) {
524
- 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);
525
488
  return takeObject(ret);
526
489
  }
527
490
  /**
528
491
  * @param {any} p
529
492
  * @param {number} a
530
493
  * @param {number} v
531
- * @param {number} t
494
+ * @param {number | undefined} t
532
495
  * @param {number | undefined} r
533
496
  * @returns {Promise<number>}
534
497
  */
535
498
  movej(p, a, v, t, r) {
536
- 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);
537
500
  return takeObject(ret);
538
501
  }
539
502
  /**
540
503
  * @param {any} p
541
504
  * @param {number} a
542
505
  * @param {number} v
543
- * @param {number} t
506
+ * @param {number | undefined} t
544
507
  * @param {number | undefined} r
545
508
  * @returns {Promise<number>}
546
509
  */
547
510
  movel(p, a, v, t, r) {
548
- 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);
549
512
  return takeObject(ret);
550
513
  }
551
514
  /**
@@ -554,12 +517,12 @@ export class Robot {
554
517
  * @param {number} rad
555
518
  * @param {number} a
556
519
  * @param {number} v
557
- * @param {number} t
520
+ * @param {number | undefined} t
558
521
  * @param {number | undefined} r
559
522
  * @returns {Promise<number>}
560
523
  */
561
524
  movec(via, p, rad, a, v, t, r) {
562
- 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);
563
526
  return takeObject(ret);
564
527
  }
565
528
  /**
@@ -569,7 +532,7 @@ export class Robot {
569
532
  * @returns {Promise<void>}
570
533
  */
571
534
  move_pvt(p, v, t) {
572
- 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);
573
536
  return takeObject(ret);
574
537
  }
575
538
  /**
@@ -580,38 +543,42 @@ export class Robot {
580
543
  * @returns {Promise<void>}
581
544
  */
582
545
  move_pvat(p, v, a, t) {
583
- 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);
584
547
  return takeObject(ret);
585
548
  }
586
549
  /**
550
+ * @param {number} a
587
551
  * @param {any} v
588
- * @returns {Promise<void>}
552
+ * @param {number | undefined} t
553
+ * @returns {Promise<number>}
589
554
  */
590
- speedj(v) {
591
- 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);
592
557
  return takeObject(ret);
593
558
  }
594
559
  /**
560
+ * @param {number} a
595
561
  * @param {any} v
562
+ * @param {number | undefined} t
596
563
  * @param {any | undefined} frame
597
- * @returns {Promise<void>}
564
+ * @returns {Promise<number>}
598
565
  */
599
- speedl(v, frame) {
600
- 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));
601
568
  return takeObject(ret);
602
569
  }
603
570
  /**
604
571
  * @returns {Promise<void>}
605
572
  */
606
573
  start_teach_mode() {
607
- const ret = wasm.robot_start_teach_mode(this.ptr);
574
+ const ret = wasm.robot_start_teach_mode(this.__wbg_ptr);
608
575
  return takeObject(ret);
609
576
  }
610
577
  /**
611
578
  * @returns {Promise<void>}
612
579
  */
613
580
  end_teach_mode() {
614
- const ret = wasm.robot_end_teach_mode(this.ptr);
581
+ const ret = wasm.robot_end_teach_mode(this.__wbg_ptr);
615
582
  return takeObject(ret);
616
583
  }
617
584
  /**
@@ -621,7 +588,7 @@ export class Robot {
621
588
  * @returns {Promise<void>}
622
589
  */
623
590
  set_do(device, pin, value) {
624
- 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);
625
592
  return takeObject(ret);
626
593
  }
627
594
  /**
@@ -630,7 +597,7 @@ export class Robot {
630
597
  * @returns {Promise<number>}
631
598
  */
632
599
  get_do(device, pin) {
633
- const ret = wasm.robot_get_do(this.ptr, addHeapObject(device), pin);
600
+ const ret = wasm.robot_get_do(this.__wbg_ptr, addHeapObject(device), pin);
634
601
  return takeObject(ret);
635
602
  }
636
603
  /**
@@ -640,7 +607,7 @@ export class Robot {
640
607
  * @returns {Promise<any>}
641
608
  */
642
609
  get_dos(device, pin, num) {
643
- 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);
644
611
  return takeObject(ret);
645
612
  }
646
613
  /**
@@ -649,7 +616,7 @@ export class Robot {
649
616
  * @returns {Promise<number>}
650
617
  */
651
618
  get_di(device, pin) {
652
- const ret = wasm.robot_get_di(this.ptr, addHeapObject(device), pin);
619
+ const ret = wasm.robot_get_di(this.__wbg_ptr, addHeapObject(device), pin);
653
620
  return takeObject(ret);
654
621
  }
655
622
  /**
@@ -659,7 +626,7 @@ export class Robot {
659
626
  * @returns {Promise<any>}
660
627
  */
661
628
  get_dis(device, pin, num) {
662
- 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);
663
630
  return takeObject(ret);
664
631
  }
665
632
  /**
@@ -669,7 +636,7 @@ export class Robot {
669
636
  * @returns {Promise<void>}
670
637
  */
671
638
  set_ao(device, pin, value) {
672
- 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);
673
640
  return takeObject(ret);
674
641
  }
675
642
  /**
@@ -678,7 +645,7 @@ export class Robot {
678
645
  * @returns {Promise<number>}
679
646
  */
680
647
  get_ao(device, pin) {
681
- const ret = wasm.robot_get_ao(this.ptr, addHeapObject(device), pin);
648
+ const ret = wasm.robot_get_ao(this.__wbg_ptr, addHeapObject(device), pin);
682
649
  return takeObject(ret);
683
650
  }
684
651
  /**
@@ -688,7 +655,7 @@ export class Robot {
688
655
  * @returns {Promise<any>}
689
656
  */
690
657
  get_aos(device, pin, num) {
691
- 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);
692
659
  return takeObject(ret);
693
660
  }
694
661
  /**
@@ -697,7 +664,7 @@ export class Robot {
697
664
  * @returns {Promise<number>}
698
665
  */
699
666
  get_ai(device, pin) {
700
- const ret = wasm.robot_get_ai(this.ptr, addHeapObject(device), pin);
667
+ const ret = wasm.robot_get_ai(this.__wbg_ptr, addHeapObject(device), pin);
701
668
  return takeObject(ret);
702
669
  }
703
670
  /**
@@ -707,7 +674,7 @@ export class Robot {
707
674
  * @returns {Promise<any>}
708
675
  */
709
676
  get_ais(device, pin, num) {
710
- 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);
711
678
  return takeObject(ret);
712
679
  }
713
680
  /**
@@ -716,7 +683,7 @@ export class Robot {
716
683
  * @returns {Promise<void>}
717
684
  */
718
685
  set_signal(index, value) {
719
- const ret = wasm.robot_set_signal(this.ptr, index, value);
686
+ const ret = wasm.robot_set_signal(this.__wbg_ptr, index, value);
720
687
  return takeObject(ret);
721
688
  }
722
689
  /**
@@ -724,7 +691,7 @@ export class Robot {
724
691
  * @returns {Promise<number>}
725
692
  */
726
693
  get_signal(index) {
727
- const ret = wasm.robot_get_signal(this.ptr, index);
694
+ const ret = wasm.robot_get_signal(this.__wbg_ptr, index);
728
695
  return takeObject(ret);
729
696
  }
730
697
  /**
@@ -733,7 +700,7 @@ export class Robot {
733
700
  * @returns {Promise<void>}
734
701
  */
735
702
  add_signal(index, value) {
736
- const ret = wasm.robot_add_signal(this.ptr, index, value);
703
+ const ret = wasm.robot_add_signal(this.__wbg_ptr, index, value);
737
704
  return takeObject(ret);
738
705
  }
739
706
  /**
@@ -749,7 +716,7 @@ export class Robot {
749
716
  const len0 = WASM_VECTOR_LEN;
750
717
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
751
718
  var len1 = WASM_VECTOR_LEN;
752
- 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);
753
720
  return takeObject(ret);
754
721
  }
755
722
  /**
@@ -757,7 +724,51 @@ export class Robot {
757
724
  * @returns {Promise<string>}
758
725
  */
759
726
  get_task_state(id) {
760
- 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);
761
772
  return takeObject(ret);
762
773
  }
763
774
  /**
@@ -771,7 +782,7 @@ export class Robot {
771
782
  const len0 = WASM_VECTOR_LEN;
772
783
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
773
784
  const len1 = WASM_VECTOR_LEN;
774
- 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);
775
786
  return takeObject(ret);
776
787
  }
777
788
  /**
@@ -785,7 +796,7 @@ export class Robot {
785
796
  const len0 = WASM_VECTOR_LEN;
786
797
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
787
798
  const len1 = WASM_VECTOR_LEN;
788
- 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));
789
800
  return takeObject(ret);
790
801
  }
791
802
  /**
@@ -799,7 +810,7 @@ export class Robot {
799
810
  const len0 = WASM_VECTOR_LEN;
800
811
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
801
812
  const len1 = WASM_VECTOR_LEN;
802
- 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);
803
814
  return takeObject(ret);
804
815
  }
805
816
  /**
@@ -813,7 +824,7 @@ export class Robot {
813
824
  const len0 = WASM_VECTOR_LEN;
814
825
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
815
826
  const len1 = WASM_VECTOR_LEN;
816
- 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);
817
828
  return takeObject(ret);
818
829
  }
819
830
  /**
@@ -827,7 +838,7 @@ export class Robot {
827
838
  const len0 = WASM_VECTOR_LEN;
828
839
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
829
840
  const len1 = WASM_VECTOR_LEN;
830
- 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);
831
842
  return takeObject(ret);
832
843
  }
833
844
  /**
@@ -841,7 +852,7 @@ export class Robot {
841
852
  const len0 = WASM_VECTOR_LEN;
842
853
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
843
854
  const len1 = WASM_VECTOR_LEN;
844
- 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));
845
856
  return takeObject(ret);
846
857
  }
847
858
  /**
@@ -855,7 +866,7 @@ export class Robot {
855
866
  const len0 = WASM_VECTOR_LEN;
856
867
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
857
868
  const len1 = WASM_VECTOR_LEN;
858
- 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);
859
870
  return takeObject(ret);
860
871
  }
861
872
  /**
@@ -869,7 +880,7 @@ export class Robot {
869
880
  const len0 = WASM_VECTOR_LEN;
870
881
  const ptr1 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
871
882
  const len1 = WASM_VECTOR_LEN;
872
- 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);
873
884
  return takeObject(ret);
874
885
  }
875
886
  /**
@@ -878,14 +889,14 @@ export class Robot {
878
889
  * @returns {Promise<void>}
879
890
  */
880
891
  set_claw(force, amplitude) {
881
- 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);
882
893
  return takeObject(ret);
883
894
  }
884
895
  /**
885
896
  * @returns {Promise<any>}
886
897
  */
887
898
  get_claw() {
888
- const ret = wasm.robot_get_claw(this.ptr);
899
+ const ret = wasm.robot_get_claw(this.__wbg_ptr);
889
900
  return takeObject(ret);
890
901
  }
891
902
  /**
@@ -898,7 +909,7 @@ export class Robot {
898
909
  const len0 = WASM_VECTOR_LEN;
899
910
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
900
911
  var len1 = WASM_VECTOR_LEN;
901
- 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);
902
913
  return takeObject(ret);
903
914
  }
904
915
  /**
@@ -906,7 +917,7 @@ export class Robot {
906
917
  * @returns {Promise<void>}
907
918
  */
908
919
  set_led_style(style) {
909
- const ret = wasm.robot_set_led_style(this.ptr, addHeapObject(style));
920
+ const ret = wasm.robot_set_led_style(this.__wbg_ptr, addHeapObject(style));
910
921
  return takeObject(ret);
911
922
  }
912
923
  /**
@@ -918,7 +929,7 @@ export class Robot {
918
929
  set_led(mode, speed, colors) {
919
930
  const ptr0 = passArray32ToWasm0(colors, wasm.__wbindgen_malloc);
920
931
  const len0 = WASM_VECTOR_LEN;
921
- 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);
922
933
  return takeObject(ret);
923
934
  }
924
935
  /**
@@ -927,7 +938,7 @@ export class Robot {
927
938
  * @returns {Promise<void>}
928
939
  */
929
940
  set_voice(voice, volume) {
930
- const ret = wasm.robot_set_voice(this.ptr, voice, volume);
941
+ const ret = wasm.robot_set_voice(this.__wbg_ptr, voice, volume);
931
942
  return takeObject(ret);
932
943
  }
933
944
  /**
@@ -935,49 +946,49 @@ export class Robot {
935
946
  * @returns {Promise<void>}
936
947
  */
937
948
  set_fan(mode) {
938
- const ret = wasm.robot_set_fan(this.ptr, mode);
949
+ const ret = wasm.robot_set_fan(this.__wbg_ptr, mode);
939
950
  return takeObject(ret);
940
951
  }
941
952
  /**
942
953
  * @returns {Promise<void>}
943
954
  */
944
955
  start_sys() {
945
- const ret = wasm.robot_start_sys(this.ptr);
956
+ const ret = wasm.robot_start_sys(this.__wbg_ptr);
946
957
  return takeObject(ret);
947
958
  }
948
959
  /**
949
960
  * @returns {Promise<void>}
950
961
  */
951
962
  stop_sys() {
952
- const ret = wasm.robot_stop_sys(this.ptr);
963
+ const ret = wasm.robot_stop_sys(this.__wbg_ptr);
953
964
  return takeObject(ret);
954
965
  }
955
966
  /**
956
967
  * @returns {Promise<void>}
957
968
  */
958
969
  powerdown() {
959
- const ret = wasm.robot_powerdown(this.ptr);
970
+ const ret = wasm.robot_powerdown(this.__wbg_ptr);
960
971
  return takeObject(ret);
961
972
  }
962
973
  /**
963
974
  * @returns {Promise<void>}
964
975
  */
965
976
  reboot() {
966
- const ret = wasm.robot_reboot(this.ptr);
977
+ const ret = wasm.robot_reboot(this.__wbg_ptr);
967
978
  return takeObject(ret);
968
979
  }
969
980
  /**
970
981
  * @returns {Promise<void>}
971
982
  */
972
983
  stop() {
973
- const ret = wasm.robot_stop(this.ptr);
984
+ const ret = wasm.robot_stop(this.__wbg_ptr);
974
985
  return takeObject(ret);
975
986
  }
976
987
  /**
977
988
  * @returns {Promise<void>}
978
989
  */
979
990
  estop() {
980
- const ret = wasm.robot_estop(this.ptr);
991
+ const ret = wasm.robot_estop(this.__wbg_ptr);
981
992
  return takeObject(ret);
982
993
  }
983
994
  /**
@@ -990,7 +1001,7 @@ export class Robot {
990
1001
  const len0 = WASM_VECTOR_LEN;
991
1002
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
992
1003
  var len1 = WASM_VECTOR_LEN;
993
- 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);
994
1005
  return takeObject(ret);
995
1006
  }
996
1007
  /**
@@ -998,14 +1009,14 @@ export class Robot {
998
1009
  * @returns {Promise<void>}
999
1010
  */
1000
1011
  set_tcp(pose) {
1001
- const ret = wasm.robot_set_tcp(this.ptr, addHeapObject(pose));
1012
+ const ret = wasm.robot_set_tcp(this.__wbg_ptr, addHeapObject(pose));
1002
1013
  return takeObject(ret);
1003
1014
  }
1004
1015
  /**
1005
1016
  * @returns {Promise<any>}
1006
1017
  */
1007
1018
  get_tcp() {
1008
- const ret = wasm.robot_get_tcp(this.ptr);
1019
+ const ret = wasm.robot_get_tcp(this.__wbg_ptr);
1009
1020
  return takeObject(ret);
1010
1021
  }
1011
1022
  /**
@@ -1013,14 +1024,14 @@ export class Robot {
1013
1024
  * @returns {Promise<void>}
1014
1025
  */
1015
1026
  set_velocity_factor(speed_factor) {
1016
- const ret = wasm.robot_set_velocity_factor(this.ptr, speed_factor);
1027
+ const ret = wasm.robot_set_velocity_factor(this.__wbg_ptr, speed_factor);
1017
1028
  return takeObject(ret);
1018
1029
  }
1019
1030
  /**
1020
1031
  * @returns {Promise<number>}
1021
1032
  */
1022
1033
  get_velocity_factor() {
1023
- const ret = wasm.robot_get_velocity_factor(this.ptr);
1034
+ const ret = wasm.robot_get_velocity_factor(this.__wbg_ptr);
1024
1035
  return takeObject(ret);
1025
1036
  }
1026
1037
  /**
@@ -1033,7 +1044,7 @@ export class Robot {
1033
1044
  const len0 = WASM_VECTOR_LEN;
1034
1045
  var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1035
1046
  var len1 = WASM_VECTOR_LEN;
1036
- 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);
1037
1048
  return takeObject(ret);
1038
1049
  }
1039
1050
  /**
@@ -1042,14 +1053,14 @@ export class Robot {
1042
1053
  * @returns {Promise<void>}
1043
1054
  */
1044
1055
  set_payload(mass, cog) {
1045
- 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));
1046
1057
  return takeObject(ret);
1047
1058
  }
1048
1059
  /**
1049
1060
  * @returns {Promise<any>}
1050
1061
  */
1051
1062
  get_payload() {
1052
- const ret = wasm.robot_get_payload(this.ptr);
1063
+ const ret = wasm.robot_get_payload(this.__wbg_ptr);
1053
1064
  return takeObject(ret);
1054
1065
  }
1055
1066
  /**
@@ -1057,14 +1068,14 @@ export class Robot {
1057
1068
  * @returns {Promise<void>}
1058
1069
  */
1059
1070
  set_gravity(pose) {
1060
- const ret = wasm.robot_set_gravity(this.ptr, addHeapObject(pose));
1071
+ const ret = wasm.robot_set_gravity(this.__wbg_ptr, addHeapObject(pose));
1061
1072
  return takeObject(ret);
1062
1073
  }
1063
1074
  /**
1064
1075
  * @returns {Promise<any>}
1065
1076
  */
1066
1077
  get_gravity() {
1067
- const ret = wasm.robot_get_gravity(this.ptr);
1078
+ const ret = wasm.robot_get_gravity(this.__wbg_ptr);
1068
1079
  return takeObject(ret);
1069
1080
  }
1070
1081
  }
@@ -1073,15 +1084,16 @@ export class Robot {
1073
1084
  export class RobotSubscription {
1074
1085
 
1075
1086
  static __wrap(ptr) {
1087
+ ptr = ptr >>> 0;
1076
1088
  const obj = Object.create(RobotSubscription.prototype);
1077
- obj.ptr = ptr;
1089
+ obj.__wbg_ptr = ptr;
1078
1090
 
1079
1091
  return obj;
1080
1092
  }
1081
1093
 
1082
1094
  __destroy_into_raw() {
1083
- const ptr = this.ptr;
1084
- this.ptr = 0;
1095
+ const ptr = this.__wbg_ptr;
1096
+ this.__wbg_ptr = 0;
1085
1097
 
1086
1098
  return ptr;
1087
1099
  }
@@ -1094,21 +1106,11 @@ export class RobotSubscription {
1094
1106
  * @returns {Promise<string | undefined>}
1095
1107
  */
1096
1108
  next() {
1097
- const ret = wasm.robotsubscription_next(this.ptr);
1109
+ const ret = wasm.robotsubscription_next(this.__wbg_ptr);
1098
1110
  return takeObject(ret);
1099
1111
  }
1100
1112
  }
1101
1113
 
1102
- export function __wbindgen_cb_drop(arg0) {
1103
- const obj = takeObject(arg0).original;
1104
- if (obj.cnt-- == 1) {
1105
- obj.a = 0;
1106
- return true;
1107
- }
1108
- const ret = false;
1109
- return ret;
1110
- };
1111
-
1112
1114
  export function __wbindgen_object_drop_ref(arg0) {
1113
1115
  takeObject(arg0);
1114
1116
  };
@@ -1120,19 +1122,24 @@ export function __wbindgen_number_get(arg0, arg1) {
1120
1122
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
1121
1123
  };
1122
1124
 
1125
+ export function __wbindgen_boolean_get(arg0) {
1126
+ const v = getObject(arg0);
1127
+ const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
1128
+ return ret;
1129
+ };
1130
+
1123
1131
  export function __wbindgen_string_get(arg0, arg1) {
1124
1132
  const obj = getObject(arg1);
1125
1133
  const ret = typeof(obj) === 'string' ? obj : undefined;
1126
- var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1127
- var len0 = WASM_VECTOR_LEN;
1128
- getInt32Memory0()[arg0 / 4 + 1] = len0;
1129
- getInt32Memory0()[arg0 / 4 + 0] = ptr0;
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;
1130
1138
  };
1131
1139
 
1132
- export function __wbindgen_boolean_get(arg0) {
1133
- const v = getObject(arg0);
1134
- const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
1135
- return ret;
1140
+ export function __wbindgen_number_new(arg0) {
1141
+ const ret = arg0;
1142
+ return addHeapObject(ret);
1136
1143
  };
1137
1144
 
1138
1145
  export function __wbg_robotsubscription_new(arg0) {
@@ -1145,9 +1152,10 @@ export function __wbg_robot_new(arg0) {
1145
1152
  return addHeapObject(ret);
1146
1153
  };
1147
1154
 
1148
- export function __wbindgen_number_new(arg0) {
1149
- const ret = arg0;
1150
- return addHeapObject(ret);
1155
+ export function __wbindgen_is_object(arg0) {
1156
+ const val = getObject(arg0);
1157
+ const ret = typeof(val) === 'object' && val !== null;
1158
+ return ret;
1151
1159
  };
1152
1160
 
1153
1161
  export function __wbindgen_string_new(arg0, arg1) {
@@ -1155,6 +1163,26 @@ export function __wbindgen_string_new(arg0, arg1) {
1155
1163
  return addHeapObject(ret);
1156
1164
  };
1157
1165
 
1166
+ export function __wbindgen_cb_drop(arg0) {
1167
+ const obj = takeObject(arg0).original;
1168
+ if (obj.cnt-- == 1) {
1169
+ obj.a = 0;
1170
+ return true;
1171
+ }
1172
+ const ret = false;
1173
+ return ret;
1174
+ };
1175
+
1176
+ export function __wbindgen_is_undefined(arg0) {
1177
+ const ret = getObject(arg0) === undefined;
1178
+ return ret;
1179
+ };
1180
+
1181
+ export function __wbindgen_in(arg0, arg1) {
1182
+ const ret = getObject(arg0) in getObject(arg1);
1183
+ return ret;
1184
+ };
1185
+
1158
1186
  export function __wbindgen_is_bigint(arg0) {
1159
1187
  const ret = typeof(getObject(arg0)) === 'bigint';
1160
1188
  return ret;
@@ -1170,27 +1198,11 @@ export function __wbindgen_jsval_eq(arg0, arg1) {
1170
1198
  return ret;
1171
1199
  };
1172
1200
 
1173
- export function __wbindgen_is_object(arg0) {
1174
- const val = getObject(arg0);
1175
- const ret = typeof(val) === 'object' && val !== null;
1176
- return ret;
1177
- };
1178
-
1179
- export function __wbindgen_in(arg0, arg1) {
1180
- const ret = getObject(arg0) in getObject(arg1);
1181
- return ret;
1182
- };
1183
-
1184
1201
  export function __wbindgen_bigint_from_u64(arg0) {
1185
1202
  const ret = BigInt.asUintN(64, arg0);
1186
1203
  return addHeapObject(ret);
1187
1204
  };
1188
1205
 
1189
- export function __wbindgen_is_undefined(arg0) {
1190
- const ret = getObject(arg0) === undefined;
1191
- return ret;
1192
- };
1193
-
1194
1206
  export function __wbindgen_error_new(arg0, arg1) {
1195
1207
  const ret = new Error(getStringFromWasm0(arg0, arg1));
1196
1208
  return addHeapObject(ret);
@@ -1206,73 +1218,73 @@ export function __wbindgen_object_clone_ref(arg0) {
1206
1218
  return addHeapObject(ret);
1207
1219
  };
1208
1220
 
1209
- 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) {
1210
1222
  getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
1211
1223
  }, arguments) };
1212
1224
 
1213
- 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) {
1214
1226
  getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
1215
1227
  }, arguments) };
1216
1228
 
1217
- export function __wbg_dispatchEvent_615d1ccbba577081() { return handleError(function (arg0, arg1) {
1229
+ export function __wbg_dispatchEvent_cfc38228a531c8c8() { return handleError(function (arg0, arg1) {
1218
1230
  const ret = getObject(arg0).dispatchEvent(getObject(arg1));
1219
1231
  return ret;
1220
1232
  }, arguments) };
1221
1233
 
1222
- 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) {
1223
1235
  getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
1224
1236
  }, arguments) };
1225
1237
 
1226
- export function __wbg_wasClean_17e8b22af0b82315(arg0) {
1238
+ export function __wbg_wasClean_133b4529d739de9e(arg0) {
1227
1239
  const ret = getObject(arg0).wasClean;
1228
1240
  return ret;
1229
1241
  };
1230
1242
 
1231
- export function __wbg_code_9743a5678b87b9e9(arg0) {
1243
+ export function __wbg_code_5921daf18e5a3378(arg0) {
1232
1244
  const ret = getObject(arg0).code;
1233
1245
  return ret;
1234
1246
  };
1235
1247
 
1236
- export function __wbg_reason_8585c102803c11b5(arg0, arg1) {
1248
+ export function __wbg_reason_c07db343645d6e25(arg0, arg1) {
1237
1249
  const ret = getObject(arg1).reason;
1238
- const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1239
- const len0 = WASM_VECTOR_LEN;
1240
- getInt32Memory0()[arg0 / 4 + 1] = len0;
1241
- 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;
1242
1254
  };
1243
1255
 
1244
- export function __wbg_newwitheventinitdict_0e8e2070ae66ce38() { return handleError(function (arg0, arg1, arg2) {
1256
+ export function __wbg_newwitheventinitdict_6b770a22a3426955() { return handleError(function (arg0, arg1, arg2) {
1245
1257
  const ret = new CloseEvent(getStringFromWasm0(arg0, arg1), getObject(arg2));
1246
1258
  return addHeapObject(ret);
1247
1259
  }, arguments) };
1248
1260
 
1249
- export function __wbg_readyState_b3671943d2cedc2b(arg0) {
1261
+ export function __wbg_readyState_ad4a43cf245ed346(arg0) {
1250
1262
  const ret = getObject(arg0).readyState;
1251
1263
  return ret;
1252
1264
  };
1253
1265
 
1254
- export function __wbg_setbinaryType_c9b2fa398c277601(arg0, arg1) {
1266
+ export function __wbg_setbinaryType_912a58ff49a07245(arg0, arg1) {
1255
1267
  getObject(arg0).binaryType = takeObject(arg1);
1256
1268
  };
1257
1269
 
1258
- export function __wbg_new_8ad026ef33da9ab1() { return handleError(function (arg0, arg1) {
1270
+ export function __wbg_new_c70a4fdc1ed8f3bb() { return handleError(function (arg0, arg1) {
1259
1271
  const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
1260
1272
  return addHeapObject(ret);
1261
1273
  }, arguments) };
1262
1274
 
1263
- export function __wbg_close_546591d4b4350b36() { return handleError(function (arg0) {
1275
+ export function __wbg_close_b57426e46b2cde05() { return handleError(function (arg0) {
1264
1276
  getObject(arg0).close();
1265
1277
  }, arguments) };
1266
1278
 
1267
- export function __wbg_send_36f8bcb566f8afa0() { return handleError(function (arg0, arg1, arg2) {
1279
+ export function __wbg_send_1cc5e505b0cbc15c() { return handleError(function (arg0, arg1, arg2) {
1268
1280
  getObject(arg0).send(getStringFromWasm0(arg1, arg2));
1269
1281
  }, arguments) };
1270
1282
 
1271
- export function __wbg_send_c1c0838681688262() { return handleError(function (arg0, arg1, arg2) {
1283
+ export function __wbg_send_43a6924260160efb() { return handleError(function (arg0, arg1, arg2) {
1272
1284
  getObject(arg0).send(getArrayU8FromWasm0(arg1, arg2));
1273
1285
  }, arguments) };
1274
1286
 
1275
- export function __wbg_data_af909e5dfe73e68c(arg0) {
1287
+ export function __wbg_data_338d13609f6165a6(arg0) {
1276
1288
  const ret = getObject(arg0).data;
1277
1289
  return addHeapObject(ret);
1278
1290
  };
@@ -1292,26 +1304,26 @@ export function __wbindgen_jsval_loose_eq(arg0, arg1) {
1292
1304
  return ret;
1293
1305
  };
1294
1306
 
1295
- export function __wbg_getwithrefkey_15c62c2b8546208d(arg0, arg1) {
1307
+ export function __wbg_getwithrefkey_5e6d9547403deab8(arg0, arg1) {
1296
1308
  const ret = getObject(arg0)[getObject(arg1)];
1297
1309
  return addHeapObject(ret);
1298
1310
  };
1299
1311
 
1300
- export function __wbg_set_20cbc34131e76824(arg0, arg1, arg2) {
1312
+ export function __wbg_set_841ac57cff3d672b(arg0, arg1, arg2) {
1301
1313
  getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
1302
1314
  };
1303
1315
 
1304
- export function __wbg_get_27fe3dac1c4d0224(arg0, arg1) {
1316
+ export function __wbg_get_7303ed2ef026b2f5(arg0, arg1) {
1305
1317
  const ret = getObject(arg0)[arg1 >>> 0];
1306
1318
  return addHeapObject(ret);
1307
1319
  };
1308
1320
 
1309
- export function __wbg_length_e498fbc24f9c1d4f(arg0) {
1321
+ export function __wbg_length_820c786973abdd8a(arg0) {
1310
1322
  const ret = getObject(arg0).length;
1311
1323
  return ret;
1312
1324
  };
1313
1325
 
1314
- export function __wbg_new_b525de17f44a8943() {
1326
+ export function __wbg_new_0394642eae39db16() {
1315
1327
  const ret = new Array();
1316
1328
  return addHeapObject(ret);
1317
1329
  };
@@ -1321,56 +1333,56 @@ export function __wbindgen_is_function(arg0) {
1321
1333
  return ret;
1322
1334
  };
1323
1335
 
1324
- export function __wbg_next_b7d530c04fd8b217(arg0) {
1336
+ export function __wbg_next_f4bc0e96ea67da68(arg0) {
1325
1337
  const ret = getObject(arg0).next;
1326
1338
  return addHeapObject(ret);
1327
1339
  };
1328
1340
 
1329
- export function __wbg_next_88560ec06a094dea() { return handleError(function (arg0) {
1341
+ export function __wbg_next_ec061e48a0e72a96() { return handleError(function (arg0) {
1330
1342
  const ret = getObject(arg0).next();
1331
1343
  return addHeapObject(ret);
1332
1344
  }, arguments) };
1333
1345
 
1334
- export function __wbg_done_1ebec03bbd919843(arg0) {
1346
+ export function __wbg_done_b6abb27d42b63867(arg0) {
1335
1347
  const ret = getObject(arg0).done;
1336
1348
  return ret;
1337
1349
  };
1338
1350
 
1339
- export function __wbg_value_6ac8da5cc5b3efda(arg0) {
1351
+ export function __wbg_value_2f4ef2036bfad28e(arg0) {
1340
1352
  const ret = getObject(arg0).value;
1341
1353
  return addHeapObject(ret);
1342
1354
  };
1343
1355
 
1344
- export function __wbg_iterator_55f114446221aa5a() {
1356
+ export function __wbg_iterator_7c7e58f62eb84700() {
1345
1357
  const ret = Symbol.iterator;
1346
1358
  return addHeapObject(ret);
1347
1359
  };
1348
1360
 
1349
- export function __wbg_get_baf4855f9a986186() { return handleError(function (arg0, arg1) {
1361
+ export function __wbg_get_f53c921291c381bd() { return handleError(function (arg0, arg1) {
1350
1362
  const ret = Reflect.get(getObject(arg0), getObject(arg1));
1351
1363
  return addHeapObject(ret);
1352
1364
  }, arguments) };
1353
1365
 
1354
- export function __wbg_call_95d1ea488d03e4e8() { return handleError(function (arg0, arg1) {
1366
+ export function __wbg_call_557a2f2deacc4912() { return handleError(function (arg0, arg1) {
1355
1367
  const ret = getObject(arg0).call(getObject(arg1));
1356
1368
  return addHeapObject(ret);
1357
1369
  }, arguments) };
1358
1370
 
1359
- export function __wbg_new_f9876326328f45ed() {
1371
+ export function __wbg_new_2b6fea4ea03b1b95() {
1360
1372
  const ret = new Object();
1361
1373
  return addHeapObject(ret);
1362
1374
  };
1363
1375
 
1364
- export function __wbg_set_17224bc548dd1d7b(arg0, arg1, arg2) {
1376
+ export function __wbg_set_b4da98d504ac6091(arg0, arg1, arg2) {
1365
1377
  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1366
1378
  };
1367
1379
 
1368
- export function __wbg_isArray_39d28997bf6b96b4(arg0) {
1380
+ export function __wbg_isArray_04e59fb73f78ab5b(arg0) {
1369
1381
  const ret = Array.isArray(getObject(arg0));
1370
1382
  return ret;
1371
1383
  };
1372
1384
 
1373
- export function __wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065(arg0) {
1385
+ export function __wbg_instanceof_ArrayBuffer_ef2632aa0d4bfff8(arg0) {
1374
1386
  let result;
1375
1387
  try {
1376
1388
  result = getObject(arg0) instanceof ArrayBuffer;
@@ -1381,7 +1393,7 @@ export function __wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065(arg0) {
1381
1393
  return ret;
1382
1394
  };
1383
1395
 
1384
- export function __wbg_instanceof_Error_749a7378f4439ee0(arg0) {
1396
+ export function __wbg_instanceof_Error_fac23a8832b241da(arg0) {
1385
1397
  let result;
1386
1398
  try {
1387
1399
  result = getObject(arg0) instanceof Error;
@@ -1392,44 +1404,44 @@ export function __wbg_instanceof_Error_749a7378f4439ee0(arg0) {
1392
1404
  return ret;
1393
1405
  };
1394
1406
 
1395
- export function __wbg_message_a95c3ef248e4b57a(arg0) {
1407
+ export function __wbg_message_eab7d45ec69a2135(arg0) {
1396
1408
  const ret = getObject(arg0).message;
1397
1409
  return addHeapObject(ret);
1398
1410
  };
1399
1411
 
1400
- export function __wbg_name_c69a20c4b1197dc0(arg0) {
1412
+ export function __wbg_name_8e6176d4db1a502d(arg0) {
1401
1413
  const ret = getObject(arg0).name;
1402
1414
  return addHeapObject(ret);
1403
1415
  };
1404
1416
 
1405
- export function __wbg_toString_cec163b212643722(arg0) {
1417
+ export function __wbg_toString_506566b763774a16(arg0) {
1406
1418
  const ret = getObject(arg0).toString();
1407
1419
  return addHeapObject(ret);
1408
1420
  };
1409
1421
 
1410
- export function __wbg_call_9495de66fdbe016b() { return handleError(function (arg0, arg1, arg2) {
1422
+ export function __wbg_call_587b30eea3e09332() { return handleError(function (arg0, arg1, arg2) {
1411
1423
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
1412
1424
  return addHeapObject(ret);
1413
1425
  }, arguments) };
1414
1426
 
1415
- export function __wbg_isSafeInteger_8c4789029e885159(arg0) {
1427
+ export function __wbg_isSafeInteger_2088b01008075470(arg0) {
1416
1428
  const ret = Number.isSafeInteger(getObject(arg0));
1417
1429
  return ret;
1418
1430
  };
1419
1431
 
1420
- export function __wbg_entries_4e1315b774245952(arg0) {
1432
+ export function __wbg_entries_13e011453776468f(arg0) {
1421
1433
  const ret = Object.entries(getObject(arg0));
1422
1434
  return addHeapObject(ret);
1423
1435
  };
1424
1436
 
1425
- export function __wbg_new_9d3a9ce4282a18a8(arg0, arg1) {
1437
+ export function __wbg_new_2b55e405e4af4986(arg0, arg1) {
1426
1438
  try {
1427
1439
  var state0 = {a: arg0, b: arg1};
1428
1440
  var cb0 = (arg0, arg1) => {
1429
1441
  const a = state0.a;
1430
1442
  state0.a = 0;
1431
1443
  try {
1432
- return __wbg_adapter_220(a, state0.b, arg0, arg1);
1444
+ return __wbg_adapter_221(a, state0.b, arg0, arg1);
1433
1445
  } finally {
1434
1446
  state0.a = a;
1435
1447
  }
@@ -1441,36 +1453,36 @@ export function __wbg_new_9d3a9ce4282a18a8(arg0, arg1) {
1441
1453
  }
1442
1454
  };
1443
1455
 
1444
- export function __wbg_resolve_fd40f858d9db1a04(arg0) {
1456
+ export function __wbg_resolve_ae38ad63c43ff98b(arg0) {
1445
1457
  const ret = Promise.resolve(getObject(arg0));
1446
1458
  return addHeapObject(ret);
1447
1459
  };
1448
1460
 
1449
- export function __wbg_then_ec5db6d509eb475f(arg0, arg1) {
1461
+ export function __wbg_then_8df675b8bb5d5e3c(arg0, arg1) {
1450
1462
  const ret = getObject(arg0).then(getObject(arg1));
1451
1463
  return addHeapObject(ret);
1452
1464
  };
1453
1465
 
1454
- export function __wbg_buffer_cf65c07de34b9a08(arg0) {
1466
+ export function __wbg_buffer_55ba7a6b1b92e2ac(arg0) {
1455
1467
  const ret = getObject(arg0).buffer;
1456
1468
  return addHeapObject(ret);
1457
1469
  };
1458
1470
 
1459
- export function __wbg_new_537b7341ce90bb31(arg0) {
1471
+ export function __wbg_new_09938a7d020f049b(arg0) {
1460
1472
  const ret = new Uint8Array(getObject(arg0));
1461
1473
  return addHeapObject(ret);
1462
1474
  };
1463
1475
 
1464
- export function __wbg_set_17499e8aa4003ebd(arg0, arg1, arg2) {
1476
+ export function __wbg_set_3698e3ca519b3c3c(arg0, arg1, arg2) {
1465
1477
  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
1466
1478
  };
1467
1479
 
1468
- export function __wbg_length_27a2afe8ab42b09f(arg0) {
1480
+ export function __wbg_length_0aab7ffd65ad19ed(arg0) {
1469
1481
  const ret = getObject(arg0).length;
1470
1482
  return ret;
1471
1483
  };
1472
1484
 
1473
- export function __wbg_instanceof_Uint8Array_01cebe79ca606cca(arg0) {
1485
+ export function __wbg_instanceof_Uint8Array_1349640af2da2e88(arg0) {
1474
1486
  let result;
1475
1487
  try {
1476
1488
  result = getObject(arg0) instanceof Uint8Array;
@@ -1481,7 +1493,7 @@ export function __wbg_instanceof_Uint8Array_01cebe79ca606cca(arg0) {
1481
1493
  return ret;
1482
1494
  };
1483
1495
 
1484
- export function __wbg_set_6aa458a4ebdb65cb() { return handleError(function (arg0, arg1, arg2) {
1496
+ export function __wbg_set_07da13cc24b69217() { return handleError(function (arg0, arg1, arg2) {
1485
1497
  const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1486
1498
  return ret;
1487
1499
  }, arguments) };
@@ -1495,10 +1507,10 @@ export function __wbindgen_bigint_get_as_i64(arg0, arg1) {
1495
1507
 
1496
1508
  export function __wbindgen_debug_string(arg0, arg1) {
1497
1509
  const ret = debugString(getObject(arg1));
1498
- const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1499
- const len0 = WASM_VECTOR_LEN;
1500
- getInt32Memory0()[arg0 / 4 + 1] = len0;
1501
- 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;
1502
1514
  };
1503
1515
 
1504
1516
  export function __wbindgen_throw(arg0, arg1) {
@@ -1510,33 +1522,33 @@ export function __wbindgen_memory() {
1510
1522
  return addHeapObject(ret);
1511
1523
  };
1512
1524
 
1513
- export function __wbindgen_closure_wrapper1520(arg0, arg1, arg2) {
1514
- const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_48);
1525
+ export function __wbindgen_closure_wrapper1552(arg0, arg1, arg2) {
1526
+ const ret = makeMutClosure(arg0, arg1, 588, __wbg_adapter_48);
1515
1527
  return addHeapObject(ret);
1516
1528
  };
1517
1529
 
1518
- export function __wbindgen_closure_wrapper1522(arg0, arg1, arg2) {
1519
- const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_48);
1530
+ export function __wbindgen_closure_wrapper1554(arg0, arg1, arg2) {
1531
+ const ret = makeMutClosure(arg0, arg1, 588, __wbg_adapter_48);
1520
1532
  return addHeapObject(ret);
1521
1533
  };
1522
1534
 
1523
- export function __wbindgen_closure_wrapper1524(arg0, arg1, arg2) {
1524
- const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_48);
1535
+ export function __wbindgen_closure_wrapper1556(arg0, arg1, arg2) {
1536
+ const ret = makeMutClosure(arg0, arg1, 588, __wbg_adapter_48);
1525
1537
  return addHeapObject(ret);
1526
1538
  };
1527
1539
 
1528
- export function __wbindgen_closure_wrapper1526(arg0, arg1, arg2) {
1529
- const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_55);
1540
+ export function __wbindgen_closure_wrapper1558(arg0, arg1, arg2) {
1541
+ const ret = makeMutClosure(arg0, arg1, 588, __wbg_adapter_55);
1530
1542
  return addHeapObject(ret);
1531
1543
  };
1532
1544
 
1533
- export function __wbindgen_closure_wrapper2010(arg0, arg1, arg2) {
1534
- const ret = makeMutClosure(arg0, arg1, 673, __wbg_adapter_58);
1545
+ export function __wbindgen_closure_wrapper2026(arg0, arg1, arg2) {
1546
+ const ret = makeMutClosure(arg0, arg1, 663, __wbg_adapter_58);
1535
1547
  return addHeapObject(ret);
1536
1548
  };
1537
1549
 
1538
- export function __wbindgen_closure_wrapper2044(arg0, arg1, arg2) {
1539
- const ret = makeMutClosure(arg0, arg1, 687, __wbg_adapter_61);
1550
+ export function __wbindgen_closure_wrapper2061(arg0, arg1, arg2) {
1551
+ const ret = makeMutClosure(arg0, arg1, 677, __wbg_adapter_61);
1540
1552
  return addHeapObject(ret);
1541
1553
  };
1542
1554