@bitwarden/sdk-internal 0.2.0-main.373 → 0.2.0-main.375

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.
@@ -3,16 +3,6 @@ export function __wbg_set_wasm(val) {
3
3
  wasm = val;
4
4
  }
5
5
 
6
- const heap = new Array(128).fill(undefined);
7
-
8
- heap.push(undefined, null, true, false);
9
-
10
- function getObject(idx) {
11
- return heap[idx];
12
- }
13
-
14
- let WASM_VECTOR_LEN = 0;
15
-
16
6
  let cachedUint8ArrayMemory0 = null;
17
7
 
18
8
  function getUint8ArrayMemory0() {
@@ -22,24 +12,60 @@ function getUint8ArrayMemory0() {
22
12
  return cachedUint8ArrayMemory0;
23
13
  }
24
14
 
25
- const lTextEncoder =
26
- typeof TextEncoder === "undefined" ? (0, module.require)("util").TextEncoder : TextEncoder;
15
+ let cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
27
16
 
28
- let cachedTextEncoder = new lTextEncoder("utf-8");
17
+ cachedTextDecoder.decode();
29
18
 
30
- const encodeString =
31
- typeof cachedTextEncoder.encodeInto === "function"
32
- ? function (arg, view) {
33
- return cachedTextEncoder.encodeInto(arg, view);
34
- }
35
- : function (arg, view) {
36
- const buf = cachedTextEncoder.encode(arg);
37
- view.set(buf);
38
- return {
39
- read: arg.length,
40
- written: buf.length,
41
- };
42
- };
19
+ const MAX_SAFARI_DECODE_BYTES = 2146435072;
20
+ let numBytesDecoded = 0;
21
+ function decodeText(ptr, len) {
22
+ numBytesDecoded += len;
23
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
24
+ cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
25
+ cachedTextDecoder.decode();
26
+ numBytesDecoded = len;
27
+ }
28
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
29
+ }
30
+
31
+ function getStringFromWasm0(ptr, len) {
32
+ ptr = ptr >>> 0;
33
+ return decodeText(ptr, len);
34
+ }
35
+
36
+ let heap = new Array(128).fill(undefined);
37
+
38
+ heap.push(undefined, null, true, false);
39
+
40
+ let heap_next = heap.length;
41
+
42
+ function addHeapObject(obj) {
43
+ if (heap_next === heap.length) heap.push(heap.length + 1);
44
+ const idx = heap_next;
45
+ heap_next = heap[idx];
46
+
47
+ heap[idx] = obj;
48
+ return idx;
49
+ }
50
+
51
+ function getObject(idx) {
52
+ return heap[idx];
53
+ }
54
+
55
+ let WASM_VECTOR_LEN = 0;
56
+
57
+ const cachedTextEncoder = new TextEncoder();
58
+
59
+ if (!("encodeInto" in cachedTextEncoder)) {
60
+ cachedTextEncoder.encodeInto = function (arg, view) {
61
+ const buf = cachedTextEncoder.encode(arg);
62
+ view.set(buf);
63
+ return {
64
+ read: arg.length,
65
+ written: buf.length,
66
+ };
67
+ };
68
+ }
43
69
 
44
70
  function passStringToWasm0(arg, malloc, realloc) {
45
71
  if (realloc === undefined) {
@@ -71,7 +97,7 @@ function passStringToWasm0(arg, malloc, realloc) {
71
97
  }
72
98
  ptr = realloc(ptr, len, (len = offset + arg.length * 3), 1) >>> 0;
73
99
  const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
74
- const ret = encodeString(arg, view);
100
+ const ret = cachedTextEncoder.encodeInto(arg, view);
75
101
 
76
102
  offset += ret.written;
77
103
  ptr = realloc(ptr, len, offset, 1) >>> 0;
@@ -95,90 +121,10 @@ function getDataViewMemory0() {
95
121
  return cachedDataViewMemory0;
96
122
  }
97
123
 
98
- let heap_next = heap.length;
99
-
100
- function addHeapObject(obj) {
101
- if (heap_next === heap.length) heap.push(heap.length + 1);
102
- const idx = heap_next;
103
- heap_next = heap[idx];
104
-
105
- heap[idx] = obj;
106
- return idx;
107
- }
108
-
109
- function handleError(f, args) {
110
- try {
111
- return f.apply(this, args);
112
- } catch (e) {
113
- wasm.__wbindgen_exn_store(addHeapObject(e));
114
- }
115
- }
116
-
117
- const lTextDecoder =
118
- typeof TextDecoder === "undefined" ? (0, module.require)("util").TextDecoder : TextDecoder;
119
-
120
- let cachedTextDecoder = new lTextDecoder("utf-8", { ignoreBOM: true, fatal: true });
121
-
122
- cachedTextDecoder.decode();
123
-
124
- function getStringFromWasm0(ptr, len) {
125
- ptr = ptr >>> 0;
126
- return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
127
- }
128
-
129
124
  function isLikeNone(x) {
130
125
  return x === undefined || x === null;
131
126
  }
132
127
 
133
- function dropObject(idx) {
134
- if (idx < 132) return;
135
- heap[idx] = heap_next;
136
- heap_next = idx;
137
- }
138
-
139
- function takeObject(idx) {
140
- const ret = getObject(idx);
141
- dropObject(idx);
142
- return ret;
143
- }
144
-
145
- function getArrayU8FromWasm0(ptr, len) {
146
- ptr = ptr >>> 0;
147
- return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
148
- }
149
-
150
- const CLOSURE_DTORS =
151
- typeof FinalizationRegistry === "undefined"
152
- ? { register: () => {}, unregister: () => {} }
153
- : new FinalizationRegistry((state) => {
154
- wasm.__wbindgen_export_4.get(state.dtor)(state.a, state.b);
155
- });
156
-
157
- function makeMutClosure(arg0, arg1, dtor, f) {
158
- const state = { a: arg0, b: arg1, cnt: 1, dtor };
159
- const real = (...args) => {
160
- // First up with a closure we increment the internal reference
161
- // count. This ensures that the Rust closure environment won't
162
- // be deallocated while we're invoking it.
163
- state.cnt++;
164
- const a = state.a;
165
- state.a = 0;
166
- try {
167
- return f(a, state.b, ...args);
168
- } finally {
169
- if (--state.cnt === 0) {
170
- wasm.__wbindgen_export_4.get(state.dtor)(a, state.b);
171
- CLOSURE_DTORS.unregister(state);
172
- } else {
173
- state.a = a;
174
- }
175
- }
176
- };
177
- real.original = state;
178
- CLOSURE_DTORS.register(real, state, state);
179
- return real;
180
- }
181
-
182
128
  function debugString(val) {
183
129
  // primitive types
184
130
  const type = typeof val;
@@ -243,6 +189,73 @@ function debugString(val) {
243
189
  // TODO we could test for more things here, like `Set`s and `Map`s.
244
190
  return className;
245
191
  }
192
+
193
+ function handleError(f, args) {
194
+ try {
195
+ return f.apply(this, args);
196
+ } catch (e) {
197
+ wasm.__wbindgen_exn_store(addHeapObject(e));
198
+ }
199
+ }
200
+
201
+ function dropObject(idx) {
202
+ if (idx < 132) return;
203
+ heap[idx] = heap_next;
204
+ heap_next = idx;
205
+ }
206
+
207
+ function takeObject(idx) {
208
+ const ret = getObject(idx);
209
+ dropObject(idx);
210
+ return ret;
211
+ }
212
+
213
+ function getArrayU8FromWasm0(ptr, len) {
214
+ ptr = ptr >>> 0;
215
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
216
+ }
217
+
218
+ const CLOSURE_DTORS =
219
+ typeof FinalizationRegistry === "undefined"
220
+ ? { register: () => {}, unregister: () => {} }
221
+ : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
222
+
223
+ function makeMutClosure(arg0, arg1, dtor, f) {
224
+ const state = { a: arg0, b: arg1, cnt: 1, dtor };
225
+ const real = (...args) => {
226
+ // First up with a closure we increment the internal reference
227
+ // count. This ensures that the Rust closure environment won't
228
+ // be deallocated while we're invoking it.
229
+ state.cnt++;
230
+ const a = state.a;
231
+ state.a = 0;
232
+ try {
233
+ return f(a, state.b, ...args);
234
+ } finally {
235
+ state.a = a;
236
+ real._wbg_cb_unref();
237
+ }
238
+ };
239
+ real._wbg_cb_unref = () => {
240
+ if (--state.cnt === 0) {
241
+ state.dtor(state.a, state.b);
242
+ state.a = 0;
243
+ CLOSURE_DTORS.unregister(state);
244
+ }
245
+ };
246
+ CLOSURE_DTORS.register(real, state, state);
247
+ return real;
248
+ }
249
+
250
+ function getArrayJsValueFromWasm0(ptr, len) {
251
+ ptr = ptr >>> 0;
252
+ const mem = getDataViewMemory0();
253
+ const result = [];
254
+ for (let i = ptr; i < ptr + 4 * len; i += 4) {
255
+ result.push(takeObject(mem.getUint32(i, true)));
256
+ }
257
+ return result;
258
+ }
246
259
  /**
247
260
  * @param {LogLevel} level
248
261
  */
@@ -464,16 +477,6 @@ function passArrayJsValueToWasm0(array, malloc) {
464
477
  WASM_VECTOR_LEN = array.length;
465
478
  return ptr;
466
479
  }
467
-
468
- function getArrayJsValueFromWasm0(ptr, len) {
469
- ptr = ptr >>> 0;
470
- const mem = getDataViewMemory0();
471
- const result = [];
472
- for (let i = ptr; i < ptr + 4 * len; i += 4) {
473
- result.push(takeObject(mem.getUint32(i, true)));
474
- }
475
- return result;
476
- }
477
480
  /**
478
481
  * @param {any} error
479
482
  * @returns {boolean}
@@ -872,18 +875,22 @@ export function isEncryptFileError(error) {
872
875
  }
873
876
  }
874
877
 
875
- function __wbg_adapter_54(arg0, arg1, arg2) {
876
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h49eea50fd723d292(
878
+ function wasm_bindgen__convert__closures_____invoke__h76c71c1158b6af01(arg0, arg1) {
879
+ wasm.wasm_bindgen__convert__closures_____invoke__h76c71c1158b6af01(arg0, arg1);
880
+ }
881
+
882
+ function wasm_bindgen__convert__closures_____invoke__h142f80da75ccedf5(arg0, arg1, arg2) {
883
+ wasm.wasm_bindgen__convert__closures_____invoke__h142f80da75ccedf5(
877
884
  arg0,
878
885
  arg1,
879
886
  addHeapObject(arg2),
880
887
  );
881
888
  }
882
889
 
883
- function __wbg_adapter_57(arg0, arg1, arg2) {
890
+ function wasm_bindgen__convert__closures_____invoke__he84e41ce162f03b8(arg0, arg1, arg2) {
884
891
  try {
885
892
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
886
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h1e53e05ec7a13572(
893
+ wasm.wasm_bindgen__convert__closures_____invoke__he84e41ce162f03b8(
887
894
  retptr,
888
895
  arg0,
889
896
  arg1,
@@ -899,15 +906,8 @@ function __wbg_adapter_57(arg0, arg1, arg2) {
899
906
  }
900
907
  }
901
908
 
902
- function __wbg_adapter_60(arg0, arg1) {
903
- wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h1d088d25aee734e6(
904
- arg0,
905
- arg1,
906
- );
907
- }
908
-
909
- function __wbg_adapter_355(arg0, arg1, arg2, arg3) {
910
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h849ee2a9e4ae2f91(
909
+ function wasm_bindgen__convert__closures_____invoke__h4096c3b930b983e7(arg0, arg1, arg2, arg3) {
910
+ wasm.wasm_bindgen__convert__closures_____invoke__h4096c3b930b983e7(
911
911
  arg0,
912
912
  arg1,
913
913
  addHeapObject(arg2),
@@ -1137,6 +1137,7 @@ export class AttachmentsClient {
1137
1137
  }
1138
1138
  }
1139
1139
  }
1140
+ if (Symbol.dispose) AttachmentsClient.prototype[Symbol.dispose] = AttachmentsClient.prototype.free;
1140
1141
 
1141
1142
  const AuthClientFinalization =
1142
1143
  typeof FinalizationRegistry === "undefined"
@@ -1182,6 +1183,7 @@ export class AuthClient {
1182
1183
  return SendAccessClient.__wrap(ret);
1183
1184
  }
1184
1185
  }
1186
+ if (Symbol.dispose) AuthClient.prototype[Symbol.dispose] = AuthClient.prototype.free;
1185
1187
 
1186
1188
  const BitwardenClientFinalization =
1187
1189
  typeof FinalizationRegistry === "undefined"
@@ -1338,6 +1340,7 @@ export class BitwardenClient {
1338
1340
  return ExporterClient.__wrap(ret);
1339
1341
  }
1340
1342
  }
1343
+ if (Symbol.dispose) BitwardenClient.prototype[Symbol.dispose] = BitwardenClient.prototype.free;
1341
1344
 
1342
1345
  const CipherRiskClientFinalization =
1343
1346
  typeof FinalizationRegistry === "undefined"
@@ -1420,6 +1423,7 @@ export class CipherRiskClient {
1420
1423
  return takeObject(ret);
1421
1424
  }
1422
1425
  }
1426
+ if (Symbol.dispose) CipherRiskClient.prototype[Symbol.dispose] = CipherRiskClient.prototype.free;
1423
1427
 
1424
1428
  const CiphersClientFinalization =
1425
1429
  typeof FinalizationRegistry === "undefined"
@@ -1735,6 +1739,7 @@ export class CiphersClient {
1735
1739
  }
1736
1740
  }
1737
1741
  }
1742
+ if (Symbol.dispose) CiphersClient.prototype[Symbol.dispose] = CiphersClient.prototype.free;
1738
1743
 
1739
1744
  const CollectionViewNodeItemFinalization =
1740
1745
  typeof FinalizationRegistry === "undefined"
@@ -1799,6 +1804,8 @@ export class CollectionViewNodeItem {
1799
1804
  return takeObject(ret);
1800
1805
  }
1801
1806
  }
1807
+ if (Symbol.dispose)
1808
+ CollectionViewNodeItem.prototype[Symbol.dispose] = CollectionViewNodeItem.prototype.free;
1802
1809
 
1803
1810
  const CollectionViewTreeFinalization =
1804
1811
  typeof FinalizationRegistry === "undefined"
@@ -1869,6 +1876,8 @@ export class CollectionViewTree {
1869
1876
  }
1870
1877
  }
1871
1878
  }
1879
+ if (Symbol.dispose)
1880
+ CollectionViewTree.prototype[Symbol.dispose] = CollectionViewTree.prototype.free;
1872
1881
 
1873
1882
  const CollectionsClientFinalization =
1874
1883
  typeof FinalizationRegistry === "undefined"
@@ -1952,6 +1961,7 @@ export class CollectionsClient {
1952
1961
  return CollectionViewTree.__wrap(ret);
1953
1962
  }
1954
1963
  }
1964
+ if (Symbol.dispose) CollectionsClient.prototype[Symbol.dispose] = CollectionsClient.prototype.free;
1955
1965
 
1956
1966
  const CryptoClientFinalization =
1957
1967
  typeof FinalizationRegistry === "undefined"
@@ -2195,6 +2205,7 @@ export class CryptoClient {
2195
2205
  }
2196
2206
  }
2197
2207
  }
2208
+ if (Symbol.dispose) CryptoClient.prototype[Symbol.dispose] = CryptoClient.prototype.free;
2198
2209
 
2199
2210
  const ExporterClientFinalization =
2200
2211
  typeof FinalizationRegistry === "undefined"
@@ -2376,6 +2387,7 @@ export class ExporterClient {
2376
2387
  }
2377
2388
  }
2378
2389
  }
2390
+ if (Symbol.dispose) ExporterClient.prototype[Symbol.dispose] = ExporterClient.prototype.free;
2379
2391
 
2380
2392
  const FoldersClientFinalization =
2381
2393
  typeof FinalizationRegistry === "undefined"
@@ -2510,6 +2522,7 @@ export class FoldersClient {
2510
2522
  return takeObject(ret);
2511
2523
  }
2512
2524
  }
2525
+ if (Symbol.dispose) FoldersClient.prototype[Symbol.dispose] = FoldersClient.prototype.free;
2513
2526
 
2514
2527
  const GeneratorClientFinalization =
2515
2528
  typeof FinalizationRegistry === "undefined"
@@ -2641,6 +2654,7 @@ export class GeneratorClient {
2641
2654
  }
2642
2655
  }
2643
2656
  }
2657
+ if (Symbol.dispose) GeneratorClient.prototype[Symbol.dispose] = GeneratorClient.prototype.free;
2644
2658
 
2645
2659
  const IdentityClientFinalization =
2646
2660
  typeof FinalizationRegistry === "undefined"
@@ -2670,6 +2684,7 @@ export class IdentityClient {
2670
2684
  wasm.__wbg_identityclient_free(ptr, 0);
2671
2685
  }
2672
2686
  }
2687
+ if (Symbol.dispose) IdentityClient.prototype[Symbol.dispose] = IdentityClient.prototype.free;
2673
2688
 
2674
2689
  const IncomingMessageFinalization =
2675
2690
  typeof FinalizationRegistry === "undefined"
@@ -2809,6 +2824,7 @@ export class IncomingMessage {
2809
2824
  return takeObject(ret);
2810
2825
  }
2811
2826
  }
2827
+ if (Symbol.dispose) IncomingMessage.prototype[Symbol.dispose] = IncomingMessage.prototype.free;
2812
2828
 
2813
2829
  const IpcClientFinalization =
2814
2830
  typeof FinalizationRegistry === "undefined"
@@ -2819,6 +2835,14 @@ const IpcClientFinalization =
2819
2835
  * [IpcClient] documentation.
2820
2836
  */
2821
2837
  export class IpcClient {
2838
+ static __wrap(ptr) {
2839
+ ptr = ptr >>> 0;
2840
+ const obj = Object.create(IpcClient.prototype);
2841
+ obj.__wbg_ptr = ptr;
2842
+ IpcClientFinalization.register(obj, obj.__wbg_ptr, obj);
2843
+ return obj;
2844
+ }
2845
+
2822
2846
  __destroy_into_raw() {
2823
2847
  const ptr = this.__wbg_ptr;
2824
2848
  this.__wbg_ptr = 0;
@@ -2831,14 +2855,30 @@ export class IpcClient {
2831
2855
  wasm.__wbg_ipcclient_free(ptr, 0);
2832
2856
  }
2833
2857
  /**
2858
+ * Create a new `IpcClient` instance with an in-memory session repository for saving
2859
+ * sessions within the SDK.
2834
2860
  * @param {IpcCommunicationBackend} communication_provider
2861
+ * @returns {IpcClient}
2835
2862
  */
2836
- constructor(communication_provider) {
2863
+ static newWithSdkInMemorySessions(communication_provider) {
2837
2864
  _assertClass(communication_provider, IpcCommunicationBackend);
2838
- const ret = wasm.ipcclient_new(communication_provider.__wbg_ptr);
2839
- this.__wbg_ptr = ret >>> 0;
2840
- IpcClientFinalization.register(this, this.__wbg_ptr, this);
2841
- return this;
2865
+ const ret = wasm.ipcclient_newWithSdkInMemorySessions(communication_provider.__wbg_ptr);
2866
+ return IpcClient.__wrap(ret);
2867
+ }
2868
+ /**
2869
+ * Create a new `IpcClient` instance with a client-managed session repository for saving
2870
+ * sessions using State Provider.
2871
+ * @param {IpcCommunicationBackend} communication_provider
2872
+ * @param {IpcSessionRepository} session_repository
2873
+ * @returns {IpcClient}
2874
+ */
2875
+ static newWithClientManagedSessions(communication_provider, session_repository) {
2876
+ _assertClass(communication_provider, IpcCommunicationBackend);
2877
+ const ret = wasm.ipcclient_newWithClientManagedSessions(
2878
+ communication_provider.__wbg_ptr,
2879
+ addHeapObject(session_repository),
2880
+ );
2881
+ return IpcClient.__wrap(ret);
2842
2882
  }
2843
2883
  /**
2844
2884
  * @returns {Promise<void>}
@@ -2872,6 +2912,7 @@ export class IpcClient {
2872
2912
  return takeObject(ret);
2873
2913
  }
2874
2914
  }
2915
+ if (Symbol.dispose) IpcClient.prototype[Symbol.dispose] = IpcClient.prototype.free;
2875
2916
 
2876
2917
  const IpcClientSubscriptionFinalization =
2877
2918
  typeof FinalizationRegistry === "undefined"
@@ -2913,6 +2954,8 @@ export class IpcClientSubscription {
2913
2954
  return takeObject(ret);
2914
2955
  }
2915
2956
  }
2957
+ if (Symbol.dispose)
2958
+ IpcClientSubscription.prototype[Symbol.dispose] = IpcClientSubscription.prototype.free;
2916
2959
 
2917
2960
  const IpcCommunicationBackendFinalization =
2918
2961
  typeof FinalizationRegistry === "undefined"
@@ -2963,6 +3006,8 @@ export class IpcCommunicationBackend {
2963
3006
  }
2964
3007
  }
2965
3008
  }
3009
+ if (Symbol.dispose)
3010
+ IpcCommunicationBackend.prototype[Symbol.dispose] = IpcCommunicationBackend.prototype.free;
2966
3011
 
2967
3012
  const OutgoingMessageFinalization =
2968
3013
  typeof FinalizationRegistry === "undefined"
@@ -3105,6 +3150,7 @@ export class OutgoingMessage {
3105
3150
  }
3106
3151
  }
3107
3152
  }
3153
+ if (Symbol.dispose) OutgoingMessage.prototype[Symbol.dispose] = OutgoingMessage.prototype.free;
3108
3154
 
3109
3155
  const PlatformClientFinalization =
3110
3156
  typeof FinalizationRegistry === "undefined"
@@ -3156,6 +3202,7 @@ export class PlatformClient {
3156
3202
  }
3157
3203
  }
3158
3204
  }
3205
+ if (Symbol.dispose) PlatformClient.prototype[Symbol.dispose] = PlatformClient.prototype.free;
3159
3206
 
3160
3207
  const PureCryptoFinalization =
3161
3208
  typeof FinalizationRegistry === "undefined"
@@ -3971,6 +4018,7 @@ export class PureCrypto {
3971
4018
  }
3972
4019
  }
3973
4020
  }
4021
+ if (Symbol.dispose) PureCrypto.prototype[Symbol.dispose] = PureCrypto.prototype.free;
3974
4022
 
3975
4023
  const SendAccessClientFinalization =
3976
4024
  typeof FinalizationRegistry === "undefined"
@@ -4012,6 +4060,7 @@ export class SendAccessClient {
4012
4060
  return takeObject(ret);
4013
4061
  }
4014
4062
  }
4063
+ if (Symbol.dispose) SendAccessClient.prototype[Symbol.dispose] = SendAccessClient.prototype.free;
4015
4064
 
4016
4065
  const StateClientFinalization =
4017
4066
  typeof FinalizationRegistry === "undefined"
@@ -4069,6 +4118,7 @@ export class StateClient {
4069
4118
  return takeObject(ret);
4070
4119
  }
4071
4120
  }
4121
+ if (Symbol.dispose) StateClient.prototype[Symbol.dispose] = StateClient.prototype.free;
4072
4122
 
4073
4123
  const TotpClientFinalization =
4074
4124
  typeof FinalizationRegistry === "undefined"
@@ -4133,6 +4183,7 @@ export class TotpClient {
4133
4183
  }
4134
4184
  }
4135
4185
  }
4186
+ if (Symbol.dispose) TotpClient.prototype[Symbol.dispose] = TotpClient.prototype.free;
4136
4187
 
4137
4188
  const VaultClientFinalization =
4138
4189
  typeof FinalizationRegistry === "undefined"
@@ -4208,6 +4259,17 @@ export class VaultClient {
4208
4259
  return CipherRiskClient.__wrap(ret);
4209
4260
  }
4210
4261
  }
4262
+ if (Symbol.dispose) VaultClient.prototype[Symbol.dispose] = VaultClient.prototype.free;
4263
+
4264
+ export function __wbg_Error_e83987f665cf5504(arg0, arg1) {
4265
+ const ret = Error(getStringFromWasm0(arg0, arg1));
4266
+ return addHeapObject(ret);
4267
+ }
4268
+
4269
+ export function __wbg_Number_bb48ca12f395cd08(arg0) {
4270
+ const ret = Number(getObject(arg0));
4271
+ return ret;
4272
+ }
4211
4273
 
4212
4274
  export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) {
4213
4275
  const ret = String(getObject(arg1));
@@ -4217,37 +4279,119 @@ export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) {
4217
4279
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4218
4280
  }
4219
4281
 
4220
- export function __wbg_abort_410ec47a64ac6117(arg0, arg1) {
4221
- getObject(arg0).abort(getObject(arg1));
4282
+ export function __wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd(arg0, arg1) {
4283
+ const v = getObject(arg1);
4284
+ const ret = typeof v === "bigint" ? v : undefined;
4285
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
4286
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
4222
4287
  }
4223
4288
 
4224
- export function __wbg_abort_775ef1d17fc65868(arg0) {
4225
- getObject(arg0).abort();
4289
+ export function __wbg___wbindgen_boolean_get_6d5a1ee65bab5f68(arg0) {
4290
+ const v = getObject(arg0);
4291
+ const ret = typeof v === "boolean" ? v : undefined;
4292
+ return isLikeNone(ret) ? 0xffffff : ret ? 1 : 0;
4293
+ }
4294
+
4295
+ export function __wbg___wbindgen_debug_string_df47ffb5e35e6763(arg0, arg1) {
4296
+ const ret = debugString(getObject(arg1));
4297
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4298
+ const len1 = WASM_VECTOR_LEN;
4299
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4300
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4301
+ }
4302
+
4303
+ export function __wbg___wbindgen_in_bb933bd9e1b3bc0f(arg0, arg1) {
4304
+ const ret = getObject(arg0) in getObject(arg1);
4305
+ return ret;
4306
+ }
4307
+
4308
+ export function __wbg___wbindgen_is_bigint_cb320707dcd35f0b(arg0) {
4309
+ const ret = typeof getObject(arg0) === "bigint";
4310
+ return ret;
4311
+ }
4312
+
4313
+ export function __wbg___wbindgen_is_function_ee8a6c5833c90377(arg0) {
4314
+ const ret = typeof getObject(arg0) === "function";
4315
+ return ret;
4316
+ }
4317
+
4318
+ export function __wbg___wbindgen_is_object_c818261d21f283a4(arg0) {
4319
+ const val = getObject(arg0);
4320
+ const ret = typeof val === "object" && val !== null;
4321
+ return ret;
4322
+ }
4323
+
4324
+ export function __wbg___wbindgen_is_string_fbb76cb2940daafd(arg0) {
4325
+ const ret = typeof getObject(arg0) === "string";
4326
+ return ret;
4327
+ }
4328
+
4329
+ export function __wbg___wbindgen_is_undefined_2d472862bd29a478(arg0) {
4330
+ const ret = getObject(arg0) === undefined;
4331
+ return ret;
4332
+ }
4333
+
4334
+ export function __wbg___wbindgen_jsval_eq_6b13ab83478b1c50(arg0, arg1) {
4335
+ const ret = getObject(arg0) === getObject(arg1);
4336
+ return ret;
4337
+ }
4338
+
4339
+ export function __wbg___wbindgen_jsval_loose_eq_b664b38a2f582147(arg0, arg1) {
4340
+ const ret = getObject(arg0) == getObject(arg1);
4341
+ return ret;
4342
+ }
4343
+
4344
+ export function __wbg___wbindgen_number_get_a20bf9b85341449d(arg0, arg1) {
4345
+ const obj = getObject(arg1);
4346
+ const ret = typeof obj === "number" ? obj : undefined;
4347
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
4348
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
4349
+ }
4350
+
4351
+ export function __wbg___wbindgen_string_get_e4f06c90489ad01b(arg0, arg1) {
4352
+ const obj = getObject(arg1);
4353
+ const ret = typeof obj === "string" ? obj : undefined;
4354
+ var ptr1 = isLikeNone(ret)
4355
+ ? 0
4356
+ : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4357
+ var len1 = WASM_VECTOR_LEN;
4358
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4359
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4360
+ }
4361
+
4362
+ export function __wbg___wbindgen_throw_b855445ff6a94295(arg0, arg1) {
4363
+ throw new Error(getStringFromWasm0(arg0, arg1));
4364
+ }
4365
+
4366
+ export function __wbg__wbg_cb_unref_2454a539ea5790d9(arg0) {
4367
+ getObject(arg0)._wbg_cb_unref();
4226
4368
  }
4227
4369
 
4228
- export function __wbg_abort_99fc644e2c79c9fb() {
4370
+ export function __wbg_abort_28ad55c5825b004d(arg0, arg1) {
4371
+ getObject(arg0).abort(getObject(arg1));
4372
+ }
4373
+
4374
+ export function __wbg_abort_3b256cd5ad0ac232() {
4229
4375
  return handleError(function (arg0) {
4230
4376
  getObject(arg0).abort();
4231
4377
  }, arguments);
4232
4378
  }
4233
4379
 
4234
- export function __wbg_addEventListener_dc3da056b615f634(arg0, arg1, arg2, arg3) {
4235
- getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
4380
+ export function __wbg_abort_e7eb059f72f9ed0c(arg0) {
4381
+ getObject(arg0).abort();
4236
4382
  }
4237
4383
 
4238
- export function __wbg_append_299d5d48292c0495() {
4239
- return handleError(function (arg0, arg1, arg2, arg3, arg4) {
4240
- getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
4241
- }, arguments);
4384
+ export function __wbg_addEventListener_dc3da056b615f634(arg0, arg1, arg2, arg3) {
4385
+ getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
4242
4386
  }
4243
4387
 
4244
- export function __wbg_append_8c7dd8d641a5f01b() {
4388
+ export function __wbg_append_45ddba58b0706f62() {
4245
4389
  return handleError(function (arg0, arg1, arg2, arg3, arg4) {
4246
4390
  getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
4247
4391
  }, arguments);
4248
4392
  }
4249
4393
 
4250
- export function __wbg_append_b2d1fc16de2a0e81() {
4394
+ export function __wbg_append_892c5e2d5bdd60ac() {
4251
4395
  return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
4252
4396
  getObject(arg0).append(
4253
4397
  getStringFromWasm0(arg1, arg2),
@@ -4257,39 +4401,40 @@ export function __wbg_append_b2d1fc16de2a0e81() {
4257
4401
  }, arguments);
4258
4402
  }
4259
4403
 
4260
- export function __wbg_append_b44785ebeb668479() {
4404
+ export function __wbg_append_b577eb3a177bc0fa() {
4405
+ return handleError(function (arg0, arg1, arg2, arg3, arg4) {
4406
+ getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
4407
+ }, arguments);
4408
+ }
4409
+
4410
+ export function __wbg_append_cb0bba4cf263a60b() {
4261
4411
  return handleError(function (arg0, arg1, arg2, arg3) {
4262
4412
  getObject(arg0).append(getStringFromWasm0(arg1, arg2), getObject(arg3));
4263
4413
  }, arguments);
4264
4414
  }
4265
4415
 
4266
- export function __wbg_arrayBuffer_d1b44c4390db422f() {
4416
+ export function __wbg_arrayBuffer_b375eccb84b4ddf3() {
4267
4417
  return handleError(function (arg0) {
4268
4418
  const ret = getObject(arg0).arrayBuffer();
4269
4419
  return addHeapObject(ret);
4270
4420
  }, arguments);
4271
4421
  }
4272
4422
 
4273
- export function __wbg_buffer_609cc3eee51ed158(arg0) {
4274
- const ret = getObject(arg0).buffer;
4275
- return addHeapObject(ret);
4276
- }
4277
-
4278
- export function __wbg_call_672a4d21634d4a24() {
4279
- return handleError(function (arg0, arg1) {
4280
- const ret = getObject(arg0).call(getObject(arg1));
4423
+ export function __wbg_call_525440f72fbfc0ea() {
4424
+ return handleError(function (arg0, arg1, arg2) {
4425
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
4281
4426
  return addHeapObject(ret);
4282
4427
  }, arguments);
4283
4428
  }
4284
4429
 
4285
- export function __wbg_call_7cccdd69e0791ae2() {
4286
- return handleError(function (arg0, arg1, arg2) {
4287
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
4430
+ export function __wbg_call_e762c39fa8ea36bf() {
4431
+ return handleError(function (arg0, arg1) {
4432
+ const ret = getObject(arg0).call(getObject(arg1));
4288
4433
  return addHeapObject(ret);
4289
4434
  }, arguments);
4290
4435
  }
4291
4436
 
4292
- export function __wbg_cipher_a27a94359315cc93(arg0) {
4437
+ export function __wbg_cipher_eb520ade5d02e2c8(arg0) {
4293
4438
  const ret = getObject(arg0).cipher;
4294
4439
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
4295
4440
  }
@@ -4304,7 +4449,7 @@ export function __wbg_collectionviewnodeitem_new(arg0) {
4304
4449
  return addHeapObject(ret);
4305
4450
  }
4306
4451
 
4307
- export function __wbg_createObjectStore_d2f9e1016f4d81b9() {
4452
+ export function __wbg_createObjectStore_283a43a822bf49ca() {
4308
4453
  return handleError(function (arg0, arg1, arg2, arg3) {
4309
4454
  const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2), getObject(arg3));
4310
4455
  return addHeapObject(ret);
@@ -4316,26 +4461,33 @@ export function __wbg_crypto_574e78ad8b13b65f(arg0) {
4316
4461
  return addHeapObject(ret);
4317
4462
  }
4318
4463
 
4319
- export function __wbg_debug_e17b51583ca6a632(arg0, arg1, arg2, arg3) {
4464
+ export function __wbg_debug_e55e1461940eb14d(arg0, arg1, arg2, arg3) {
4320
4465
  console.debug(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
4321
4466
  }
4322
4467
 
4323
- export function __wbg_deleteObjectStore_3f08ae00cd288224() {
4468
+ export function __wbg_deleteObjectStore_444a266b213fafcf() {
4324
4469
  return handleError(function (arg0, arg1, arg2) {
4325
4470
  getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
4326
4471
  }, arguments);
4327
4472
  }
4328
4473
 
4329
- export function __wbg_done_769e5ede4b31c67b(arg0) {
4474
+ export function __wbg_done_2042aa2670fb1db1(arg0) {
4330
4475
  const ret = getObject(arg0).done;
4331
4476
  return ret;
4332
4477
  }
4333
4478
 
4334
- export function __wbg_entries_3265d4158b33e5dc(arg0) {
4479
+ export function __wbg_entries_e171b586f8f6bdbf(arg0) {
4335
4480
  const ret = Object.entries(getObject(arg0));
4336
4481
  return addHeapObject(ret);
4337
4482
  }
4338
4483
 
4484
+ export function __wbg_error_3e929987fcd3e155() {
4485
+ return handleError(function (arg0) {
4486
+ const ret = getObject(arg0).error;
4487
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
4488
+ }, arguments);
4489
+ }
4490
+
4339
4491
  export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
4340
4492
  let deferred0_0;
4341
4493
  let deferred0_1;
@@ -4348,33 +4500,26 @@ export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
4348
4500
  }
4349
4501
  }
4350
4502
 
4351
- export function __wbg_error_80de38b3f7cc3c3c(arg0, arg1, arg2, arg3) {
4503
+ export function __wbg_error_d8b22cf4e59a6791(arg0, arg1, arg2, arg3) {
4352
4504
  console.error(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
4353
4505
  }
4354
4506
 
4355
- export function __wbg_error_ff4ddaabdfc5dbb3() {
4356
- return handleError(function (arg0) {
4357
- const ret = getObject(arg0).error;
4358
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
4359
- }, arguments);
4360
- }
4361
-
4362
4507
  export function __wbg_fetch_3afbdcc7ddbf16fe(arg0) {
4363
4508
  const ret = fetch(getObject(arg0));
4364
4509
  return addHeapObject(ret);
4365
4510
  }
4366
4511
 
4367
- export function __wbg_fetch_509096533071c657(arg0, arg1) {
4512
+ export function __wbg_fetch_f8ba0e29a9d6de0d(arg0, arg1) {
4368
4513
  const ret = getObject(arg0).fetch(getObject(arg1));
4369
4514
  return addHeapObject(ret);
4370
4515
  }
4371
4516
 
4372
- export function __wbg_folder_ff53d2d4dc2faf85(arg0) {
4517
+ export function __wbg_folder_a9c369db22013424(arg0) {
4373
4518
  const ret = getObject(arg0).folder;
4374
4519
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
4375
4520
  }
4376
4521
 
4377
- export function __wbg_getFullYear_17d3c9e4db748eb7(arg0) {
4522
+ export function __wbg_getFullYear_8240d5a15191feae(arg0) {
4378
4523
  const ret = getObject(arg0).getFullYear();
4379
4524
  return ret;
4380
4525
  }
@@ -4391,12 +4536,22 @@ export function __wbg_getRandomValues_b8f5dbd5f3995a9e() {
4391
4536
  }, arguments);
4392
4537
  }
4393
4538
 
4394
- export function __wbg_getTime_46267b1c24877e30(arg0) {
4539
+ export function __wbg_getTime_14776bfb48a1bff9(arg0) {
4395
4540
  const ret = getObject(arg0).getTime();
4396
4541
  return ret;
4397
4542
  }
4398
4543
 
4399
- export function __wbg_get_669deafd63743335() {
4544
+ export function __wbg_get_7bed016f185add81(arg0, arg1) {
4545
+ const ret = getObject(arg0)[arg1 >>> 0];
4546
+ return addHeapObject(ret);
4547
+ }
4548
+
4549
+ export function __wbg_get_access_token_2a6f3a7572a71513(arg0) {
4550
+ const ret = getObject(arg0).get_access_token();
4551
+ return addHeapObject(ret);
4552
+ }
4553
+
4554
+ export function __wbg_get_e964441f5ccb3c80() {
4400
4555
  return handleError(function (arg0, arg1, arg2) {
4401
4556
  let deferred0_0;
4402
4557
  let deferred0_1;
@@ -4411,14 +4566,7 @@ export function __wbg_get_669deafd63743335() {
4411
4566
  }, arguments);
4412
4567
  }
4413
4568
 
4414
- export function __wbg_get_67b2ba62fc30de12() {
4415
- return handleError(function (arg0, arg1) {
4416
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
4417
- return addHeapObject(ret);
4418
- }, arguments);
4419
- }
4420
-
4421
- export function __wbg_get_ab004b7c5fd98da4() {
4569
+ export function __wbg_get_ec74c278e7438da5() {
4422
4570
  return handleError(function (arg0, arg1, arg2) {
4423
4571
  let deferred0_0;
4424
4572
  let deferred0_1;
@@ -4433,29 +4581,26 @@ export function __wbg_get_ab004b7c5fd98da4() {
4433
4581
  }, arguments);
4434
4582
  }
4435
4583
 
4436
- export function __wbg_get_b9b93047fe3cf45b(arg0, arg1) {
4437
- const ret = getObject(arg0)[arg1 >>> 0];
4438
- return addHeapObject(ret);
4439
- }
4440
-
4441
- export function __wbg_getaccesstoken_005ebb39d33faf4d(arg0) {
4442
- const ret = getObject(arg0).get_access_token();
4443
- return addHeapObject(ret);
4584
+ export function __wbg_get_efcb449f58ec27c2() {
4585
+ return handleError(function (arg0, arg1) {
4586
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
4587
+ return addHeapObject(ret);
4588
+ }, arguments);
4444
4589
  }
4445
4590
 
4446
- export function __wbg_getwithrefkey_1dc361bd10053bfe(arg0, arg1) {
4591
+ export function __wbg_get_with_ref_key_1dc361bd10053bfe(arg0, arg1) {
4447
4592
  const ret = getObject(arg0)[getObject(arg1)];
4448
4593
  return addHeapObject(ret);
4449
4594
  }
4450
4595
 
4451
- export function __wbg_has_a5ea9117f258a0ec() {
4596
+ export function __wbg_has_787fafc980c3ccdb() {
4452
4597
  return handleError(function (arg0, arg1) {
4453
4598
  const ret = Reflect.has(getObject(arg0), getObject(arg1));
4454
4599
  return ret;
4455
4600
  }, arguments);
4456
4601
  }
4457
4602
 
4458
- export function __wbg_headers_9cb51cfd2ac780a4(arg0) {
4603
+ export function __wbg_headers_b87d7eaba61c3278(arg0) {
4459
4604
  const ret = getObject(arg0).headers;
4460
4605
  return addHeapObject(ret);
4461
4606
  }
@@ -4465,25 +4610,25 @@ export function __wbg_incomingmessage_new(arg0) {
4465
4610
  return addHeapObject(ret);
4466
4611
  }
4467
4612
 
4468
- export function __wbg_indexedDB_b1f49280282046f8() {
4613
+ export function __wbg_indexedDB_62bfbbd55ec74b14() {
4469
4614
  return handleError(function (arg0) {
4470
4615
  const ret = getObject(arg0).indexedDB;
4471
4616
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
4472
4617
  }, arguments);
4473
4618
  }
4474
4619
 
4475
- export function __wbg_indexedDB_f6b47b0dc333fd2f() {
4620
+ export function __wbg_indexedDB_8b464318fe56681e() {
4476
4621
  return handleError(function (arg0) {
4477
4622
  const ret = getObject(arg0).indexedDB;
4478
4623
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
4479
4624
  }, arguments);
4480
4625
  }
4481
4626
 
4482
- export function __wbg_info_033d8b8a0838f1d3(arg0, arg1, arg2, arg3) {
4627
+ export function __wbg_info_68cd5b51ef7e5137(arg0, arg1, arg2, arg3) {
4483
4628
  console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
4484
4629
  }
4485
4630
 
4486
- export function __wbg_instanceof_ArrayBuffer_e14585432e3737fc(arg0) {
4631
+ export function __wbg_instanceof_ArrayBuffer_70beb1189ca63b38(arg0) {
4487
4632
  let result;
4488
4633
  try {
4489
4634
  result = getObject(arg0) instanceof ArrayBuffer;
@@ -4494,7 +4639,7 @@ export function __wbg_instanceof_ArrayBuffer_e14585432e3737fc(arg0) {
4494
4639
  return ret;
4495
4640
  }
4496
4641
 
4497
- export function __wbg_instanceof_DomException_ed1ccb7aaf39034c(arg0) {
4642
+ export function __wbg_instanceof_DomException_83b15e7b042a0b1a(arg0) {
4498
4643
  let result;
4499
4644
  try {
4500
4645
  result = getObject(arg0) instanceof DOMException;
@@ -4505,7 +4650,7 @@ export function __wbg_instanceof_DomException_ed1ccb7aaf39034c(arg0) {
4505
4650
  return ret;
4506
4651
  }
4507
4652
 
4508
- export function __wbg_instanceof_IdbDatabase_a3ef009ca00059f9(arg0) {
4653
+ export function __wbg_instanceof_IdbDatabase_fcf75ffeeec3ec8c(arg0) {
4509
4654
  let result;
4510
4655
  try {
4511
4656
  result = getObject(arg0) instanceof IDBDatabase;
@@ -4516,7 +4661,7 @@ export function __wbg_instanceof_IdbDatabase_a3ef009ca00059f9(arg0) {
4516
4661
  return ret;
4517
4662
  }
4518
4663
 
4519
- export function __wbg_instanceof_IdbOpenDbRequest_a3416e156c9db893(arg0) {
4664
+ export function __wbg_instanceof_IdbOpenDbRequest_08e4929084e51476(arg0) {
4520
4665
  let result;
4521
4666
  try {
4522
4667
  result = getObject(arg0) instanceof IDBOpenDBRequest;
@@ -4527,7 +4672,7 @@ export function __wbg_instanceof_IdbOpenDbRequest_a3416e156c9db893(arg0) {
4527
4672
  return ret;
4528
4673
  }
4529
4674
 
4530
- export function __wbg_instanceof_IdbRequest_4813c3f207666aa4(arg0) {
4675
+ export function __wbg_instanceof_IdbRequest_26754883a3cc8f81(arg0) {
4531
4676
  let result;
4532
4677
  try {
4533
4678
  result = getObject(arg0) instanceof IDBRequest;
@@ -4538,7 +4683,7 @@ export function __wbg_instanceof_IdbRequest_4813c3f207666aa4(arg0) {
4538
4683
  return ret;
4539
4684
  }
4540
4685
 
4541
- export function __wbg_instanceof_Map_f3469ce2244d2430(arg0) {
4686
+ export function __wbg_instanceof_Map_8579b5e2ab5437c7(arg0) {
4542
4687
  let result;
4543
4688
  try {
4544
4689
  result = getObject(arg0) instanceof Map;
@@ -4549,7 +4694,7 @@ export function __wbg_instanceof_Map_f3469ce2244d2430(arg0) {
4549
4694
  return ret;
4550
4695
  }
4551
4696
 
4552
- export function __wbg_instanceof_Response_f2cc20d9f7dfd644(arg0) {
4697
+ export function __wbg_instanceof_Response_f4f3e87e07f3135c(arg0) {
4553
4698
  let result;
4554
4699
  try {
4555
4700
  result = getObject(arg0) instanceof Response;
@@ -4560,7 +4705,7 @@ export function __wbg_instanceof_Response_f2cc20d9f7dfd644(arg0) {
4560
4705
  return ret;
4561
4706
  }
4562
4707
 
4563
- export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) {
4708
+ export function __wbg_instanceof_Uint8Array_20c8e73002f7af98(arg0) {
4564
4709
  let result;
4565
4710
  try {
4566
4711
  result = getObject(arg0) instanceof Uint8Array;
@@ -4571,7 +4716,7 @@ export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) {
4571
4716
  return ret;
4572
4717
  }
4573
4718
 
4574
- export function __wbg_instanceof_Window_def73ea0955fc569(arg0) {
4719
+ export function __wbg_instanceof_Window_4846dbb3de56c84c(arg0) {
4575
4720
  let result;
4576
4721
  try {
4577
4722
  result = getObject(arg0) instanceof Window;
@@ -4582,7 +4727,7 @@ export function __wbg_instanceof_Window_def73ea0955fc569(arg0) {
4582
4727
  return ret;
4583
4728
  }
4584
4729
 
4585
- export function __wbg_instanceof_WorkerGlobalScope_dbdbdea7e3b56493(arg0) {
4730
+ export function __wbg_instanceof_WorkerGlobalScope_e31f49b6d33fcadd(arg0) {
4586
4731
  let result;
4587
4732
  try {
4588
4733
  result = getObject(arg0) instanceof WorkerGlobalScope;
@@ -4598,46 +4743,46 @@ export function __wbg_ipcclientsubscription_new(arg0) {
4598
4743
  return addHeapObject(ret);
4599
4744
  }
4600
4745
 
4601
- export function __wbg_isArray_a1eab7e0d067391b(arg0) {
4746
+ export function __wbg_isArray_96e0af9891d0945d(arg0) {
4602
4747
  const ret = Array.isArray(getObject(arg0));
4603
4748
  return ret;
4604
4749
  }
4605
4750
 
4606
- export function __wbg_isSafeInteger_343e2beeeece1bb0(arg0) {
4751
+ export function __wbg_isSafeInteger_d216eda7911dde36(arg0) {
4607
4752
  const ret = Number.isSafeInteger(getObject(arg0));
4608
4753
  return ret;
4609
4754
  }
4610
4755
 
4611
- export function __wbg_iterator_9a24c88df860dc65() {
4756
+ export function __wbg_iterator_e5822695327a3c39() {
4612
4757
  const ret = Symbol.iterator;
4613
4758
  return addHeapObject(ret);
4614
4759
  }
4615
4760
 
4616
- export function __wbg_length_a446193dc22c12f8(arg0) {
4761
+ export function __wbg_length_69bca3cb64fc8748(arg0) {
4617
4762
  const ret = getObject(arg0).length;
4618
4763
  return ret;
4619
4764
  }
4620
4765
 
4621
- export function __wbg_length_e2d2a49132c1b256(arg0) {
4766
+ export function __wbg_length_cdd215e10d9dd507(arg0) {
4622
4767
  const ret = getObject(arg0).length;
4623
4768
  return ret;
4624
4769
  }
4625
4770
 
4626
- export function __wbg_list_8a771eed93888b5d() {
4771
+ export function __wbg_list_b8dfecdd2b65e61e() {
4627
4772
  return handleError(function (arg0) {
4628
4773
  const ret = getObject(arg0).list();
4629
4774
  return addHeapObject(ret);
4630
4775
  }, arguments);
4631
4776
  }
4632
4777
 
4633
- export function __wbg_list_97f0fbb3cdf20313() {
4778
+ export function __wbg_list_daa32c63b02d85cb() {
4634
4779
  return handleError(function (arg0) {
4635
4780
  const ret = getObject(arg0).list();
4636
4781
  return addHeapObject(ret);
4637
4782
  }, arguments);
4638
4783
  }
4639
4784
 
4640
- export function __wbg_log_cad59bb680daec67(arg0, arg1, arg2, arg3) {
4785
+ export function __wbg_log_45eb3a49e7cdcb64(arg0, arg1, arg2, arg3) {
4641
4786
  console.log(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
4642
4787
  }
4643
4788
 
@@ -4646,7 +4791,7 @@ export function __wbg_msCrypto_a61aeb35a24c1329(arg0) {
4646
4791
  return addHeapObject(ret);
4647
4792
  }
4648
4793
 
4649
- export function __wbg_name_f2d27098bfd843e7(arg0, arg1) {
4794
+ export function __wbg_name_3a33ad25b892b2dd(arg0, arg1) {
4650
4795
  const ret = getObject(arg1).name;
4651
4796
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4652
4797
  const len1 = WASM_VECTOR_LEN;
@@ -4654,26 +4799,36 @@ export function __wbg_name_f2d27098bfd843e7(arg0, arg1) {
4654
4799
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4655
4800
  }
4656
4801
 
4657
- export function __wbg_new0_f788a2397c7ca929() {
4802
+ export function __wbg_new_0_f9740686d739025c() {
4658
4803
  const ret = new Date();
4659
4804
  return addHeapObject(ret);
4660
4805
  }
4661
4806
 
4662
- export function __wbg_new_018dcc2d6c8c2f6a() {
4807
+ export function __wbg_new_1acc0b6eea89d040() {
4808
+ const ret = new Object();
4809
+ return addHeapObject(ret);
4810
+ }
4811
+
4812
+ export function __wbg_new_2531773dac38ebb3() {
4663
4813
  return handleError(function () {
4664
- const ret = new Headers();
4814
+ const ret = new AbortController();
4665
4815
  return addHeapObject(ret);
4666
4816
  }, arguments);
4667
4817
  }
4668
4818
 
4669
- export function __wbg_new_23a2665fac83c611(arg0, arg1) {
4819
+ export function __wbg_new_3c3d849046688a66(arg0, arg1) {
4670
4820
  try {
4671
4821
  var state0 = { a: arg0, b: arg1 };
4672
4822
  var cb0 = (arg0, arg1) => {
4673
4823
  const a = state0.a;
4674
4824
  state0.a = 0;
4675
4825
  try {
4676
- return __wbg_adapter_355(a, state0.b, arg0, arg1);
4826
+ return wasm_bindgen__convert__closures_____invoke__h4096c3b930b983e7(
4827
+ a,
4828
+ state0.b,
4829
+ arg0,
4830
+ arg1,
4831
+ );
4677
4832
  } finally {
4678
4833
  state0.a = a;
4679
4834
  }
@@ -4685,19 +4840,21 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
4685
4840
  }
4686
4841
  }
4687
4842
 
4688
- export function __wbg_new_405e22f390576ce2() {
4689
- const ret = new Object();
4843
+ export function __wbg_new_5a79be3ab53b8aa5(arg0) {
4844
+ const ret = new Uint8Array(getObject(arg0));
4690
4845
  return addHeapObject(ret);
4691
4846
  }
4692
4847
 
4693
- export function __wbg_new_5e0be73521bc8c17() {
4848
+ export function __wbg_new_68651c719dcda04e() {
4694
4849
  const ret = new Map();
4695
4850
  return addHeapObject(ret);
4696
4851
  }
4697
4852
 
4698
- export function __wbg_new_78feb108b6472713() {
4699
- const ret = new Array();
4700
- return addHeapObject(ret);
4853
+ export function __wbg_new_6f694bb0585846e0() {
4854
+ return handleError(function () {
4855
+ const ret = new FormData();
4856
+ return addHeapObject(ret);
4857
+ }, arguments);
4701
4858
  }
4702
4859
 
4703
4860
  export function __wbg_new_8a6f238a6ece86ea() {
@@ -4705,28 +4862,21 @@ export function __wbg_new_8a6f238a6ece86ea() {
4705
4862
  return addHeapObject(ret);
4706
4863
  }
4707
4864
 
4708
- export function __wbg_new_9fd39a253424609a() {
4865
+ export function __wbg_new_9edf9838a2def39c() {
4709
4866
  return handleError(function () {
4710
- const ret = new FormData();
4867
+ const ret = new Headers();
4711
4868
  return addHeapObject(ret);
4712
4869
  }, arguments);
4713
4870
  }
4714
4871
 
4715
- export function __wbg_new_a12002a7f91c75be(arg0) {
4716
- const ret = new Uint8Array(getObject(arg0));
4717
- return addHeapObject(ret);
4718
- }
4719
-
4720
- export function __wbg_new_c68d7209be747379(arg0, arg1) {
4872
+ export function __wbg_new_a7442b4b19c1a356(arg0, arg1) {
4721
4873
  const ret = new Error(getStringFromWasm0(arg0, arg1));
4722
4874
  return addHeapObject(ret);
4723
4875
  }
4724
4876
 
4725
- export function __wbg_new_e25e5aab09ff45db() {
4726
- return handleError(function () {
4727
- const ret = new AbortController();
4728
- return addHeapObject(ret);
4729
- }, arguments);
4877
+ export function __wbg_new_e17d9f43105b08be() {
4878
+ const ret = new Array();
4879
+ return addHeapObject(ret);
4730
4880
  }
4731
4881
 
4732
4882
  export function __wbg_new_f24b6d53abe5bc82(arg0, arg1) {
@@ -4742,72 +4892,72 @@ export function __wbg_new_f24b6d53abe5bc82(arg0, arg1) {
4742
4892
  }
4743
4893
  }
4744
4894
 
4745
- export function __wbg_newnoargs_105ed471475aaf50(arg0, arg1) {
4746
- const ret = new Function(getStringFromWasm0(arg0, arg1));
4895
+ export function __wbg_new_from_slice_92f4d78ca282a2d2(arg0, arg1) {
4896
+ const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
4747
4897
  return addHeapObject(ret);
4748
4898
  }
4749
4899
 
4750
- export function __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a(arg0, arg1, arg2) {
4751
- const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
4900
+ export function __wbg_new_no_args_ee98eee5275000a4(arg0, arg1) {
4901
+ const ret = new Function(getStringFromWasm0(arg0, arg1));
4752
4902
  return addHeapObject(ret);
4753
4903
  }
4754
4904
 
4755
- export function __wbg_newwithlength_a381634e90c276d4(arg0) {
4905
+ export function __wbg_new_with_length_01aa0dc35aa13543(arg0) {
4756
4906
  const ret = new Uint8Array(arg0 >>> 0);
4757
4907
  return addHeapObject(ret);
4758
4908
  }
4759
4909
 
4760
- export function __wbg_newwithstrandinit_06c535e0a867c635() {
4910
+ export function __wbg_new_with_str_and_init_0ae7728b6ec367b1() {
4761
4911
  return handleError(function (arg0, arg1, arg2) {
4762
4912
  const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
4763
4913
  return addHeapObject(ret);
4764
4914
  }, arguments);
4765
4915
  }
4766
4916
 
4767
- export function __wbg_newwithu8arraysequenceandoptions_068570c487f69127() {
4917
+ export function __wbg_new_with_u8_array_sequence_and_options_0c1d0bd56d93d25a() {
4768
4918
  return handleError(function (arg0, arg1) {
4769
4919
  const ret = new Blob(getObject(arg0), getObject(arg1));
4770
4920
  return addHeapObject(ret);
4771
4921
  }, arguments);
4772
4922
  }
4773
4923
 
4774
- export function __wbg_next_25feadfc0913fea9(arg0) {
4775
- const ret = getObject(arg0).next;
4776
- return addHeapObject(ret);
4777
- }
4778
-
4779
- export function __wbg_next_6574e1a8a62d1055() {
4924
+ export function __wbg_next_020810e0ae8ebcb0() {
4780
4925
  return handleError(function (arg0) {
4781
4926
  const ret = getObject(arg0).next();
4782
4927
  return addHeapObject(ret);
4783
4928
  }, arguments);
4784
4929
  }
4785
4930
 
4931
+ export function __wbg_next_2c826fe5dfec6b6a(arg0) {
4932
+ const ret = getObject(arg0).next;
4933
+ return addHeapObject(ret);
4934
+ }
4935
+
4786
4936
  export function __wbg_node_905d3e251edff8a2(arg0) {
4787
4937
  const ret = getObject(arg0).node;
4788
4938
  return addHeapObject(ret);
4789
4939
  }
4790
4940
 
4791
- export function __wbg_now_d18023d54d4e5500(arg0) {
4941
+ export function __wbg_now_f5ba683d8ce2c571(arg0) {
4792
4942
  const ret = getObject(arg0).now();
4793
4943
  return ret;
4794
4944
  }
4795
4945
 
4796
- export function __wbg_open_e0c0b2993eb596e1() {
4946
+ export function __wbg_open_9d8c51d122a5a6ea() {
4797
4947
  return handleError(function (arg0, arg1, arg2, arg3) {
4798
4948
  const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
4799
4949
  return addHeapObject(ret);
4800
4950
  }, arguments);
4801
4951
  }
4802
4952
 
4803
- export function __wbg_parse_def2e24ef1252aff() {
4953
+ export function __wbg_parse_2a704d6b78abb2b8() {
4804
4954
  return handleError(function (arg0, arg1) {
4805
4955
  const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
4806
4956
  return addHeapObject(ret);
4807
4957
  }, arguments);
4808
4958
  }
4809
4959
 
4810
- export function __wbg_preventDefault_c2314fd813c02b3c(arg0) {
4960
+ export function __wbg_preventDefault_1f362670ce7ef430(arg0) {
4811
4961
  getObject(arg0).preventDefault();
4812
4962
  }
4813
4963
 
@@ -4816,27 +4966,31 @@ export function __wbg_process_dc0fbacc7c1c06f7(arg0) {
4816
4966
  return addHeapObject(ret);
4817
4967
  }
4818
4968
 
4819
- export function __wbg_push_737cfc8c1432c2c6(arg0, arg1) {
4820
- const ret = getObject(arg0).push(getObject(arg1));
4821
- return ret;
4969
+ export function __wbg_prototypesetcall_2a6620b6922694b2(arg0, arg1, arg2) {
4970
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
4822
4971
  }
4823
4972
 
4824
- export function __wbg_queueMicrotask_97d92b4fcc8a61c5(arg0) {
4825
- queueMicrotask(getObject(arg0));
4973
+ export function __wbg_push_df81a39d04db858c(arg0, arg1) {
4974
+ const ret = getObject(arg0).push(getObject(arg1));
4975
+ return ret;
4826
4976
  }
4827
4977
 
4828
- export function __wbg_queueMicrotask_d3219def82552485(arg0) {
4978
+ export function __wbg_queueMicrotask_34d692c25c47d05b(arg0) {
4829
4979
  const ret = getObject(arg0).queueMicrotask;
4830
4980
  return addHeapObject(ret);
4831
4981
  }
4832
4982
 
4983
+ export function __wbg_queueMicrotask_9d76cacb20c84d58(arg0) {
4984
+ queueMicrotask(getObject(arg0));
4985
+ }
4986
+
4833
4987
  export function __wbg_randomFillSync_ac0988aba3254290() {
4834
4988
  return handleError(function (arg0, arg1) {
4835
4989
  getObject(arg0).randomFillSync(takeObject(arg1));
4836
4990
  }, arguments);
4837
4991
  }
4838
4992
 
4839
- export function __wbg_remove_956f7c593f896a01() {
4993
+ export function __wbg_remove_3bf97e854da9e7c3() {
4840
4994
  return handleError(function (arg0, arg1, arg2) {
4841
4995
  let deferred0_0;
4842
4996
  let deferred0_1;
@@ -4851,7 +5005,7 @@ export function __wbg_remove_956f7c593f896a01() {
4851
5005
  }, arguments);
4852
5006
  }
4853
5007
 
4854
- export function __wbg_remove_e3a32c8e47e778c1() {
5008
+ export function __wbg_remove_be4a47406b9a0def() {
4855
5009
  return handleError(function (arg0, arg1, arg2) {
4856
5010
  let deferred0_0;
4857
5011
  let deferred0_1;
@@ -4873,12 +5027,12 @@ export function __wbg_require_60cc747a6bc5215a() {
4873
5027
  }, arguments);
4874
5028
  }
4875
5029
 
4876
- export function __wbg_resolve_4851785c9c5f573d(arg0) {
5030
+ export function __wbg_resolve_caf97c30b83f7053(arg0) {
4877
5031
  const ret = Promise.resolve(getObject(arg0));
4878
5032
  return addHeapObject(ret);
4879
5033
  }
4880
5034
 
4881
- export function __wbg_result_f29afabdf2c05826() {
5035
+ export function __wbg_result_25e75004b82b9830() {
4882
5036
  return handleError(function (arg0) {
4883
5037
  const ret = getObject(arg0).result;
4884
5038
  return addHeapObject(ret);
@@ -4897,19 +5051,7 @@ export function __wbg_setTimeout_ca12ead8b48245e2(arg0, arg1) {
4897
5051
  return addHeapObject(ret);
4898
5052
  }
4899
5053
 
4900
- export function __wbg_set_37837023f3d740e8(arg0, arg1, arg2) {
4901
- getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
4902
- }
4903
-
4904
- export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
4905
- getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
4906
- }
4907
-
4908
- export function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) {
4909
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
4910
- }
4911
-
4912
- export function __wbg_set_89104a657df0b114() {
5054
+ export function __wbg_set_10039b2e1149cb0c() {
4913
5055
  return handleError(function (arg0, arg1, arg2, arg3) {
4914
5056
  let deferred0_0;
4915
5057
  let deferred0_1;
@@ -4924,12 +5066,28 @@ export function __wbg_set_89104a657df0b114() {
4924
5066
  }, arguments);
4925
5067
  }
4926
5068
 
4927
- export function __wbg_set_8fc6bf8a5b1071d1(arg0, arg1, arg2) {
5069
+ export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
5070
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
5071
+ }
5072
+
5073
+ export function __wbg_set_907fb406c34a251d(arg0, arg1, arg2) {
4928
5074
  const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
4929
5075
  return addHeapObject(ret);
4930
5076
  }
4931
5077
 
4932
- export function __wbg_set_d46a2477f493c1aa() {
5078
+ export function __wbg_set_body_3c365989753d61f4(arg0, arg1) {
5079
+ getObject(arg0).body = getObject(arg1);
5080
+ }
5081
+
5082
+ export function __wbg_set_c213c871859d6500(arg0, arg1, arg2) {
5083
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
5084
+ }
5085
+
5086
+ export function __wbg_set_credentials_f621cd2d85c0c228(arg0, arg1) {
5087
+ getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
5088
+ }
5089
+
5090
+ export function __wbg_set_f2f0abdffceab618() {
4933
5091
  return handleError(function (arg0, arg1, arg2, arg3) {
4934
5092
  let deferred0_0;
4935
5093
  let deferred0_1;
@@ -4944,27 +5102,19 @@ export function __wbg_set_d46a2477f493c1aa() {
4944
5102
  }, arguments);
4945
5103
  }
4946
5104
 
4947
- export function __wbg_setbody_5923b78a95eedf29(arg0, arg1) {
4948
- getObject(arg0).body = getObject(arg1);
4949
- }
4950
-
4951
- export function __wbg_setcredentials_c3a22f1cd105a2c6(arg0, arg1) {
4952
- getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
4953
- }
4954
-
4955
- export function __wbg_setheaders_834c0bdb6a8949ad(arg0, arg1) {
5105
+ export function __wbg_set_headers_6926da238cd32ee4(arg0, arg1) {
4956
5106
  getObject(arg0).headers = getObject(arg1);
4957
5107
  }
4958
5108
 
4959
- export function __wbg_setmethod_3c5280fe5d890842(arg0, arg1, arg2) {
5109
+ export function __wbg_set_method_c02d8cbbe204ac2d(arg0, arg1, arg2) {
4960
5110
  getObject(arg0).method = getStringFromWasm0(arg1, arg2);
4961
5111
  }
4962
5112
 
4963
- export function __wbg_setmode_5dc300b865044b65(arg0, arg1) {
5113
+ export function __wbg_set_mode_52ef73cfa79639cb(arg0, arg1) {
4964
5114
  getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
4965
5115
  }
4966
5116
 
4967
- export function __wbg_setname_c0e2d6f348c746f4(arg0, arg1, arg2) {
5117
+ export function __wbg_set_name_c0e2d6f348c746f4(arg0, arg1, arg2) {
4968
5118
  let deferred0_0;
4969
5119
  let deferred0_1;
4970
5120
  try {
@@ -4976,27 +5126,27 @@ export function __wbg_setname_c0e2d6f348c746f4(arg0, arg1, arg2) {
4976
5126
  }
4977
5127
  }
4978
5128
 
4979
- export function __wbg_setonerror_d7e3056cc6e56085(arg0, arg1) {
5129
+ export function __wbg_set_onerror_dc82fea584ffccaa(arg0, arg1) {
4980
5130
  getObject(arg0).onerror = getObject(arg1);
4981
5131
  }
4982
5132
 
4983
- export function __wbg_setonsuccess_afa464ee777a396d(arg0, arg1) {
5133
+ export function __wbg_set_onsuccess_f367d002b462109e(arg0, arg1) {
4984
5134
  getObject(arg0).onsuccess = getObject(arg1);
4985
5135
  }
4986
5136
 
4987
- export function __wbg_setonupgradeneeded_fcf7ce4f2eb0cb5f(arg0, arg1) {
5137
+ export function __wbg_set_onupgradeneeded_0a519a73284a1418(arg0, arg1) {
4988
5138
  getObject(arg0).onupgradeneeded = getObject(arg1);
4989
5139
  }
4990
5140
 
4991
- export function __wbg_setsignal_75b21ef3a81de905(arg0, arg1) {
5141
+ export function __wbg_set_signal_dda2cf7ccb6bee0f(arg0, arg1) {
4992
5142
  getObject(arg0).signal = getObject(arg1);
4993
5143
  }
4994
5144
 
4995
- export function __wbg_settype_39ed370d3edd403c(arg0, arg1, arg2) {
5145
+ export function __wbg_set_type_63fa4c18251f6545(arg0, arg1, arg2) {
4996
5146
  getObject(arg0).type = getStringFromWasm0(arg1, arg2);
4997
5147
  }
4998
5148
 
4999
- export function __wbg_setvariant_d1d41b778dfe9c17(arg0, arg1, arg2) {
5149
+ export function __wbg_set_variant_d1d41b778dfe9c17(arg0, arg1, arg2) {
5000
5150
  let deferred0_0;
5001
5151
  let deferred0_1;
5002
5152
  try {
@@ -5008,7 +5158,7 @@ export function __wbg_setvariant_d1d41b778dfe9c17(arg0, arg1, arg2) {
5008
5158
  }
5009
5159
  }
5010
5160
 
5011
- export function __wbg_signal_aaf9ad74119f20a4(arg0) {
5161
+ export function __wbg_signal_4db5aa055bf9eb9a(arg0) {
5012
5162
  const ret = getObject(arg0).signal;
5013
5163
  return addHeapObject(ret);
5014
5164
  }
@@ -5021,22 +5171,22 @@ export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
5021
5171
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
5022
5172
  }
5023
5173
 
5024
- export function __wbg_static_accessor_GLOBAL_88a902d13a557d07() {
5174
+ export function __wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e() {
5025
5175
  const ret = typeof global === "undefined" ? null : global;
5026
5176
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
5027
5177
  }
5028
5178
 
5029
- export function __wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0() {
5179
+ export function __wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac() {
5030
5180
  const ret = typeof globalThis === "undefined" ? null : globalThis;
5031
5181
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
5032
5182
  }
5033
5183
 
5034
- export function __wbg_static_accessor_SELF_37c5d418e4bf5819() {
5184
+ export function __wbg_static_accessor_SELF_6fdf4b64710cc91b() {
5035
5185
  const ret = typeof self === "undefined" ? null : self;
5036
5186
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
5037
5187
  }
5038
5188
 
5039
- export function __wbg_static_accessor_WINDOW_5de37043a91a9c40() {
5189
+ export function __wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2() {
5040
5190
  const ret = typeof window === "undefined" ? null : window;
5041
5191
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
5042
5192
  }
@@ -5046,51 +5196,51 @@ export function __wbg_static_accessor_performance_da77b3a901a72934() {
5046
5196
  return addHeapObject(ret);
5047
5197
  }
5048
5198
 
5049
- export function __wbg_status_f6360336ca686bf0(arg0) {
5199
+ export function __wbg_status_de7eed5a7a5bfd5d(arg0) {
5050
5200
  const ret = getObject(arg0).status;
5051
5201
  return ret;
5052
5202
  }
5053
5203
 
5054
- export function __wbg_stringify_f7ed6987935b4a24() {
5204
+ export function __wbg_stringify_b5fb28f6465d9c3e() {
5055
5205
  return handleError(function (arg0) {
5056
5206
  const ret = JSON.stringify(getObject(arg0));
5057
5207
  return addHeapObject(ret);
5058
5208
  }, arguments);
5059
5209
  }
5060
5210
 
5061
- export function __wbg_subarray_aa9065fa9dc5df96(arg0, arg1, arg2) {
5211
+ export function __wbg_subarray_480600f3d6a9f26c(arg0, arg1, arg2) {
5062
5212
  const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
5063
5213
  return addHeapObject(ret);
5064
5214
  }
5065
5215
 
5066
- export function __wbg_target_0a62d9d79a2a1ede(arg0) {
5216
+ export function __wbg_target_1447f5d3a6fa6fe0(arg0) {
5067
5217
  const ret = getObject(arg0).target;
5068
5218
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
5069
5219
  }
5070
5220
 
5071
- export function __wbg_text_7805bea50de2af49() {
5221
+ export function __wbg_text_dc33c15c17bdfb52() {
5072
5222
  return handleError(function (arg0) {
5073
5223
  const ret = getObject(arg0).text();
5074
5224
  return addHeapObject(ret);
5075
5225
  }, arguments);
5076
5226
  }
5077
5227
 
5078
- export function __wbg_then_44b73946d2fb3e7d(arg0, arg1) {
5228
+ export function __wbg_then_4f46f6544e6b4a28(arg0, arg1) {
5079
5229
  const ret = getObject(arg0).then(getObject(arg1));
5080
5230
  return addHeapObject(ret);
5081
5231
  }
5082
5232
 
5083
- export function __wbg_then_48b406749878a531(arg0, arg1, arg2) {
5233
+ export function __wbg_then_70d05cf780a18d77(arg0, arg1, arg2) {
5084
5234
  const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
5085
5235
  return addHeapObject(ret);
5086
5236
  }
5087
5237
 
5088
- export function __wbg_transaction_e713aa7b07ccaedd(arg0) {
5238
+ export function __wbg_transaction_9fb8349a0a81725c(arg0) {
5089
5239
  const ret = getObject(arg0).transaction;
5090
5240
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
5091
5241
  }
5092
5242
 
5093
- export function __wbg_url_ae10c34ca209681d(arg0, arg1) {
5243
+ export function __wbg_url_b36d2a5008eb056f(arg0, arg1) {
5094
5244
  const ret = getObject(arg1).url;
5095
5245
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
5096
5246
  const len1 = WASM_VECTOR_LEN;
@@ -5098,7 +5248,7 @@ export function __wbg_url_ae10c34ca209681d(arg0, arg1) {
5098
5248
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
5099
5249
  }
5100
5250
 
5101
- export function __wbg_value_cd1ffa7b1ab794f1(arg0) {
5251
+ export function __wbg_value_692627309814bb8c(arg0) {
5102
5252
  const ret = getObject(arg0).value;
5103
5253
  return addHeapObject(ret);
5104
5254
  }
@@ -5108,150 +5258,116 @@ export function __wbg_versions_c01dfd4722a88165(arg0) {
5108
5258
  return addHeapObject(ret);
5109
5259
  }
5110
5260
 
5111
- export function __wbg_warn_aaf1f4664a035bd6(arg0, arg1, arg2, arg3) {
5261
+ export function __wbg_warn_8f5b5437666d0885(arg0, arg1, arg2, arg3) {
5112
5262
  console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
5113
5263
  }
5114
5264
 
5115
- export function __wbindgen_array_new() {
5116
- const ret = [];
5265
+ export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
5266
+ // Cast intrinsic for `Ref(String) -> Externref`.
5267
+ const ret = getStringFromWasm0(arg0, arg1);
5117
5268
  return addHeapObject(ret);
5118
5269
  }
5119
5270
 
5120
- export function __wbindgen_array_push(arg0, arg1) {
5121
- getObject(arg0).push(takeObject(arg1));
5122
- }
5123
-
5124
- export function __wbindgen_as_number(arg0) {
5125
- const ret = +getObject(arg0);
5126
- return ret;
5127
- }
5128
-
5129
- export function __wbindgen_bigint_from_i64(arg0) {
5130
- const ret = arg0;
5271
+ export function __wbindgen_cast_36265b4dca1d434b(arg0, arg1) {
5272
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 268, function: Function { arguments: [], shim_idx: 269, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
5273
+ const ret = makeMutClosure(
5274
+ arg0,
5275
+ arg1,
5276
+ wasm.wasm_bindgen__closure__destroy__h04ff7fddf688fec6,
5277
+ wasm_bindgen__convert__closures_____invoke__h76c71c1158b6af01,
5278
+ );
5131
5279
  return addHeapObject(ret);
5132
5280
  }
5133
5281
 
5134
- export function __wbindgen_bigint_from_u64(arg0) {
5282
+ export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
5283
+ // Cast intrinsic for `U64 -> Externref`.
5135
5284
  const ret = BigInt.asUintN(64, arg0);
5136
5285
  return addHeapObject(ret);
5137
5286
  }
5138
5287
 
5139
- export function __wbindgen_bigint_get_as_i64(arg0, arg1) {
5140
- const v = getObject(arg1);
5141
- const ret = typeof v === "bigint" ? v : undefined;
5142
- getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
5143
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
5144
- }
5145
-
5146
- export function __wbindgen_boolean_get(arg0) {
5147
- const v = getObject(arg0);
5148
- const ret = typeof v === "boolean" ? (v ? 1 : 0) : 2;
5149
- return ret;
5150
- }
5151
-
5152
- export function __wbindgen_cb_drop(arg0) {
5153
- const obj = takeObject(arg0).original;
5154
- if (obj.cnt-- == 1) {
5155
- obj.a = 0;
5156
- return true;
5157
- }
5158
- const ret = false;
5159
- return ret;
5160
- }
5161
-
5162
- export function __wbindgen_closure_wrapper198(arg0, arg1, arg2) {
5163
- const ret = makeMutClosure(arg0, arg1, 7, __wbg_adapter_54);
5288
+ export function __wbindgen_cast_5fea77eff9dd275c(arg0, arg1) {
5289
+ var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
5290
+ wasm.__wbindgen_free(arg0, arg1 * 4, 4);
5291
+ // Cast intrinsic for `Vector(NamedExternref("CipherRiskResult")) -> Externref`.
5292
+ const ret = v0;
5164
5293
  return addHeapObject(ret);
5165
5294
  }
5166
5295
 
5167
- export function __wbindgen_closure_wrapper200(arg0, arg1, arg2) {
5168
- const ret = makeMutClosure(arg0, arg1, 7, __wbg_adapter_57);
5296
+ export function __wbindgen_cast_7a6d185652cd8149(arg0, arg1) {
5297
+ var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
5298
+ wasm.__wbindgen_free(arg0, arg1 * 4, 4);
5299
+ // Cast intrinsic for `Vector(NamedExternref("Cipher")) -> Externref`.
5300
+ const ret = v0;
5169
5301
  return addHeapObject(ret);
5170
5302
  }
5171
5303
 
5172
- export function __wbindgen_closure_wrapper4512(arg0, arg1, arg2) {
5173
- const ret = makeMutClosure(arg0, arg1, 349, __wbg_adapter_60);
5304
+ export function __wbindgen_cast_91244c1b651c8ba8(arg0, arg1) {
5305
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 5, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 6, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
5306
+ const ret = makeMutClosure(
5307
+ arg0,
5308
+ arg1,
5309
+ wasm.wasm_bindgen__closure__destroy__h7a400a8c6869e00b,
5310
+ wasm_bindgen__convert__closures_____invoke__h142f80da75ccedf5,
5311
+ );
5174
5312
  return addHeapObject(ret);
5175
5313
  }
5176
5314
 
5177
- export function __wbindgen_closure_wrapper8569(arg0, arg1, arg2) {
5178
- const ret = makeMutClosure(arg0, arg1, 516, __wbg_adapter_60);
5315
+ export function __wbindgen_cast_98de615b9dbdc064(arg0, arg1) {
5316
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 268, function: Function { arguments: [Externref], shim_idx: 6, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
5317
+ const ret = makeMutClosure(
5318
+ arg0,
5319
+ arg1,
5320
+ wasm.wasm_bindgen__closure__destroy__h04ff7fddf688fec6,
5321
+ wasm_bindgen__convert__closures_____invoke__h142f80da75ccedf5,
5322
+ );
5179
5323
  return addHeapObject(ret);
5180
5324
  }
5181
5325
 
5182
- export function __wbindgen_closure_wrapper8955(arg0, arg1, arg2) {
5183
- const ret = makeMutClosure(arg0, arg1, 538, __wbg_adapter_54);
5326
+ export function __wbindgen_cast_9ae0607507abb057(arg0) {
5327
+ // Cast intrinsic for `I64 -> Externref`.
5328
+ const ret = arg0;
5184
5329
  return addHeapObject(ret);
5185
5330
  }
5186
5331
 
5187
- export function __wbindgen_debug_string(arg0, arg1) {
5188
- const ret = debugString(getObject(arg1));
5189
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
5190
- const len1 = WASM_VECTOR_LEN;
5191
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
5192
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
5193
- }
5194
-
5195
- export function __wbindgen_error_new(arg0, arg1) {
5196
- const ret = new Error(getStringFromWasm0(arg0, arg1));
5332
+ export function __wbindgen_cast_cb9088102bce6b30(arg0, arg1) {
5333
+ // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
5334
+ const ret = getArrayU8FromWasm0(arg0, arg1);
5197
5335
  return addHeapObject(ret);
5198
5336
  }
5199
5337
 
5200
- export function __wbindgen_in(arg0, arg1) {
5201
- const ret = getObject(arg0) in getObject(arg1);
5202
- return ret;
5203
- }
5204
-
5205
- export function __wbindgen_is_bigint(arg0) {
5206
- const ret = typeof getObject(arg0) === "bigint";
5207
- return ret;
5208
- }
5209
-
5210
- export function __wbindgen_is_function(arg0) {
5211
- const ret = typeof getObject(arg0) === "function";
5212
- return ret;
5213
- }
5214
-
5215
- export function __wbindgen_is_object(arg0) {
5216
- const val = getObject(arg0);
5217
- const ret = typeof val === "object" && val !== null;
5218
- return ret;
5219
- }
5220
-
5221
- export function __wbindgen_is_string(arg0) {
5222
- const ret = typeof getObject(arg0) === "string";
5223
- return ret;
5224
- }
5225
-
5226
- export function __wbindgen_is_undefined(arg0) {
5227
- const ret = getObject(arg0) === undefined;
5228
- return ret;
5229
- }
5230
-
5231
- export function __wbindgen_jsval_eq(arg0, arg1) {
5232
- const ret = getObject(arg0) === getObject(arg1);
5233
- return ret;
5234
- }
5235
-
5236
- export function __wbindgen_jsval_loose_eq(arg0, arg1) {
5237
- const ret = getObject(arg0) == getObject(arg1);
5238
- return ret;
5338
+ export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
5339
+ // Cast intrinsic for `F64 -> Externref`.
5340
+ const ret = arg0;
5341
+ return addHeapObject(ret);
5239
5342
  }
5240
5343
 
5241
- export function __wbindgen_memory() {
5242
- const ret = wasm.memory;
5344
+ export function __wbindgen_cast_e904f2c9fda6146b(arg0, arg1) {
5345
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 5, function: Function { arguments: [NamedExternref("Event")], shim_idx: 8, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
5346
+ const ret = makeMutClosure(
5347
+ arg0,
5348
+ arg1,
5349
+ wasm.wasm_bindgen__closure__destroy__h7a400a8c6869e00b,
5350
+ wasm_bindgen__convert__closures_____invoke__he84e41ce162f03b8,
5351
+ );
5243
5352
  return addHeapObject(ret);
5244
5353
  }
5245
5354
 
5246
- export function __wbindgen_number_get(arg0, arg1) {
5247
- const obj = getObject(arg1);
5248
- const ret = typeof obj === "number" ? obj : undefined;
5249
- getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
5250
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
5355
+ export function __wbindgen_cast_ef90a087adb7475d(arg0, arg1) {
5356
+ var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
5357
+ wasm.__wbindgen_free(arg0, arg1 * 4, 4);
5358
+ // Cast intrinsic for `Vector(NamedExternref("FolderView")) -> Externref`.
5359
+ const ret = v0;
5360
+ return addHeapObject(ret);
5251
5361
  }
5252
5362
 
5253
- export function __wbindgen_number_new(arg0) {
5254
- const ret = arg0;
5363
+ export function __wbindgen_cast_f31034722c398fdb(arg0, arg1) {
5364
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 520, function: Function { arguments: [], shim_idx: 269, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
5365
+ const ret = makeMutClosure(
5366
+ arg0,
5367
+ arg1,
5368
+ wasm.wasm_bindgen__closure__destroy__h1cce7ce4a094839d,
5369
+ wasm_bindgen__convert__closures_____invoke__h76c71c1158b6af01,
5370
+ );
5255
5371
  return addHeapObject(ret);
5256
5372
  }
5257
5373
 
@@ -5263,23 +5379,3 @@ export function __wbindgen_object_clone_ref(arg0) {
5263
5379
  export function __wbindgen_object_drop_ref(arg0) {
5264
5380
  takeObject(arg0);
5265
5381
  }
5266
-
5267
- export function __wbindgen_string_get(arg0, arg1) {
5268
- const obj = getObject(arg1);
5269
- const ret = typeof obj === "string" ? obj : undefined;
5270
- var ptr1 = isLikeNone(ret)
5271
- ? 0
5272
- : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
5273
- var len1 = WASM_VECTOR_LEN;
5274
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
5275
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
5276
- }
5277
-
5278
- export function __wbindgen_string_new(arg0, arg1) {
5279
- const ret = getStringFromWasm0(arg0, arg1);
5280
- return addHeapObject(ret);
5281
- }
5282
-
5283
- export function __wbindgen_throw(arg0, arg1) {
5284
- throw new Error(getStringFromWasm0(arg0, arg1));
5285
- }