@bitwarden/sdk-internal 0.2.0-main.232 → 0.2.0-main.233

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/VERSION CHANGED
@@ -1 +1 @@
1
- bdcb5f5480053b181dab1e6c80c5df0ab93e440f
1
+ f1fc29b660d4669b7618fbd70d42d217e22619d3
@@ -1,20 +1,5 @@
1
1
  /* tslint:disable */
2
2
  /* eslint-disable */
3
- /**
4
- * Registers a DiscoverHandler so that the client can respond to DiscoverRequests.
5
- */
6
- export function ipcRegisterDiscoverHandler(
7
- ipc_client: IpcClient,
8
- response: DiscoverResponse,
9
- ): Promise<void>;
10
- /**
11
- * Sends a DiscoverRequest to the specified destination and returns the response.
12
- */
13
- export function ipcRequestDiscover(
14
- ipc_client: IpcClient,
15
- destination: Endpoint,
16
- abort_signal?: AbortSignal | null,
17
- ): Promise<DiscoverResponse>;
18
3
  export function set_log_level(level: LogLevel): void;
19
4
  export function init_sdk(log_level?: LogLevel | null): void;
20
5
  /**
@@ -44,6 +29,21 @@ export function generate_ssh_key(key_algorithm: KeyAlgorithm): SshKeyView;
44
29
  * - `Err(UnsupportedKeyType)` if the key type is not supported
45
30
  */
46
31
  export function import_ssh_key(imported_key: string, password?: string | null): SshKeyView;
32
+ /**
33
+ * Registers a DiscoverHandler so that the client can respond to DiscoverRequests.
34
+ */
35
+ export function ipcRegisterDiscoverHandler(
36
+ ipc_client: IpcClient,
37
+ response: DiscoverResponse,
38
+ ): Promise<void>;
39
+ /**
40
+ * Sends a DiscoverRequest to the specified destination and returns the response.
41
+ */
42
+ export function ipcRequestDiscover(
43
+ ipc_client: IpcClient,
44
+ destination: Endpoint,
45
+ abort_signal?: AbortSignal | null,
46
+ ): Promise<DiscoverResponse>;
47
47
  export enum CardLinkedIdType {
48
48
  CardholderName = 300,
49
49
  ExpMonth = 301,
@@ -112,6 +112,52 @@ export enum UriMatchType {
112
112
  RegularExpression = 4,
113
113
  Never = 5,
114
114
  }
115
+
116
+ import { Tagged } from "type-fest";
117
+
118
+ /**
119
+ * A string that **MUST** be a valid UUID.
120
+ *
121
+ * Never create or cast to this type directly, use the `uuid<T>()` function instead.
122
+ */
123
+ // TODO: Uncomment this when the `uuid` crate is used.
124
+ // export type Uuid = unknown;
125
+
126
+ export type Uuid = string;
127
+
128
+ /**
129
+ * RFC3339 compliant date-time string.
130
+ * @typeParam T - Not used in JavaScript.
131
+ */
132
+ export type DateTime<T = unknown> = string;
133
+
134
+ /**
135
+ * UTC date-time string. Not used in JavaScript.
136
+ */
137
+ export type Utc = unknown;
138
+
139
+ /**
140
+ * An integer that is known not to equal zero.
141
+ */
142
+ export type NonZeroU32 = number;
143
+
144
+ export interface Repository<T> {
145
+ get(id: string): Promise<T | null>;
146
+ list(): Promise<T[]>;
147
+ set(id: string, value: T): Promise<void>;
148
+ remove(id: string): Promise<void>;
149
+ }
150
+
151
+ export interface TokenProvider {
152
+ get_access_token(): Promise<string | undefined>;
153
+ }
154
+
155
+ export interface TestError extends Error {
156
+ name: "TestError";
157
+ }
158
+
159
+ export function isTestError(error: any): error is TestError;
160
+
115
161
  /**
116
162
  * State used for initializing the user cryptographic state.
117
163
  */
@@ -1270,51 +1316,6 @@ export interface Attachment {
1270
1316
  key: EncString | undefined;
1271
1317
  }
1272
1318
 
1273
- import { Tagged } from "type-fest";
1274
-
1275
- /**
1276
- * A string that **MUST** be a valid UUID.
1277
- *
1278
- * Never create or cast to this type directly, use the `uuid<T>()` function instead.
1279
- */
1280
- // TODO: Uncomment this when the `uuid` crate is used.
1281
- // export type Uuid = unknown;
1282
-
1283
- export type Uuid = string;
1284
-
1285
- /**
1286
- * RFC3339 compliant date-time string.
1287
- * @typeParam T - Not used in JavaScript.
1288
- */
1289
- export type DateTime<T = unknown> = string;
1290
-
1291
- /**
1292
- * UTC date-time string. Not used in JavaScript.
1293
- */
1294
- export type Utc = unknown;
1295
-
1296
- /**
1297
- * An integer that is known not to equal zero.
1298
- */
1299
- export type NonZeroU32 = number;
1300
-
1301
- export interface Repository<T> {
1302
- get(id: string): Promise<T | null>;
1303
- list(): Promise<T[]>;
1304
- set(id: string, value: T): Promise<void>;
1305
- remove(id: string): Promise<void>;
1306
- }
1307
-
1308
- export interface TokenProvider {
1309
- get_access_token(): Promise<string | undefined>;
1310
- }
1311
-
1312
- export interface TestError extends Error {
1313
- name: "TestError";
1314
- }
1315
-
1316
- export function isTestError(error: any): error is TestError;
1317
-
1318
1319
  export class AttachmentsClient {
1319
1320
  private constructor();
1320
1321
  free(): void;
@@ -243,6 +243,93 @@ function debugString(val) {
243
243
  // TODO we could test for more things here, like `Set`s and `Map`s.
244
244
  return className;
245
245
  }
246
+ /**
247
+ * @param {LogLevel} level
248
+ */
249
+ export function set_log_level(level) {
250
+ wasm.set_log_level(level);
251
+ }
252
+
253
+ /**
254
+ * @param {LogLevel | null} [log_level]
255
+ */
256
+ export function init_sdk(log_level) {
257
+ wasm.init_sdk(isLikeNone(log_level) ? 5 : log_level);
258
+ }
259
+
260
+ function passArray8ToWasm0(arg, malloc) {
261
+ const ptr = malloc(arg.length * 1, 1) >>> 0;
262
+ getUint8ArrayMemory0().set(arg, ptr / 1);
263
+ WASM_VECTOR_LEN = arg.length;
264
+ return ptr;
265
+ }
266
+ /**
267
+ * Generate a new SSH key pair
268
+ *
269
+ * # Arguments
270
+ * - `key_algorithm` - The algorithm to use for the key pair
271
+ *
272
+ * # Returns
273
+ * - `Ok(SshKey)` if the key was successfully generated
274
+ * - `Err(KeyGenerationError)` if the key could not be generated
275
+ * @param {KeyAlgorithm} key_algorithm
276
+ * @returns {SshKeyView}
277
+ */
278
+ export function generate_ssh_key(key_algorithm) {
279
+ try {
280
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
281
+ wasm.generate_ssh_key(retptr, addHeapObject(key_algorithm));
282
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
283
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
284
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
285
+ if (r2) {
286
+ throw takeObject(r1);
287
+ }
288
+ return takeObject(r0);
289
+ } finally {
290
+ wasm.__wbindgen_add_to_stack_pointer(16);
291
+ }
292
+ }
293
+
294
+ /**
295
+ * Convert a PCKS8 or OpenSSH encrypted or unencrypted private key
296
+ * to an OpenSSH private key with public key and fingerprint
297
+ *
298
+ * # Arguments
299
+ * - `imported_key` - The private key to convert
300
+ * - `password` - The password to use for decrypting the key
301
+ *
302
+ * # Returns
303
+ * - `Ok(SshKey)` if the key was successfully coneverted
304
+ * - `Err(PasswordRequired)` if the key is encrypted and no password was provided
305
+ * - `Err(WrongPassword)` if the password provided is incorrect
306
+ * - `Err(ParsingError)` if the key could not be parsed
307
+ * - `Err(UnsupportedKeyType)` if the key type is not supported
308
+ * @param {string} imported_key
309
+ * @param {string | null} [password]
310
+ * @returns {SshKeyView}
311
+ */
312
+ export function import_ssh_key(imported_key, password) {
313
+ try {
314
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
315
+ const ptr0 = passStringToWasm0(imported_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
316
+ const len0 = WASM_VECTOR_LEN;
317
+ var ptr1 = isLikeNone(password)
318
+ ? 0
319
+ : passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
320
+ var len1 = WASM_VECTOR_LEN;
321
+ wasm.import_ssh_key(retptr, ptr0, len0, ptr1, len1);
322
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
323
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
324
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
325
+ if (r2) {
326
+ throw takeObject(r1);
327
+ }
328
+ return takeObject(r0);
329
+ } finally {
330
+ wasm.__wbindgen_add_to_stack_pointer(16);
331
+ }
332
+ }
246
333
 
247
334
  let stack_pointer = 128;
248
335
 
@@ -251,6 +338,19 @@ function addBorrowedObject(obj) {
251
338
  heap[--stack_pointer] = obj;
252
339
  return stack_pointer;
253
340
  }
341
+ /**
342
+ * @param {any} error
343
+ * @returns {boolean}
344
+ */
345
+ export function isTestError(error) {
346
+ try {
347
+ const ret = wasm.isTestError(addBorrowedObject(error));
348
+ return ret !== 0;
349
+ } finally {
350
+ heap[stack_pointer++] = undefined;
351
+ }
352
+ }
353
+
254
354
  /**
255
355
  * @param {any} error
256
356
  * @returns {boolean}
@@ -400,13 +500,6 @@ export function isPassphraseError(error) {
400
500
  }
401
501
  }
402
502
 
403
- function passArray8ToWasm0(arg, malloc) {
404
- const ptr = malloc(arg.length * 1, 1) >>> 0;
405
- getUint8ArrayMemory0().set(arg, ptr / 1);
406
- WASM_VECTOR_LEN = arg.length;
407
- return ptr;
408
- }
409
-
410
503
  function _assertClass(instance, klass) {
411
504
  if (!(instance instanceof klass)) {
412
505
  throw new Error(`expected instance of ${klass.name}`);
@@ -688,125 +781,23 @@ export function isEncryptFileError(error) {
688
781
  }
689
782
  }
690
783
 
691
- /**
692
- * @param {LogLevel} level
693
- */
694
- export function set_log_level(level) {
695
- wasm.set_log_level(level);
696
- }
697
-
698
- /**
699
- * @param {LogLevel | null} [log_level]
700
- */
701
- export function init_sdk(log_level) {
702
- wasm.init_sdk(isLikeNone(log_level) ? 5 : log_level);
703
- }
704
-
705
- /**
706
- * Generate a new SSH key pair
707
- *
708
- * # Arguments
709
- * - `key_algorithm` - The algorithm to use for the key pair
710
- *
711
- * # Returns
712
- * - `Ok(SshKey)` if the key was successfully generated
713
- * - `Err(KeyGenerationError)` if the key could not be generated
714
- * @param {KeyAlgorithm} key_algorithm
715
- * @returns {SshKeyView}
716
- */
717
- export function generate_ssh_key(key_algorithm) {
718
- try {
719
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
720
- wasm.generate_ssh_key(retptr, addHeapObject(key_algorithm));
721
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
722
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
723
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
724
- if (r2) {
725
- throw takeObject(r1);
726
- }
727
- return takeObject(r0);
728
- } finally {
729
- wasm.__wbindgen_add_to_stack_pointer(16);
730
- }
731
- }
732
-
733
- /**
734
- * Convert a PCKS8 or OpenSSH encrypted or unencrypted private key
735
- * to an OpenSSH private key with public key and fingerprint
736
- *
737
- * # Arguments
738
- * - `imported_key` - The private key to convert
739
- * - `password` - The password to use for decrypting the key
740
- *
741
- * # Returns
742
- * - `Ok(SshKey)` if the key was successfully coneverted
743
- * - `Err(PasswordRequired)` if the key is encrypted and no password was provided
744
- * - `Err(WrongPassword)` if the password provided is incorrect
745
- * - `Err(ParsingError)` if the key could not be parsed
746
- * - `Err(UnsupportedKeyType)` if the key type is not supported
747
- * @param {string} imported_key
748
- * @param {string | null} [password]
749
- * @returns {SshKeyView}
750
- */
751
- export function import_ssh_key(imported_key, password) {
752
- try {
753
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
754
- const ptr0 = passStringToWasm0(imported_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
755
- const len0 = WASM_VECTOR_LEN;
756
- var ptr1 = isLikeNone(password)
757
- ? 0
758
- : passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
759
- var len1 = WASM_VECTOR_LEN;
760
- wasm.import_ssh_key(retptr, ptr0, len0, ptr1, len1);
761
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
762
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
763
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
764
- if (r2) {
765
- throw takeObject(r1);
766
- }
767
- return takeObject(r0);
768
- } finally {
769
- wasm.__wbindgen_add_to_stack_pointer(16);
770
- }
771
- }
772
-
773
- /**
774
- * @param {any} error
775
- * @returns {boolean}
776
- */
777
- export function isTestError(error) {
778
- try {
779
- const ret = wasm.isTestError(addBorrowedObject(error));
780
- return ret !== 0;
781
- } finally {
782
- heap[stack_pointer++] = undefined;
783
- }
784
- }
785
-
786
784
  function __wbg_adapter_54(arg0, arg1) {
787
- wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h31333524c3115e44(
785
+ wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h091423ccfc08366e(
788
786
  arg0,
789
787
  arg1,
790
788
  );
791
789
  }
792
790
 
793
- function __wbg_adapter_57(arg0, arg1) {
794
- wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h2b093e5f83b42fbd(
795
- arg0,
796
- arg1,
797
- );
798
- }
799
-
800
- function __wbg_adapter_60(arg0, arg1, arg2) {
801
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb01d8be1001e4f40(
791
+ function __wbg_adapter_59(arg0, arg1, arg2) {
792
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb3d7232059e1cc02(
802
793
  arg0,
803
794
  arg1,
804
795
  addHeapObject(arg2),
805
796
  );
806
797
  }
807
798
 
808
- function __wbg_adapter_301(arg0, arg1, arg2, arg3) {
809
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h8776500d04a3e634(
799
+ function __wbg_adapter_300(arg0, arg1, arg2, arg3) {
800
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h54a8613170fef18e(
810
801
  arg0,
811
802
  arg1,
812
803
  addHeapObject(arg2),
@@ -1136,7 +1127,7 @@ export class BitwardenClient {
1136
1127
  * @returns {VaultClient}
1137
1128
  */
1138
1129
  vault() {
1139
- const ret = wasm.bitwardenclient_crypto(this.__wbg_ptr);
1130
+ const ret = wasm.bitwardenclient_vault(this.__wbg_ptr);
1140
1131
  return VaultClient.__wrap(ret);
1141
1132
  }
1142
1133
  /**
@@ -1152,14 +1143,14 @@ export class BitwardenClient {
1152
1143
  * @returns {GeneratorClient}
1153
1144
  */
1154
1145
  generator() {
1155
- const ret = wasm.bitwardenclient_crypto(this.__wbg_ptr);
1146
+ const ret = wasm.bitwardenclient_generator(this.__wbg_ptr);
1156
1147
  return GeneratorClient.__wrap(ret);
1157
1148
  }
1158
1149
  /**
1159
1150
  * @returns {ExporterClient}
1160
1151
  */
1161
1152
  exporters() {
1162
- const ret = wasm.bitwardenclient_crypto(this.__wbg_ptr);
1153
+ const ret = wasm.bitwardenclient_exporters(this.__wbg_ptr);
1163
1154
  return ExporterClient.__wrap(ret);
1164
1155
  }
1165
1156
  }
@@ -2424,7 +2415,7 @@ export class PlatformClient {
2424
2415
  * @returns {StateClient}
2425
2416
  */
2426
2417
  state() {
2427
- const ret = wasm.bitwardenclient_platform(this.__wbg_ptr);
2418
+ const ret = wasm.platformclient_state(this.__wbg_ptr);
2428
2419
  return StateClient.__wrap(ret);
2429
2420
  }
2430
2421
  }
@@ -3509,7 +3500,7 @@ export function __wbg_getTime_46267b1c24877e30(arg0) {
3509
3500
  return ret;
3510
3501
  }
3511
3502
 
3512
- export function __wbg_get_1620f903ed9a676f() {
3503
+ export function __wbg_get_1e936e9c132ed56a() {
3513
3504
  return handleError(function (arg0, arg1, arg2) {
3514
3505
  let deferred0_0;
3515
3506
  let deferred0_1;
@@ -3524,19 +3515,7 @@ export function __wbg_get_1620f903ed9a676f() {
3524
3515
  }, arguments);
3525
3516
  }
3526
3517
 
3527
- export function __wbg_get_67b2ba62fc30de12() {
3528
- return handleError(function (arg0, arg1) {
3529
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
3530
- return addHeapObject(ret);
3531
- }, arguments);
3532
- }
3533
-
3534
- export function __wbg_get_b9b93047fe3cf45b(arg0, arg1) {
3535
- const ret = getObject(arg0)[arg1 >>> 0];
3536
- return addHeapObject(ret);
3537
- }
3538
-
3539
- export function __wbg_get_e94e796a5527c131() {
3518
+ export function __wbg_get_63d4ac1519cd683d() {
3540
3519
  return handleError(function (arg0, arg1, arg2) {
3541
3520
  let deferred0_0;
3542
3521
  let deferred0_1;
@@ -3551,7 +3530,19 @@ export function __wbg_get_e94e796a5527c131() {
3551
3530
  }, arguments);
3552
3531
  }
3553
3532
 
3554
- export function __wbg_getaccesstoken_115c028df526c10b(arg0) {
3533
+ export function __wbg_get_67b2ba62fc30de12() {
3534
+ return handleError(function (arg0, arg1) {
3535
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
3536
+ return addHeapObject(ret);
3537
+ }, arguments);
3538
+ }
3539
+
3540
+ export function __wbg_get_b9b93047fe3cf45b(arg0, arg1) {
3541
+ const ret = getObject(arg0)[arg1 >>> 0];
3542
+ return addHeapObject(ret);
3543
+ }
3544
+
3545
+ export function __wbg_getaccesstoken_5c1081642adb54b3(arg0) {
3555
3546
  const ret = getObject(arg0).get_access_token();
3556
3547
  return addHeapObject(ret);
3557
3548
  }
@@ -3656,14 +3647,14 @@ export function __wbg_length_e2d2a49132c1b256(arg0) {
3656
3647
  return ret;
3657
3648
  }
3658
3649
 
3659
- export function __wbg_list_2a92e7addacc7a2d() {
3650
+ export function __wbg_list_d51438674d2a6409() {
3660
3651
  return handleError(function (arg0) {
3661
3652
  const ret = getObject(arg0).list();
3662
3653
  return addHeapObject(ret);
3663
3654
  }, arguments);
3664
3655
  }
3665
3656
 
3666
- export function __wbg_list_6d9131c88a8d0a17() {
3657
+ export function __wbg_list_ee640fea1b320673() {
3667
3658
  return handleError(function (arg0) {
3668
3659
  const ret = getObject(arg0).list();
3669
3660
  return addHeapObject(ret);
@@ -3698,7 +3689,7 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
3698
3689
  const a = state0.a;
3699
3690
  state0.a = 0;
3700
3691
  try {
3701
- return __wbg_adapter_301(a, state0.b, arg0, arg1);
3692
+ return __wbg_adapter_300(a, state0.b, arg0, arg1);
3702
3693
  } finally {
3703
3694
  state0.a = a;
3704
3695
  }
@@ -3840,7 +3831,7 @@ export function __wbg_randomFillSync_ac0988aba3254290() {
3840
3831
  }, arguments);
3841
3832
  }
3842
3833
 
3843
- export function __wbg_remove_050f4c22aba9e8c7() {
3834
+ export function __wbg_remove_1b7f523b274e28d8() {
3844
3835
  return handleError(function (arg0, arg1, arg2) {
3845
3836
  let deferred0_0;
3846
3837
  let deferred0_1;
@@ -3855,7 +3846,7 @@ export function __wbg_remove_050f4c22aba9e8c7() {
3855
3846
  }, arguments);
3856
3847
  }
3857
3848
 
3858
- export function __wbg_remove_c9b8a1e5e4b15f5f() {
3849
+ export function __wbg_remove_b9507a7e3319b5a5() {
3859
3850
  return handleError(function (arg0, arg1, arg2) {
3860
3851
  let deferred0_0;
3861
3852
  let deferred0_1;
@@ -3898,15 +3889,7 @@ export function __wbg_set_37837023f3d740e8(arg0, arg1, arg2) {
3898
3889
  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
3899
3890
  }
3900
3891
 
3901
- export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
3902
- getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
3903
- }
3904
-
3905
- export function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) {
3906
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
3907
- }
3908
-
3909
- export function __wbg_set_c0f7f01bcd881751() {
3892
+ export function __wbg_set_39adcc20133bca63() {
3910
3893
  return handleError(function (arg0, arg1, arg2, arg3) {
3911
3894
  let deferred0_0;
3912
3895
  let deferred0_1;
@@ -3921,7 +3904,15 @@ export function __wbg_set_c0f7f01bcd881751() {
3921
3904
  }, arguments);
3922
3905
  }
3923
3906
 
3924
- export function __wbg_set_f85eb67e00c0abef() {
3907
+ export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
3908
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
3909
+ }
3910
+
3911
+ export function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) {
3912
+ getObject(arg0).set(getObject(arg1), arg2 >>> 0);
3913
+ }
3914
+
3915
+ export function __wbg_set_7a0f45f61f570f10() {
3925
3916
  return handleError(function (arg0, arg1, arg2, arg3) {
3926
3917
  let deferred0_0;
3927
3918
  let deferred0_1;
@@ -4124,18 +4115,18 @@ export function __wbindgen_cb_drop(arg0) {
4124
4115
  return ret;
4125
4116
  }
4126
4117
 
4127
- export function __wbindgen_closure_wrapper3245(arg0, arg1, arg2) {
4128
- const ret = makeMutClosure(arg0, arg1, 1034, __wbg_adapter_54);
4118
+ export function __wbindgen_closure_wrapper3124(arg0, arg1, arg2) {
4119
+ const ret = makeMutClosure(arg0, arg1, 221, __wbg_adapter_54);
4129
4120
  return addHeapObject(ret);
4130
4121
  }
4131
4122
 
4132
- export function __wbindgen_closure_wrapper4086(arg0, arg1, arg2) {
4133
- const ret = makeMutClosure(arg0, arg1, 1118, __wbg_adapter_57);
4123
+ export function __wbindgen_closure_wrapper5341(arg0, arg1, arg2) {
4124
+ const ret = makeMutClosure(arg0, arg1, 246, __wbg_adapter_54);
4134
4125
  return addHeapObject(ret);
4135
4126
  }
4136
4127
 
4137
- export function __wbindgen_closure_wrapper4522(arg0, arg1, arg2) {
4138
- const ret = makeMutClosure(arg0, arg1, 1251, __wbg_adapter_60);
4128
+ export function __wbindgen_closure_wrapper5698(arg0, arg1, arg2) {
4129
+ const ret = makeMutClosure(arg0, arg1, 272, __wbg_adapter_59);
4139
4130
  return addHeapObject(ret);
4140
4131
  }
4141
4132
 
Binary file