lebai_sdk 0.1.5 → 0.1.7

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.d.ts CHANGED
@@ -12,6 +12,18 @@ export function connect(ip: string, simu: boolean): Promise<Robot>;
12
12
  */
13
13
  export function discover_devices(time: number): Promise<any>;
14
14
  /**
15
+ * @param {bigint} ms
16
+ * @returns {Promise<void>}
17
+ */
18
+ export function sleep_ms(ms: bigint): Promise<void>;
19
+ /**
20
+ * @returns {bigint}
21
+ */
22
+ export function timestamp(): bigint;
23
+ /**
24
+ */
25
+ export function init(): void;
26
+ /**
15
27
  * @returns {string}
16
28
  */
17
29
  export function version(): string;
@@ -49,6 +61,13 @@ export class Robot {
49
61
  */
50
62
  pose_trans(from: any, to: any): Promise<any>;
51
63
  /**
64
+ * @param {any} pose
65
+ * @param {any} frame
66
+ * @param {any} delta
67
+ * @returns {Promise<any>}
68
+ */
69
+ pose_add(pose: any, frame: any, delta: any): Promise<any>;
70
+ /**
52
71
  * @param {any} p
53
72
  * @returns {Promise<any>}
54
73
  */
@@ -123,19 +142,19 @@ export class Robot {
123
142
  movec(via: any, p: any, rad: number, a: number, v: number, t: number, r?: number): Promise<number>;
124
143
  /**
125
144
  * @param {any} p
126
- * @param {number} v
145
+ * @param {any} v
127
146
  * @param {number} t
128
147
  * @returns {Promise<void>}
129
148
  */
130
- move_pvt(p: any, v: number, t: number): Promise<void>;
149
+ move_pvt(p: any, v: any, t: number): Promise<void>;
131
150
  /**
132
151
  * @param {any} p
133
- * @param {number} v
134
- * @param {number} a
152
+ * @param {any} v
153
+ * @param {any} a
135
154
  * @param {number} t
136
155
  * @returns {Promise<void>}
137
156
  */
138
- move_pvat(p: any, v: number, a: number, t: number): Promise<void>;
157
+ move_pvat(p: any, v: any, a: any, t: number): Promise<void>;
139
158
  /**
140
159
  * @param {any} v
141
160
  * @returns {Promise<void>}
@@ -319,6 +338,35 @@ export class Robot {
319
338
  */
320
339
  get_claw(): Promise<any>;
321
340
  /**
341
+ * @param {string} name
342
+ * @param {string | undefined} dir
343
+ * @returns {Promise<any>}
344
+ */
345
+ load_led_style(name: string, dir?: string): Promise<any>;
346
+ /**
347
+ * @param {any} style
348
+ * @returns {Promise<void>}
349
+ */
350
+ set_led_style(style: any): Promise<void>;
351
+ /**
352
+ * @param {number} mode
353
+ * @param {number} speed
354
+ * @param {Int32Array} colors
355
+ * @returns {Promise<void>}
356
+ */
357
+ set_led(mode: number, speed: number, colors: Int32Array): Promise<void>;
358
+ /**
359
+ * @param {number} voice
360
+ * @param {number} volume
361
+ * @returns {Promise<void>}
362
+ */
363
+ set_voice(voice: number, volume: number): Promise<void>;
364
+ /**
365
+ * @param {number} mode
366
+ * @returns {Promise<void>}
367
+ */
368
+ set_fan(mode: number): Promise<void>;
369
+ /**
322
370
  * @returns {Promise<void>}
323
371
  */
324
372
  start_sys(): Promise<void>;
package/lebai_sdk.js CHANGED
@@ -1,2 +1,4 @@
1
1
  import * as wasm from "./lebai_sdk_bg.wasm";
2
- export * from "./lebai_sdk_bg.js";
2
+ import { __wbg_set_wasm } from "./lebai_sdk_bg.js";
3
+ __wbg_set_wasm(wasm);
4
+ export * from "./lebai_sdk_bg.js";
package/lebai_sdk_bg.js CHANGED
@@ -1,24 +1,19 @@
1
- import * as wasm from './lebai_sdk_bg.wasm';
2
-
3
- const heap = new Array(32).fill(undefined);
1
+ let wasm;
2
+ export function __wbg_set_wasm(val) {
3
+ wasm = val;
4
+ }
4
5
 
5
- heap.push(undefined, null, true, false);
6
6
 
7
- let heap_next = heap.length;
8
-
9
- function addHeapObject(obj) {
10
- if (heap_next === heap.length) heap.push(heap.length + 1);
11
- const idx = heap_next;
12
- heap_next = heap[idx];
7
+ const heap = new Array(128).fill(undefined);
13
8
 
14
- heap[idx] = obj;
15
- return idx;
16
- }
9
+ heap.push(undefined, null, true, false);
17
10
 
18
11
  function getObject(idx) { return heap[idx]; }
19
12
 
13
+ let heap_next = heap.length;
14
+
20
15
  function dropObject(idx) {
21
- if (idx < 36) return;
16
+ if (idx < 132) return;
22
17
  heap[idx] = heap_next;
23
18
  heap_next = idx;
24
19
  }
@@ -29,27 +24,39 @@ function takeObject(idx) {
29
24
  return ret;
30
25
  }
31
26
 
32
- const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
27
+ function isLikeNone(x) {
28
+ return x === undefined || x === null;
29
+ }
33
30
 
34
- let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
31
+ let cachedFloat64Memory0 = null;
35
32
 
36
- cachedTextDecoder.decode();
33
+ function getFloat64Memory0() {
34
+ if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
35
+ cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
36
+ }
37
+ return cachedFloat64Memory0;
38
+ }
37
39
 
38
- let cachedUint8Memory0 = new Uint8Array();
40
+ let cachedInt32Memory0 = null;
41
+
42
+ function getInt32Memory0() {
43
+ if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
44
+ cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
45
+ }
46
+ return cachedInt32Memory0;
47
+ }
48
+
49
+ let WASM_VECTOR_LEN = 0;
50
+
51
+ let cachedUint8Memory0 = null;
39
52
 
40
53
  function getUint8Memory0() {
41
- if (cachedUint8Memory0.byteLength === 0) {
54
+ if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
42
55
  cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
43
56
  }
44
57
  return cachedUint8Memory0;
45
58
  }
46
59
 
47
- function getStringFromWasm0(ptr, len) {
48
- return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
49
- }
50
-
51
- let WASM_VECTOR_LEN = 0;
52
-
53
60
  const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
54
61
 
55
62
  let cachedTextEncoder = new lTextEncoder('utf-8');
@@ -105,32 +112,29 @@ function passStringToWasm0(arg, malloc, realloc) {
105
112
  return ptr;
106
113
  }
107
114
 
108
- function isLikeNone(x) {
109
- return x === undefined || x === null;
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;
110
122
  }
111
123
 
112
- let cachedInt32Memory0 = new Int32Array();
124
+ const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
113
125
 
114
- function getInt32Memory0() {
115
- if (cachedInt32Memory0.byteLength === 0) {
116
- cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
117
- }
118
- return cachedInt32Memory0;
119
- }
126
+ let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
120
127
 
121
- let cachedFloat64Memory0 = new Float64Array();
128
+ cachedTextDecoder.decode();
122
129
 
123
- function getFloat64Memory0() {
124
- if (cachedFloat64Memory0.byteLength === 0) {
125
- cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
126
- }
127
- return cachedFloat64Memory0;
130
+ function getStringFromWasm0(ptr, len) {
131
+ return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
128
132
  }
129
133
 
130
- let cachedBigInt64Memory0 = new BigInt64Array();
134
+ let cachedBigInt64Memory0 = null;
131
135
 
132
136
  function getBigInt64Memory0() {
133
- if (cachedBigInt64Memory0.byteLength === 0) {
137
+ if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
134
138
  cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
135
139
  }
136
140
  return cachedBigInt64Memory0;
@@ -226,21 +230,36 @@ function makeMutClosure(arg0, arg1, dtor, f) {
226
230
  return real;
227
231
  }
228
232
  function __wbg_adapter_48(arg0, arg1, arg2) {
229
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h366369483d22bcaf(arg0, arg1, addHeapObject(arg2));
233
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h0c510e469e54a267(arg0, arg1, addHeapObject(arg2));
230
234
  }
231
235
 
232
- function __wbg_adapter_53(arg0, arg1) {
233
- wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h0df4c157cd7dc806(arg0, arg1);
236
+ 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);
234
238
  }
235
239
 
236
240
  function __wbg_adapter_58(arg0, arg1, arg2) {
237
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hdb5e4912e141ff12(arg0, arg1, addHeapObject(arg2));
241
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h2f7f6052cd504365(arg0, arg1, addHeapObject(arg2));
238
242
  }
239
243
 
240
244
  function __wbg_adapter_61(arg0, arg1) {
241
- wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hcf457e62695755fb(arg0, arg1);
245
+ wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hd957d0ddc4719c47(arg0, arg1);
242
246
  }
243
247
 
248
+ let cachedUint32Memory0 = null;
249
+
250
+ function getUint32Memory0() {
251
+ if (cachedUint32Memory0 === null || cachedUint32Memory0.byteLength === 0) {
252
+ cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer);
253
+ }
254
+ return cachedUint32Memory0;
255
+ }
256
+
257
+ function passArray32ToWasm0(arg, malloc) {
258
+ const ptr = malloc(arg.length * 4);
259
+ getUint32Memory0().set(arg, ptr / 4);
260
+ WASM_VECTOR_LEN = arg.length;
261
+ return ptr;
262
+ }
244
263
  /**
245
264
  * @param {string} ip
246
265
  * @param {boolean} simu
@@ -262,6 +281,50 @@ export function discover_devices(time) {
262
281
  return takeObject(ret);
263
282
  }
264
283
 
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
+
265
328
  /**
266
329
  * @returns {string}
267
330
  */
@@ -297,10 +360,8 @@ function handleError(f, args) {
297
360
  function getArrayU8FromWasm0(ptr, len) {
298
361
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
299
362
  }
300
-
301
- function notDefined(what) { return () => { throw new Error(`${what} is not defined`); }; }
302
- function __wbg_adapter_211(arg0, arg1, arg2, arg3) {
303
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h3122b00026f2b9b6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
363
+ function __wbg_adapter_220(arg0, arg1, arg2, arg3) {
364
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h1f4070fd0aa7ef09(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
304
365
  }
305
366
 
306
367
  /**
@@ -378,6 +439,16 @@ export class Robot {
378
439
  return takeObject(ret);
379
440
  }
380
441
  /**
442
+ * @param {any} pose
443
+ * @param {any} frame
444
+ * @param {any} delta
445
+ * @returns {Promise<any>}
446
+ */
447
+ pose_add(pose, frame, delta) {
448
+ const ret = wasm.robot_pose_add(this.ptr, addHeapObject(pose), addHeapObject(frame), addHeapObject(delta));
449
+ return takeObject(ret);
450
+ }
451
+ /**
381
452
  * @param {any} p
382
453
  * @returns {Promise<any>}
383
454
  */
@@ -493,23 +564,23 @@ export class Robot {
493
564
  }
494
565
  /**
495
566
  * @param {any} p
496
- * @param {number} v
567
+ * @param {any} v
497
568
  * @param {number} t
498
569
  * @returns {Promise<void>}
499
570
  */
500
571
  move_pvt(p, v, t) {
501
- const ret = wasm.robot_move_pvt(this.ptr, addHeapObject(p), v, t);
572
+ const ret = wasm.robot_move_pvt(this.ptr, addHeapObject(p), addHeapObject(v), t);
502
573
  return takeObject(ret);
503
574
  }
504
575
  /**
505
576
  * @param {any} p
506
- * @param {number} v
507
- * @param {number} a
577
+ * @param {any} v
578
+ * @param {any} a
508
579
  * @param {number} t
509
580
  * @returns {Promise<void>}
510
581
  */
511
582
  move_pvat(p, v, a, t) {
512
- const ret = wasm.robot_move_pvat(this.ptr, addHeapObject(p), v, a, t);
583
+ const ret = wasm.robot_move_pvat(this.ptr, addHeapObject(p), addHeapObject(v), addHeapObject(a), t);
513
584
  return takeObject(ret);
514
585
  }
515
586
  /**
@@ -818,6 +889,56 @@ export class Robot {
818
889
  return takeObject(ret);
819
890
  }
820
891
  /**
892
+ * @param {string} name
893
+ * @param {string | undefined} dir
894
+ * @returns {Promise<any>}
895
+ */
896
+ load_led_style(name, dir) {
897
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
898
+ const len0 = WASM_VECTOR_LEN;
899
+ var ptr1 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
900
+ var len1 = WASM_VECTOR_LEN;
901
+ const ret = wasm.robot_load_led_style(this.ptr, ptr0, len0, ptr1, len1);
902
+ return takeObject(ret);
903
+ }
904
+ /**
905
+ * @param {any} style
906
+ * @returns {Promise<void>}
907
+ */
908
+ set_led_style(style) {
909
+ const ret = wasm.robot_set_led_style(this.ptr, addHeapObject(style));
910
+ return takeObject(ret);
911
+ }
912
+ /**
913
+ * @param {number} mode
914
+ * @param {number} speed
915
+ * @param {Int32Array} colors
916
+ * @returns {Promise<void>}
917
+ */
918
+ set_led(mode, speed, colors) {
919
+ const ptr0 = passArray32ToWasm0(colors, wasm.__wbindgen_malloc);
920
+ const len0 = WASM_VECTOR_LEN;
921
+ const ret = wasm.robot_set_led(this.ptr, mode, speed, ptr0, len0);
922
+ return takeObject(ret);
923
+ }
924
+ /**
925
+ * @param {number} voice
926
+ * @param {number} volume
927
+ * @returns {Promise<void>}
928
+ */
929
+ set_voice(voice, volume) {
930
+ const ret = wasm.robot_set_voice(this.ptr, voice, volume);
931
+ return takeObject(ret);
932
+ }
933
+ /**
934
+ * @param {number} mode
935
+ * @returns {Promise<void>}
936
+ */
937
+ set_fan(mode) {
938
+ const ret = wasm.robot_set_fan(this.ptr, mode);
939
+ return takeObject(ret);
940
+ }
941
+ /**
821
942
  * @returns {Promise<void>}
822
943
  */
823
944
  start_sys() {
@@ -978,28 +1099,25 @@ export class RobotSubscription {
978
1099
  }
979
1100
  }
980
1101
 
981
- export function __wbindgen_number_new(arg0) {
982
- const ret = arg0;
983
- return addHeapObject(ret);
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;
984
1110
  };
985
1111
 
986
1112
  export function __wbindgen_object_drop_ref(arg0) {
987
1113
  takeObject(arg0);
988
1114
  };
989
1115
 
990
- export function __wbg_robot_new(arg0) {
991
- const ret = Robot.__wrap(arg0);
992
- return addHeapObject(ret);
993
- };
994
-
995
- export function __wbindgen_string_new(arg0, arg1) {
996
- const ret = getStringFromWasm0(arg0, arg1);
997
- return addHeapObject(ret);
998
- };
999
-
1000
- export function __wbg_robotsubscription_new(arg0) {
1001
- const ret = RobotSubscription.__wrap(arg0);
1002
- return addHeapObject(ret);
1116
+ export function __wbindgen_number_get(arg0, arg1) {
1117
+ const obj = getObject(arg1);
1118
+ const ret = typeof(obj) === 'number' ? obj : undefined;
1119
+ getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
1120
+ getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
1003
1121
  };
1004
1122
 
1005
1123
  export function __wbindgen_string_get(arg0, arg1) {
@@ -1011,32 +1129,30 @@ export function __wbindgen_string_get(arg0, arg1) {
1011
1129
  getInt32Memory0()[arg0 / 4 + 0] = ptr0;
1012
1130
  };
1013
1131
 
1014
- export function __wbindgen_error_new(arg0, arg1) {
1015
- const ret = new Error(getStringFromWasm0(arg0, arg1));
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;
1136
+ };
1137
+
1138
+ export function __wbg_robotsubscription_new(arg0) {
1139
+ const ret = RobotSubscription.__wrap(arg0);
1016
1140
  return addHeapObject(ret);
1017
1141
  };
1018
1142
 
1019
- export function __wbindgen_cb_drop(arg0) {
1020
- const obj = takeObject(arg0).original;
1021
- if (obj.cnt-- == 1) {
1022
- obj.a = 0;
1023
- return true;
1024
- }
1025
- const ret = false;
1026
- return ret;
1143
+ export function __wbg_robot_new(arg0) {
1144
+ const ret = Robot.__wrap(arg0);
1145
+ return addHeapObject(ret);
1027
1146
  };
1028
1147
 
1029
- export function __wbindgen_boolean_get(arg0) {
1030
- const v = getObject(arg0);
1031
- const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
1032
- return ret;
1148
+ export function __wbindgen_number_new(arg0) {
1149
+ const ret = arg0;
1150
+ return addHeapObject(ret);
1033
1151
  };
1034
1152
 
1035
- export function __wbindgen_number_get(arg0, arg1) {
1036
- const obj = getObject(arg1);
1037
- const ret = typeof(obj) === 'number' ? obj : undefined;
1038
- getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
1039
- getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
1153
+ export function __wbindgen_string_new(arg0, arg1) {
1154
+ const ret = getStringFromWasm0(arg0, arg1);
1155
+ return addHeapObject(ret);
1040
1156
  };
1041
1157
 
1042
1158
  export function __wbindgen_is_bigint(arg0) {
@@ -1075,6 +1191,11 @@ export function __wbindgen_is_undefined(arg0) {
1075
1191
  return ret;
1076
1192
  };
1077
1193
 
1194
+ export function __wbindgen_error_new(arg0, arg1) {
1195
+ const ret = new Error(getStringFromWasm0(arg0, arg1));
1196
+ return addHeapObject(ret);
1197
+ };
1198
+
1078
1199
  export function __wbindgen_is_string(arg0) {
1079
1200
  const ret = typeof(getObject(arg0)) === 'string';
1080
1201
  return ret;
@@ -1085,34 +1206,34 @@ export function __wbindgen_object_clone_ref(arg0) {
1085
1206
  return addHeapObject(ret);
1086
1207
  };
1087
1208
 
1088
- export function __wbg_addEventListener_cbe4c6f619b032f3() { return handleError(function (arg0, arg1, arg2, arg3) {
1209
+ export function __wbg_addEventListener_615d4590d38da1c9() { return handleError(function (arg0, arg1, arg2, arg3) {
1089
1210
  getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
1090
1211
  }, arguments) };
1091
1212
 
1092
- export function __wbg_addEventListener_1fc744729ac6dc27() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
1213
+ export function __wbg_addEventListener_cf5b03cd29763277() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
1093
1214
  getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
1094
1215
  }, arguments) };
1095
1216
 
1096
- export function __wbg_dispatchEvent_9c61816a838ce0ce() { return handleError(function (arg0, arg1) {
1217
+ export function __wbg_dispatchEvent_615d1ccbba577081() { return handleError(function (arg0, arg1) {
1097
1218
  const ret = getObject(arg0).dispatchEvent(getObject(arg1));
1098
1219
  return ret;
1099
1220
  }, arguments) };
1100
1221
 
1101
- export function __wbg_removeEventListener_dd20475efce70084() { return handleError(function (arg0, arg1, arg2, arg3) {
1222
+ export function __wbg_removeEventListener_86fd19ed073cd1ed() { return handleError(function (arg0, arg1, arg2, arg3) {
1102
1223
  getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
1103
1224
  }, arguments) };
1104
1225
 
1105
- export function __wbg_wasClean_2af04e6cf2076497(arg0) {
1226
+ export function __wbg_wasClean_17e8b22af0b82315(arg0) {
1106
1227
  const ret = getObject(arg0).wasClean;
1107
1228
  return ret;
1108
1229
  };
1109
1230
 
1110
- export function __wbg_code_24e161f043adce8a(arg0) {
1231
+ export function __wbg_code_9743a5678b87b9e9(arg0) {
1111
1232
  const ret = getObject(arg0).code;
1112
1233
  return ret;
1113
1234
  };
1114
1235
 
1115
- export function __wbg_reason_40159cc3d2fc655d(arg0, arg1) {
1236
+ export function __wbg_reason_8585c102803c11b5(arg0, arg1) {
1116
1237
  const ret = getObject(arg1).reason;
1117
1238
  const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1118
1239
  const len0 = WASM_VECTOR_LEN;
@@ -1120,47 +1241,50 @@ export function __wbg_reason_40159cc3d2fc655d(arg0, arg1) {
1120
1241
  getInt32Memory0()[arg0 / 4 + 0] = ptr0;
1121
1242
  };
1122
1243
 
1123
- export function __wbg_newwitheventinitdict_36f3576f1bff6dbc() { return handleError(function (arg0, arg1, arg2) {
1244
+ export function __wbg_newwitheventinitdict_0e8e2070ae66ce38() { return handleError(function (arg0, arg1, arg2) {
1124
1245
  const ret = new CloseEvent(getStringFromWasm0(arg0, arg1), getObject(arg2));
1125
1246
  return addHeapObject(ret);
1126
1247
  }, arguments) };
1127
1248
 
1128
- export function __wbg_readyState_9c0f66433e329c9e(arg0) {
1249
+ export function __wbg_readyState_b3671943d2cedc2b(arg0) {
1129
1250
  const ret = getObject(arg0).readyState;
1130
1251
  return ret;
1131
1252
  };
1132
1253
 
1133
- export function __wbg_setbinaryType_ee55743ddf4beb37(arg0, arg1) {
1254
+ export function __wbg_setbinaryType_c9b2fa398c277601(arg0, arg1) {
1134
1255
  getObject(arg0).binaryType = takeObject(arg1);
1135
1256
  };
1136
1257
 
1137
- export function __wbg_new_d29e507f6606de91() { return handleError(function (arg0, arg1) {
1258
+ export function __wbg_new_8ad026ef33da9ab1() { return handleError(function (arg0, arg1) {
1138
1259
  const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
1139
1260
  return addHeapObject(ret);
1140
1261
  }, arguments) };
1141
1262
 
1142
- export function __wbg_close_45d053bea59e7746() { return handleError(function (arg0) {
1263
+ export function __wbg_close_546591d4b4350b36() { return handleError(function (arg0) {
1143
1264
  getObject(arg0).close();
1144
1265
  }, arguments) };
1145
1266
 
1146
- export function __wbg_send_80b256d87a6779e5() { return handleError(function (arg0, arg1, arg2) {
1267
+ export function __wbg_send_36f8bcb566f8afa0() { return handleError(function (arg0, arg1, arg2) {
1147
1268
  getObject(arg0).send(getStringFromWasm0(arg1, arg2));
1148
1269
  }, arguments) };
1149
1270
 
1150
- export function __wbg_send_640853f8eb0f0385() { return handleError(function (arg0, arg1, arg2) {
1271
+ export function __wbg_send_c1c0838681688262() { return handleError(function (arg0, arg1, arg2) {
1151
1272
  getObject(arg0).send(getArrayU8FromWasm0(arg1, arg2));
1152
1273
  }, arguments) };
1153
1274
 
1154
- export function __wbg_data_7b1f01f4e6a64fbe(arg0) {
1275
+ export function __wbg_data_af909e5dfe73e68c(arg0) {
1155
1276
  const ret = getObject(arg0).data;
1156
1277
  return addHeapObject(ret);
1157
1278
  };
1158
1279
 
1159
- export const __wbg_clearTimeout_23ee6db72c0ad922 = typeof clearTimeout == 'function' ? clearTimeout : notDefined('clearTimeout');
1280
+ export function __wbg_clearTimeout_76877dbc010e786d(arg0) {
1281
+ const ret = clearTimeout(takeObject(arg0));
1282
+ return addHeapObject(ret);
1283
+ };
1160
1284
 
1161
- export function __wbg_setTimeout_09074a1669d0f224() { return handleError(function (arg0, arg1) {
1285
+ export function __wbg_setTimeout_75cb9b6991a4031d() { return handleError(function (arg0, arg1) {
1162
1286
  const ret = setTimeout(getObject(arg0), arg1);
1163
- return ret;
1287
+ return addHeapObject(ret);
1164
1288
  }, arguments) };
1165
1289
 
1166
1290
  export function __wbindgen_jsval_loose_eq(arg0, arg1) {
@@ -1177,17 +1301,17 @@ export function __wbg_set_20cbc34131e76824(arg0, arg1, arg2) {
1177
1301
  getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
1178
1302
  };
1179
1303
 
1180
- export function __wbg_get_57245cc7d7c7619d(arg0, arg1) {
1304
+ export function __wbg_get_27fe3dac1c4d0224(arg0, arg1) {
1181
1305
  const ret = getObject(arg0)[arg1 >>> 0];
1182
1306
  return addHeapObject(ret);
1183
1307
  };
1184
1308
 
1185
- export function __wbg_length_6e3bbe7c8bd4dbd8(arg0) {
1309
+ export function __wbg_length_e498fbc24f9c1d4f(arg0) {
1186
1310
  const ret = getObject(arg0).length;
1187
1311
  return ret;
1188
1312
  };
1189
1313
 
1190
- export function __wbg_new_1d9a920c6bfc44a8() {
1314
+ export function __wbg_new_b525de17f44a8943() {
1191
1315
  const ret = new Array();
1192
1316
  return addHeapObject(ret);
1193
1317
  };
@@ -1197,56 +1321,56 @@ export function __wbindgen_is_function(arg0) {
1197
1321
  return ret;
1198
1322
  };
1199
1323
 
1200
- export function __wbg_next_579e583d33566a86(arg0) {
1324
+ export function __wbg_next_b7d530c04fd8b217(arg0) {
1201
1325
  const ret = getObject(arg0).next;
1202
1326
  return addHeapObject(ret);
1203
1327
  };
1204
1328
 
1205
- export function __wbg_next_aaef7c8aa5e212ac() { return handleError(function (arg0) {
1329
+ export function __wbg_next_88560ec06a094dea() { return handleError(function (arg0) {
1206
1330
  const ret = getObject(arg0).next();
1207
1331
  return addHeapObject(ret);
1208
1332
  }, arguments) };
1209
1333
 
1210
- export function __wbg_done_1b73b0672e15f234(arg0) {
1334
+ export function __wbg_done_1ebec03bbd919843(arg0) {
1211
1335
  const ret = getObject(arg0).done;
1212
1336
  return ret;
1213
1337
  };
1214
1338
 
1215
- export function __wbg_value_1ccc36bc03462d71(arg0) {
1339
+ export function __wbg_value_6ac8da5cc5b3efda(arg0) {
1216
1340
  const ret = getObject(arg0).value;
1217
1341
  return addHeapObject(ret);
1218
1342
  };
1219
1343
 
1220
- export function __wbg_iterator_6f9d4f28845f426c() {
1344
+ export function __wbg_iterator_55f114446221aa5a() {
1221
1345
  const ret = Symbol.iterator;
1222
1346
  return addHeapObject(ret);
1223
1347
  };
1224
1348
 
1225
- export function __wbg_get_765201544a2b6869() { return handleError(function (arg0, arg1) {
1349
+ export function __wbg_get_baf4855f9a986186() { return handleError(function (arg0, arg1) {
1226
1350
  const ret = Reflect.get(getObject(arg0), getObject(arg1));
1227
1351
  return addHeapObject(ret);
1228
1352
  }, arguments) };
1229
1353
 
1230
- export function __wbg_call_97ae9d8645dc388b() { return handleError(function (arg0, arg1) {
1354
+ export function __wbg_call_95d1ea488d03e4e8() { return handleError(function (arg0, arg1) {
1231
1355
  const ret = getObject(arg0).call(getObject(arg1));
1232
1356
  return addHeapObject(ret);
1233
1357
  }, arguments) };
1234
1358
 
1235
- export function __wbg_new_0b9bfdd97583284e() {
1359
+ export function __wbg_new_f9876326328f45ed() {
1236
1360
  const ret = new Object();
1237
1361
  return addHeapObject(ret);
1238
1362
  };
1239
1363
 
1240
- export function __wbg_set_a68214f35c417fa9(arg0, arg1, arg2) {
1364
+ export function __wbg_set_17224bc548dd1d7b(arg0, arg1, arg2) {
1241
1365
  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1242
1366
  };
1243
1367
 
1244
- export function __wbg_isArray_27c46c67f498e15d(arg0) {
1368
+ export function __wbg_isArray_39d28997bf6b96b4(arg0) {
1245
1369
  const ret = Array.isArray(getObject(arg0));
1246
1370
  return ret;
1247
1371
  };
1248
1372
 
1249
- export function __wbg_instanceof_ArrayBuffer_e5e48f4762c5610b(arg0) {
1373
+ export function __wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065(arg0) {
1250
1374
  let result;
1251
1375
  try {
1252
1376
  result = getObject(arg0) instanceof ArrayBuffer;
@@ -1257,7 +1381,7 @@ export function __wbg_instanceof_ArrayBuffer_e5e48f4762c5610b(arg0) {
1257
1381
  return ret;
1258
1382
  };
1259
1383
 
1260
- export function __wbg_instanceof_Error_56b496a10a56de66(arg0) {
1384
+ export function __wbg_instanceof_Error_749a7378f4439ee0(arg0) {
1261
1385
  let result;
1262
1386
  try {
1263
1387
  result = getObject(arg0) instanceof Error;
@@ -1268,44 +1392,44 @@ export function __wbg_instanceof_Error_56b496a10a56de66(arg0) {
1268
1392
  return ret;
1269
1393
  };
1270
1394
 
1271
- export function __wbg_message_fe2af63ccc8985bc(arg0) {
1395
+ export function __wbg_message_a95c3ef248e4b57a(arg0) {
1272
1396
  const ret = getObject(arg0).message;
1273
1397
  return addHeapObject(ret);
1274
1398
  };
1275
1399
 
1276
- export function __wbg_name_48eda3ae6aa697ca(arg0) {
1400
+ export function __wbg_name_c69a20c4b1197dc0(arg0) {
1277
1401
  const ret = getObject(arg0).name;
1278
1402
  return addHeapObject(ret);
1279
1403
  };
1280
1404
 
1281
- export function __wbg_toString_73c9b562dccf34bd(arg0) {
1405
+ export function __wbg_toString_cec163b212643722(arg0) {
1282
1406
  const ret = getObject(arg0).toString();
1283
1407
  return addHeapObject(ret);
1284
1408
  };
1285
1409
 
1286
- export function __wbg_call_168da88779e35f61() { return handleError(function (arg0, arg1, arg2) {
1410
+ export function __wbg_call_9495de66fdbe016b() { return handleError(function (arg0, arg1, arg2) {
1287
1411
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
1288
1412
  return addHeapObject(ret);
1289
1413
  }, arguments) };
1290
1414
 
1291
- export function __wbg_isSafeInteger_dfa0593e8d7ac35a(arg0) {
1415
+ export function __wbg_isSafeInteger_8c4789029e885159(arg0) {
1292
1416
  const ret = Number.isSafeInteger(getObject(arg0));
1293
1417
  return ret;
1294
1418
  };
1295
1419
 
1296
- export function __wbg_entries_65a76a413fc91037(arg0) {
1420
+ export function __wbg_entries_4e1315b774245952(arg0) {
1297
1421
  const ret = Object.entries(getObject(arg0));
1298
1422
  return addHeapObject(ret);
1299
1423
  };
1300
1424
 
1301
- export function __wbg_new_9962f939219f1820(arg0, arg1) {
1425
+ export function __wbg_new_9d3a9ce4282a18a8(arg0, arg1) {
1302
1426
  try {
1303
1427
  var state0 = {a: arg0, b: arg1};
1304
1428
  var cb0 = (arg0, arg1) => {
1305
1429
  const a = state0.a;
1306
1430
  state0.a = 0;
1307
1431
  try {
1308
- return __wbg_adapter_211(a, state0.b, arg0, arg1);
1432
+ return __wbg_adapter_220(a, state0.b, arg0, arg1);
1309
1433
  } finally {
1310
1434
  state0.a = a;
1311
1435
  }
@@ -1317,36 +1441,36 @@ export function __wbg_new_9962f939219f1820(arg0, arg1) {
1317
1441
  }
1318
1442
  };
1319
1443
 
1320
- export function __wbg_resolve_99fe17964f31ffc0(arg0) {
1444
+ export function __wbg_resolve_fd40f858d9db1a04(arg0) {
1321
1445
  const ret = Promise.resolve(getObject(arg0));
1322
1446
  return addHeapObject(ret);
1323
1447
  };
1324
1448
 
1325
- export function __wbg_then_11f7a54d67b4bfad(arg0, arg1) {
1449
+ export function __wbg_then_ec5db6d509eb475f(arg0, arg1) {
1326
1450
  const ret = getObject(arg0).then(getObject(arg1));
1327
1451
  return addHeapObject(ret);
1328
1452
  };
1329
1453
 
1330
- export function __wbg_buffer_3f3d764d4747d564(arg0) {
1454
+ export function __wbg_buffer_cf65c07de34b9a08(arg0) {
1331
1455
  const ret = getObject(arg0).buffer;
1332
1456
  return addHeapObject(ret);
1333
1457
  };
1334
1458
 
1335
- export function __wbg_new_8c3f0052272a457a(arg0) {
1459
+ export function __wbg_new_537b7341ce90bb31(arg0) {
1336
1460
  const ret = new Uint8Array(getObject(arg0));
1337
1461
  return addHeapObject(ret);
1338
1462
  };
1339
1463
 
1340
- export function __wbg_set_83db9690f9353e79(arg0, arg1, arg2) {
1464
+ export function __wbg_set_17499e8aa4003ebd(arg0, arg1, arg2) {
1341
1465
  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
1342
1466
  };
1343
1467
 
1344
- export function __wbg_length_9e1ae1900cb0fbd5(arg0) {
1468
+ export function __wbg_length_27a2afe8ab42b09f(arg0) {
1345
1469
  const ret = getObject(arg0).length;
1346
1470
  return ret;
1347
1471
  };
1348
1472
 
1349
- export function __wbg_instanceof_Uint8Array_971eeda69eb75003(arg0) {
1473
+ export function __wbg_instanceof_Uint8Array_01cebe79ca606cca(arg0) {
1350
1474
  let result;
1351
1475
  try {
1352
1476
  result = getObject(arg0) instanceof Uint8Array;
@@ -1357,7 +1481,7 @@ export function __wbg_instanceof_Uint8Array_971eeda69eb75003(arg0) {
1357
1481
  return ret;
1358
1482
  };
1359
1483
 
1360
- export function __wbg_set_bf3f89b92d5a34bf() { return handleError(function (arg0, arg1, arg2) {
1484
+ export function __wbg_set_6aa458a4ebdb65cb() { return handleError(function (arg0, arg1, arg2) {
1361
1485
  const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1362
1486
  return ret;
1363
1487
  }, arguments) };
@@ -1365,7 +1489,7 @@ export function __wbg_set_bf3f89b92d5a34bf() { return handleError(function (arg0
1365
1489
  export function __wbindgen_bigint_get_as_i64(arg0, arg1) {
1366
1490
  const v = getObject(arg1);
1367
1491
  const ret = typeof(v) === 'bigint' ? v : undefined;
1368
- getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0n : ret;
1492
+ getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
1369
1493
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
1370
1494
  };
1371
1495
 
@@ -1386,33 +1510,33 @@ export function __wbindgen_memory() {
1386
1510
  return addHeapObject(ret);
1387
1511
  };
1388
1512
 
1389
- export function __wbindgen_closure_wrapper1400(arg0, arg1, arg2) {
1390
- const ret = makeMutClosure(arg0, arg1, 532, __wbg_adapter_48);
1513
+ export function __wbindgen_closure_wrapper1520(arg0, arg1, arg2) {
1514
+ const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_48);
1391
1515
  return addHeapObject(ret);
1392
1516
  };
1393
1517
 
1394
- export function __wbindgen_closure_wrapper1402(arg0, arg1, arg2) {
1395
- const ret = makeMutClosure(arg0, arg1, 532, __wbg_adapter_48);
1518
+ export function __wbindgen_closure_wrapper1522(arg0, arg1, arg2) {
1519
+ const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_48);
1396
1520
  return addHeapObject(ret);
1397
1521
  };
1398
1522
 
1399
- export function __wbindgen_closure_wrapper1404(arg0, arg1, arg2) {
1400
- const ret = makeMutClosure(arg0, arg1, 532, __wbg_adapter_53);
1523
+ export function __wbindgen_closure_wrapper1524(arg0, arg1, arg2) {
1524
+ const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_48);
1401
1525
  return addHeapObject(ret);
1402
1526
  };
1403
1527
 
1404
- export function __wbindgen_closure_wrapper1406(arg0, arg1, arg2) {
1405
- const ret = makeMutClosure(arg0, arg1, 532, __wbg_adapter_48);
1528
+ export function __wbindgen_closure_wrapper1526(arg0, arg1, arg2) {
1529
+ const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_55);
1406
1530
  return addHeapObject(ret);
1407
1531
  };
1408
1532
 
1409
- export function __wbindgen_closure_wrapper1872(arg0, arg1, arg2) {
1410
- const ret = makeMutClosure(arg0, arg1, 626, __wbg_adapter_58);
1533
+ export function __wbindgen_closure_wrapper2010(arg0, arg1, arg2) {
1534
+ const ret = makeMutClosure(arg0, arg1, 673, __wbg_adapter_58);
1411
1535
  return addHeapObject(ret);
1412
1536
  };
1413
1537
 
1414
- export function __wbindgen_closure_wrapper1906(arg0, arg1, arg2) {
1415
- const ret = makeMutClosure(arg0, arg1, 640, __wbg_adapter_61);
1538
+ export function __wbindgen_closure_wrapper2044(arg0, arg1, arg2) {
1539
+ const ret = makeMutClosure(arg0, arg1, 687, __wbg_adapter_61);
1416
1540
  return addHeapObject(ret);
1417
1541
  };
1418
1542
 
package/lebai_sdk_bg.wasm CHANGED
Binary file
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "lebai_sdk",
3
3
  "description": "lebai_sdk",
4
- "version": "0.1.5",
4
+ "version": "0.1.7",
5
5
  "license": "SEE LICENSE IN LICENSE",
6
6
  "repository": {
7
7
  "type": "git",