@openfort/react 0.0.33 → 0.0.34
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.
|
@@ -0,0 +1,389 @@
|
|
|
1
|
+
export declare function useExtendedWalletClient(): import("viem").Client<import("viem").CustomTransport, import("viem").Chain, {
|
|
2
|
+
client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
|
|
3
|
+
address: import("viem").Address;
|
|
4
|
+
nonceManager?: import("viem").NonceManager | undefined;
|
|
5
|
+
sign?: ((parameters: {
|
|
6
|
+
hash: import("viem").Hash;
|
|
7
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
8
|
+
signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
|
|
9
|
+
signMessage: ({ message }: {
|
|
10
|
+
message: import("viem").SignableMessage;
|
|
11
|
+
}) => Promise<import("viem").Hex>;
|
|
12
|
+
signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
|
|
13
|
+
serializer?: serializer | undefined;
|
|
14
|
+
} | undefined) => Promise<import("viem").Hex>;
|
|
15
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
16
|
+
publicKey: import("viem").Hex;
|
|
17
|
+
source: string;
|
|
18
|
+
type: "local";
|
|
19
|
+
} | import("viem").JsonRpcAccount | undefined>;
|
|
20
|
+
entryPoint: {
|
|
21
|
+
abi: import("viem").Abi;
|
|
22
|
+
address: import("viem").Address;
|
|
23
|
+
version: import("viem/_types/account-abstraction").EntryPointVersion;
|
|
24
|
+
};
|
|
25
|
+
extend?: object | undefined;
|
|
26
|
+
getAddress: () => Promise<import("viem").Address>;
|
|
27
|
+
decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
|
|
28
|
+
to: import("viem").Hex;
|
|
29
|
+
data?: import("viem").Hex | undefined;
|
|
30
|
+
value?: bigint | undefined;
|
|
31
|
+
}[]>) | undefined | undefined;
|
|
32
|
+
encodeCalls: (calls: readonly {
|
|
33
|
+
to: import("viem").Hex;
|
|
34
|
+
data?: import("viem").Hex | undefined;
|
|
35
|
+
value?: bigint | undefined;
|
|
36
|
+
}[]) => Promise<import("viem").Hex>;
|
|
37
|
+
getFactoryArgs: () => Promise<{
|
|
38
|
+
factory?: import("viem").Address | undefined;
|
|
39
|
+
factoryData?: import("viem").Hex | undefined;
|
|
40
|
+
}>;
|
|
41
|
+
getNonce: (parameters?: {
|
|
42
|
+
key?: bigint | undefined;
|
|
43
|
+
} | undefined) => Promise<bigint>;
|
|
44
|
+
getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
|
|
45
|
+
nonceKeyManager?: import("viem").NonceManager | undefined;
|
|
46
|
+
sign?: ((parameters: {
|
|
47
|
+
hash: import("viem").Hash;
|
|
48
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
49
|
+
signMessage: (parameters: {
|
|
50
|
+
message: import("viem").SignableMessage;
|
|
51
|
+
}) => Promise<import("viem").Hex>;
|
|
52
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
53
|
+
signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
|
|
54
|
+
chainId?: number | undefined;
|
|
55
|
+
}) => Promise<import("viem").Hex>;
|
|
56
|
+
userOperation?: {
|
|
57
|
+
estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
|
|
58
|
+
} | undefined | undefined;
|
|
59
|
+
authorization?: undefined | undefined;
|
|
60
|
+
address: import("viem").Address;
|
|
61
|
+
isDeployed: () => Promise<boolean>;
|
|
62
|
+
type: "smart";
|
|
63
|
+
nonceManager?: undefined;
|
|
64
|
+
signAuthorization?: undefined;
|
|
65
|
+
signTransaction?: undefined;
|
|
66
|
+
publicKey?: undefined;
|
|
67
|
+
source?: undefined;
|
|
68
|
+
} | {
|
|
69
|
+
client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
|
|
70
|
+
address: import("viem").Address;
|
|
71
|
+
nonceManager?: import("viem").NonceManager | undefined;
|
|
72
|
+
sign?: ((parameters: {
|
|
73
|
+
hash: import("viem").Hash;
|
|
74
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
75
|
+
signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
|
|
76
|
+
signMessage: ({ message }: {
|
|
77
|
+
message: import("viem").SignableMessage;
|
|
78
|
+
}) => Promise<import("viem").Hex>;
|
|
79
|
+
signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
|
|
80
|
+
serializer?: serializer | undefined;
|
|
81
|
+
} | undefined) => Promise<import("viem").Hex>;
|
|
82
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
83
|
+
publicKey: import("viem").Hex;
|
|
84
|
+
source: string;
|
|
85
|
+
type: "local";
|
|
86
|
+
} | import("viem").JsonRpcAccount | undefined>;
|
|
87
|
+
entryPoint: {
|
|
88
|
+
abi: import("viem").Abi;
|
|
89
|
+
address: import("viem").Address;
|
|
90
|
+
version: import("viem/_types/account-abstraction").EntryPointVersion;
|
|
91
|
+
};
|
|
92
|
+
extend?: object | undefined;
|
|
93
|
+
getAddress: () => Promise<import("viem").Address>;
|
|
94
|
+
decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
|
|
95
|
+
to: import("viem").Hex;
|
|
96
|
+
data?: import("viem").Hex | undefined;
|
|
97
|
+
value?: bigint | undefined;
|
|
98
|
+
}[]>) | undefined | undefined;
|
|
99
|
+
encodeCalls: (calls: readonly {
|
|
100
|
+
to: import("viem").Hex;
|
|
101
|
+
data?: import("viem").Hex | undefined;
|
|
102
|
+
value?: bigint | undefined;
|
|
103
|
+
}[]) => Promise<import("viem").Hex>;
|
|
104
|
+
getFactoryArgs: () => Promise<{
|
|
105
|
+
factory?: import("viem").Address | undefined;
|
|
106
|
+
factoryData?: import("viem").Hex | undefined;
|
|
107
|
+
}>;
|
|
108
|
+
getNonce: (parameters?: {
|
|
109
|
+
key?: bigint | undefined;
|
|
110
|
+
} | undefined) => Promise<bigint>;
|
|
111
|
+
getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
|
|
112
|
+
nonceKeyManager?: import("viem").NonceManager | undefined;
|
|
113
|
+
sign?: ((parameters: {
|
|
114
|
+
hash: import("viem").Hash;
|
|
115
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
116
|
+
signMessage: (parameters: {
|
|
117
|
+
message: import("viem").SignableMessage;
|
|
118
|
+
}) => Promise<import("viem").Hex>;
|
|
119
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
120
|
+
signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
|
|
121
|
+
chainId?: number | undefined;
|
|
122
|
+
}) => Promise<import("viem").Hex>;
|
|
123
|
+
userOperation?: {
|
|
124
|
+
estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
|
|
125
|
+
} | undefined | undefined;
|
|
126
|
+
authorization: {
|
|
127
|
+
account: import("viem").PrivateKeyAccount;
|
|
128
|
+
address: import("viem").Address;
|
|
129
|
+
};
|
|
130
|
+
address: import("viem").Address;
|
|
131
|
+
isDeployed: () => Promise<boolean>;
|
|
132
|
+
type: "smart";
|
|
133
|
+
nonceManager?: undefined;
|
|
134
|
+
signAuthorization?: undefined;
|
|
135
|
+
signTransaction?: undefined;
|
|
136
|
+
publicKey?: undefined;
|
|
137
|
+
source?: undefined;
|
|
138
|
+
} | {
|
|
139
|
+
address: `0x${string}`;
|
|
140
|
+
type: "json-rpc";
|
|
141
|
+
extend?: undefined;
|
|
142
|
+
nonceManager?: undefined;
|
|
143
|
+
sign?: undefined;
|
|
144
|
+
signAuthorization?: undefined;
|
|
145
|
+
signMessage?: undefined;
|
|
146
|
+
signTransaction?: undefined;
|
|
147
|
+
signTypedData?: undefined;
|
|
148
|
+
publicKey?: undefined;
|
|
149
|
+
source?: undefined;
|
|
150
|
+
client?: undefined;
|
|
151
|
+
entryPoint?: undefined;
|
|
152
|
+
getAddress?: undefined;
|
|
153
|
+
decodeCalls?: undefined;
|
|
154
|
+
encodeCalls?: undefined;
|
|
155
|
+
getFactoryArgs?: undefined;
|
|
156
|
+
getNonce?: undefined;
|
|
157
|
+
getStubSignature?: undefined;
|
|
158
|
+
nonceKeyManager?: undefined;
|
|
159
|
+
signUserOperation?: undefined;
|
|
160
|
+
userOperation?: undefined;
|
|
161
|
+
authorization?: undefined;
|
|
162
|
+
isDeployed?: undefined;
|
|
163
|
+
} | {
|
|
164
|
+
address: import("viem").Address;
|
|
165
|
+
nonceManager?: import("viem").NonceManager | undefined;
|
|
166
|
+
sign?: ((parameters: {
|
|
167
|
+
hash: import("viem").Hash;
|
|
168
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
169
|
+
signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
|
|
170
|
+
signMessage: ({ message }: {
|
|
171
|
+
message: import("viem").SignableMessage;
|
|
172
|
+
}) => Promise<import("viem").Hex>;
|
|
173
|
+
signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
|
|
174
|
+
serializer?: serializer | undefined;
|
|
175
|
+
} | undefined) => Promise<import("viem").Hex>;
|
|
176
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
177
|
+
publicKey: import("viem").Hex;
|
|
178
|
+
source: string;
|
|
179
|
+
type: "local";
|
|
180
|
+
extend?: undefined;
|
|
181
|
+
client?: undefined;
|
|
182
|
+
entryPoint?: undefined;
|
|
183
|
+
getAddress?: undefined;
|
|
184
|
+
decodeCalls?: undefined;
|
|
185
|
+
encodeCalls?: undefined;
|
|
186
|
+
getFactoryArgs?: undefined;
|
|
187
|
+
getNonce?: undefined;
|
|
188
|
+
getStubSignature?: undefined;
|
|
189
|
+
nonceKeyManager?: undefined;
|
|
190
|
+
signUserOperation?: undefined;
|
|
191
|
+
userOperation?: undefined;
|
|
192
|
+
authorization?: undefined;
|
|
193
|
+
isDeployed?: undefined;
|
|
194
|
+
}, import("viem").WalletRpcSchema, {
|
|
195
|
+
grantPermissions: (parameters: import("viem/experimental").GrantPermissionsParameters) => Promise<import("viem/experimental").GrantPermissionsReturnType>;
|
|
196
|
+
} & import("viem").WalletActions<import("viem").Chain, {
|
|
197
|
+
client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
|
|
198
|
+
address: import("viem").Address;
|
|
199
|
+
nonceManager?: import("viem").NonceManager | undefined;
|
|
200
|
+
sign?: ((parameters: {
|
|
201
|
+
hash: import("viem").Hash;
|
|
202
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
203
|
+
signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
|
|
204
|
+
signMessage: ({ message }: {
|
|
205
|
+
message: import("viem").SignableMessage;
|
|
206
|
+
}) => Promise<import("viem").Hex>;
|
|
207
|
+
signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
|
|
208
|
+
serializer?: serializer | undefined;
|
|
209
|
+
} | undefined) => Promise<import("viem").Hex>;
|
|
210
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
211
|
+
publicKey: import("viem").Hex;
|
|
212
|
+
source: string;
|
|
213
|
+
type: "local";
|
|
214
|
+
} | import("viem").JsonRpcAccount | undefined>;
|
|
215
|
+
entryPoint: {
|
|
216
|
+
abi: import("viem").Abi;
|
|
217
|
+
address: import("viem").Address;
|
|
218
|
+
version: import("viem/_types/account-abstraction").EntryPointVersion;
|
|
219
|
+
};
|
|
220
|
+
extend?: object | undefined;
|
|
221
|
+
getAddress: () => Promise<import("viem").Address>;
|
|
222
|
+
decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
|
|
223
|
+
to: import("viem").Hex;
|
|
224
|
+
data?: import("viem").Hex | undefined;
|
|
225
|
+
value?: bigint | undefined;
|
|
226
|
+
}[]>) | undefined | undefined;
|
|
227
|
+
encodeCalls: (calls: readonly {
|
|
228
|
+
to: import("viem").Hex;
|
|
229
|
+
data?: import("viem").Hex | undefined;
|
|
230
|
+
value?: bigint | undefined;
|
|
231
|
+
}[]) => Promise<import("viem").Hex>;
|
|
232
|
+
getFactoryArgs: () => Promise<{
|
|
233
|
+
factory?: import("viem").Address | undefined;
|
|
234
|
+
factoryData?: import("viem").Hex | undefined;
|
|
235
|
+
}>;
|
|
236
|
+
getNonce: (parameters?: {
|
|
237
|
+
key?: bigint | undefined;
|
|
238
|
+
} | undefined) => Promise<bigint>;
|
|
239
|
+
getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
|
|
240
|
+
nonceKeyManager?: import("viem").NonceManager | undefined;
|
|
241
|
+
sign?: ((parameters: {
|
|
242
|
+
hash: import("viem").Hash;
|
|
243
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
244
|
+
signMessage: (parameters: {
|
|
245
|
+
message: import("viem").SignableMessage;
|
|
246
|
+
}) => Promise<import("viem").Hex>;
|
|
247
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
248
|
+
signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
|
|
249
|
+
chainId?: number | undefined;
|
|
250
|
+
}) => Promise<import("viem").Hex>;
|
|
251
|
+
userOperation?: {
|
|
252
|
+
estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
|
|
253
|
+
} | undefined | undefined;
|
|
254
|
+
authorization?: undefined | undefined;
|
|
255
|
+
address: import("viem").Address;
|
|
256
|
+
isDeployed: () => Promise<boolean>;
|
|
257
|
+
type: "smart";
|
|
258
|
+
nonceManager?: undefined;
|
|
259
|
+
signAuthorization?: undefined;
|
|
260
|
+
signTransaction?: undefined;
|
|
261
|
+
publicKey?: undefined;
|
|
262
|
+
source?: undefined;
|
|
263
|
+
} | {
|
|
264
|
+
client: import("viem").Client<import("viem").Transport, import("viem").Chain | undefined, {
|
|
265
|
+
address: import("viem").Address;
|
|
266
|
+
nonceManager?: import("viem").NonceManager | undefined;
|
|
267
|
+
sign?: ((parameters: {
|
|
268
|
+
hash: import("viem").Hash;
|
|
269
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
270
|
+
signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
|
|
271
|
+
signMessage: ({ message }: {
|
|
272
|
+
message: import("viem").SignableMessage;
|
|
273
|
+
}) => Promise<import("viem").Hex>;
|
|
274
|
+
signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
|
|
275
|
+
serializer?: serializer | undefined;
|
|
276
|
+
} | undefined) => Promise<import("viem").Hex>;
|
|
277
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
278
|
+
publicKey: import("viem").Hex;
|
|
279
|
+
source: string;
|
|
280
|
+
type: "local";
|
|
281
|
+
} | import("viem").JsonRpcAccount | undefined>;
|
|
282
|
+
entryPoint: {
|
|
283
|
+
abi: import("viem").Abi;
|
|
284
|
+
address: import("viem").Address;
|
|
285
|
+
version: import("viem/_types/account-abstraction").EntryPointVersion;
|
|
286
|
+
};
|
|
287
|
+
extend?: object | undefined;
|
|
288
|
+
getAddress: () => Promise<import("viem").Address>;
|
|
289
|
+
decodeCalls?: ((data: import("viem").Hex) => Promise<readonly {
|
|
290
|
+
to: import("viem").Hex;
|
|
291
|
+
data?: import("viem").Hex | undefined;
|
|
292
|
+
value?: bigint | undefined;
|
|
293
|
+
}[]>) | undefined | undefined;
|
|
294
|
+
encodeCalls: (calls: readonly {
|
|
295
|
+
to: import("viem").Hex;
|
|
296
|
+
data?: import("viem").Hex | undefined;
|
|
297
|
+
value?: bigint | undefined;
|
|
298
|
+
}[]) => Promise<import("viem").Hex>;
|
|
299
|
+
getFactoryArgs: () => Promise<{
|
|
300
|
+
factory?: import("viem").Address | undefined;
|
|
301
|
+
factoryData?: import("viem").Hex | undefined;
|
|
302
|
+
}>;
|
|
303
|
+
getNonce: (parameters?: {
|
|
304
|
+
key?: bigint | undefined;
|
|
305
|
+
} | undefined) => Promise<bigint>;
|
|
306
|
+
getStubSignature: (parameters?: import("viem/_types/account-abstraction").UserOperationRequest | undefined) => Promise<import("viem").Hex>;
|
|
307
|
+
nonceKeyManager?: import("viem").NonceManager | undefined;
|
|
308
|
+
sign?: ((parameters: {
|
|
309
|
+
hash: import("viem").Hash;
|
|
310
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
311
|
+
signMessage: (parameters: {
|
|
312
|
+
message: import("viem").SignableMessage;
|
|
313
|
+
}) => Promise<import("viem").Hex>;
|
|
314
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
315
|
+
signUserOperation: (parameters: import("viem").UnionPartialBy<import("viem/_types/account-abstraction").UserOperation, "sender"> & {
|
|
316
|
+
chainId?: number | undefined;
|
|
317
|
+
}) => Promise<import("viem").Hex>;
|
|
318
|
+
userOperation?: {
|
|
319
|
+
estimateGas?: ((userOperation: import("viem/_types/account-abstraction").UserOperationRequest) => Promise<import("viem").ExactPartial<import("viem/_types/account-abstraction/types/userOperation").EstimateUserOperationGasReturnType> | undefined>) | undefined;
|
|
320
|
+
} | undefined | undefined;
|
|
321
|
+
authorization: {
|
|
322
|
+
account: import("viem").PrivateKeyAccount;
|
|
323
|
+
address: import("viem").Address;
|
|
324
|
+
};
|
|
325
|
+
address: import("viem").Address;
|
|
326
|
+
isDeployed: () => Promise<boolean>;
|
|
327
|
+
type: "smart";
|
|
328
|
+
nonceManager?: undefined;
|
|
329
|
+
signAuthorization?: undefined;
|
|
330
|
+
signTransaction?: undefined;
|
|
331
|
+
publicKey?: undefined;
|
|
332
|
+
source?: undefined;
|
|
333
|
+
} | {
|
|
334
|
+
address: `0x${string}`;
|
|
335
|
+
type: "json-rpc";
|
|
336
|
+
extend?: undefined;
|
|
337
|
+
nonceManager?: undefined;
|
|
338
|
+
sign?: undefined;
|
|
339
|
+
signAuthorization?: undefined;
|
|
340
|
+
signMessage?: undefined;
|
|
341
|
+
signTransaction?: undefined;
|
|
342
|
+
signTypedData?: undefined;
|
|
343
|
+
publicKey?: undefined;
|
|
344
|
+
source?: undefined;
|
|
345
|
+
client?: undefined;
|
|
346
|
+
entryPoint?: undefined;
|
|
347
|
+
getAddress?: undefined;
|
|
348
|
+
decodeCalls?: undefined;
|
|
349
|
+
encodeCalls?: undefined;
|
|
350
|
+
getFactoryArgs?: undefined;
|
|
351
|
+
getNonce?: undefined;
|
|
352
|
+
getStubSignature?: undefined;
|
|
353
|
+
nonceKeyManager?: undefined;
|
|
354
|
+
signUserOperation?: undefined;
|
|
355
|
+
userOperation?: undefined;
|
|
356
|
+
authorization?: undefined;
|
|
357
|
+
isDeployed?: undefined;
|
|
358
|
+
} | {
|
|
359
|
+
address: import("viem").Address;
|
|
360
|
+
nonceManager?: import("viem").NonceManager | undefined;
|
|
361
|
+
sign?: ((parameters: {
|
|
362
|
+
hash: import("viem").Hash;
|
|
363
|
+
}) => Promise<import("viem").Hex>) | undefined | undefined;
|
|
364
|
+
signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
|
|
365
|
+
signMessage: ({ message }: {
|
|
366
|
+
message: import("viem").SignableMessage;
|
|
367
|
+
}) => Promise<import("viem").Hex>;
|
|
368
|
+
signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
|
|
369
|
+
serializer?: serializer | undefined;
|
|
370
|
+
} | undefined) => Promise<import("viem").Hex>;
|
|
371
|
+
signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
|
|
372
|
+
publicKey: import("viem").Hex;
|
|
373
|
+
source: string;
|
|
374
|
+
type: "local";
|
|
375
|
+
extend?: undefined;
|
|
376
|
+
client?: undefined;
|
|
377
|
+
entryPoint?: undefined;
|
|
378
|
+
getAddress?: undefined;
|
|
379
|
+
decodeCalls?: undefined;
|
|
380
|
+
encodeCalls?: undefined;
|
|
381
|
+
getFactoryArgs?: undefined;
|
|
382
|
+
getNonce?: undefined;
|
|
383
|
+
getStubSignature?: undefined;
|
|
384
|
+
nonceKeyManager?: undefined;
|
|
385
|
+
signUserOperation?: undefined;
|
|
386
|
+
userOperation?: undefined;
|
|
387
|
+
authorization?: undefined;
|
|
388
|
+
isDeployed?: undefined;
|
|
389
|
+
}>> | undefined;
|
|
@@ -0,0 +1,107 @@
|
|
|
1
|
+
import type { Hex } from 'viem';
|
|
2
|
+
import type { GrantPermissionsParameters, GrantPermissionsReturnType } from 'viem/experimental';
|
|
3
|
+
import { OpenfortError, type OpenfortHookOptions } from '../../types';
|
|
4
|
+
type GrantPermissionsRequest = {
|
|
5
|
+
request: GrantPermissionsParameters;
|
|
6
|
+
sessionKey: Hex;
|
|
7
|
+
};
|
|
8
|
+
type GrantPermissionsResult = {
|
|
9
|
+
address: `0x${string}`;
|
|
10
|
+
privateKey: `0x${string}`;
|
|
11
|
+
} & GrantPermissionsReturnType;
|
|
12
|
+
type GrantPermissionsHookResult = {
|
|
13
|
+
error?: OpenfortError;
|
|
14
|
+
} & Partial<GrantPermissionsResult>;
|
|
15
|
+
type GrantPermissionsHookOptions = OpenfortHookOptions<GrantPermissionsHookResult>;
|
|
16
|
+
/**
|
|
17
|
+
* Hook for granting permissions to session keys (EIP-7715)
|
|
18
|
+
*
|
|
19
|
+
* This hook manages the creation and authorization of session keys, allowing users to
|
|
20
|
+
* delegate permissions to specific accounts for a limited time. This enables use cases
|
|
21
|
+
* like session-based authentication and gasless transactions within defined scopes.
|
|
22
|
+
* The hook leverages EIP-7715 for permission granting.
|
|
23
|
+
*
|
|
24
|
+
* @param hookOptions - Optional configuration with callback functions
|
|
25
|
+
* @returns Current grant permissions state and actions
|
|
26
|
+
*
|
|
27
|
+
* @example
|
|
28
|
+
* ```tsx
|
|
29
|
+
* import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
|
|
30
|
+
* import { useGrantPermissions } from '@openfort/openfort-react';
|
|
31
|
+
*
|
|
32
|
+
* const { grantPermissions, isLoading, isError, error } = useGrantPermissions({
|
|
33
|
+
* onSuccess: (result) => console.log('Permissions granted:', result),
|
|
34
|
+
* onError: (error) => console.error('Permission grant failed:', error),
|
|
35
|
+
* });
|
|
36
|
+
*
|
|
37
|
+
* // Grant permissions to a session key
|
|
38
|
+
* const handleGrantPermissions = async () => {
|
|
39
|
+
* try {
|
|
40
|
+
* // Generate a new session key
|
|
41
|
+
* const sessionKey = generatePrivateKey();
|
|
42
|
+
* const accountSession = privateKeyToAccount(sessionKey).address;
|
|
43
|
+
*
|
|
44
|
+
* const result = await grantPermissions({
|
|
45
|
+
* sessionKey,
|
|
46
|
+
* request: {
|
|
47
|
+
* signer: {
|
|
48
|
+
* type: 'account',
|
|
49
|
+
* data: {
|
|
50
|
+
* id: accountSession,
|
|
51
|
+
* },
|
|
52
|
+
* },
|
|
53
|
+
* expiry: 60 * 60 * 24, // 24 hours
|
|
54
|
+
* permissions: [
|
|
55
|
+
* {
|
|
56
|
+
* type: 'contract-call',
|
|
57
|
+
* data: {
|
|
58
|
+
* address: '0x2522f4fc9af2e1954a3d13f7a5b2683a00a4543a',
|
|
59
|
+
* },
|
|
60
|
+
* },
|
|
61
|
+
* ],
|
|
62
|
+
* },
|
|
63
|
+
* });
|
|
64
|
+
*
|
|
65
|
+
* if (result.address) {
|
|
66
|
+
* console.log('Session created with address:', result.address);
|
|
67
|
+
* console.log('Session private key:', result.privateKey);
|
|
68
|
+
* }
|
|
69
|
+
* } catch (error) {
|
|
70
|
+
* console.error('Failed to grant permissions:', error);
|
|
71
|
+
* }
|
|
72
|
+
* };
|
|
73
|
+
*
|
|
74
|
+
* // Check permission grant state
|
|
75
|
+
* if (isLoading) {
|
|
76
|
+
* console.log('Granting permissions...');
|
|
77
|
+
* } else if (isError) {
|
|
78
|
+
* console.error('Permission grant error:', error);
|
|
79
|
+
* }
|
|
80
|
+
*
|
|
81
|
+
* // Example usage in component
|
|
82
|
+
* return (
|
|
83
|
+
* <div>
|
|
84
|
+
* <button
|
|
85
|
+
* onClick={handleGrantPermissions}
|
|
86
|
+
* disabled={isLoading}
|
|
87
|
+
* >
|
|
88
|
+
* {isLoading ? 'Granting Permissions...' : 'Create Session'}
|
|
89
|
+
* </button>
|
|
90
|
+
*
|
|
91
|
+
* {isError && (
|
|
92
|
+
* <p>Error: {error?.message}</p>
|
|
93
|
+
* )}
|
|
94
|
+
* </div>
|
|
95
|
+
* );
|
|
96
|
+
* ```
|
|
97
|
+
*/
|
|
98
|
+
export declare const useGrantPermissions: (hookOptions?: GrantPermissionsHookOptions) => {
|
|
99
|
+
isLoading: boolean;
|
|
100
|
+
isError: boolean;
|
|
101
|
+
isSuccess: boolean;
|
|
102
|
+
error: OpenfortError | null | undefined;
|
|
103
|
+
grantPermissions: ({ request, sessionKey }: GrantPermissionsRequest, options?: GrantPermissionsHookOptions) => Promise<GrantPermissionsHookResult>;
|
|
104
|
+
data: GrantPermissionsResult | null;
|
|
105
|
+
reset: () => void;
|
|
106
|
+
};
|
|
107
|
+
export {};
|
package/build/index.d.ts
CHANGED
|
@@ -15,6 +15,7 @@ export { useSignOut } from './hooks/openfort/auth/useSignOut';
|
|
|
15
15
|
export { useWalletAuth } from './hooks/openfort/auth/useWalletAuth';
|
|
16
16
|
export { type SignAuthorizationParameters, type SignAuthorizationReturnType, use7702Authorization, } from './hooks/openfort/use7702Authorization';
|
|
17
17
|
export { useConnectWithSiwe } from './hooks/openfort/useConnectWithSiwe';
|
|
18
|
+
export { useGrantPermissions } from './hooks/openfort/useGrantPermissions';
|
|
18
19
|
export { useUI } from './hooks/openfort/useUI';
|
|
19
20
|
export { useUser } from './hooks/openfort/useUser';
|
|
20
21
|
export { UserWallet, useWallets } from './hooks/openfort/useWallets';
|
package/build/index.es.js
CHANGED
|
@@ -3,7 +3,7 @@ export { AccountTypeEnum, OAuthProvider, OpenfortEvents, RecoveryMethod, ThirdPa
|
|
|
3
3
|
import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
|
|
4
4
|
import React, { useState, useEffect, createContext, useRef, useId, useMemo, useCallback, createElement, useLayoutEffect, useContext } from 'react';
|
|
5
5
|
import { normalize } from 'viem/ens';
|
|
6
|
-
import { useEnsAddress, useEnsName, useEnsAvatar, useConfig, useAccount, useBlockNumber, useBalance, useConnectors as useConnectors$1, useConnect as useConnect$1, useDisconnect, useChainId, http, useSwitchChain, usePublicClient, WagmiContext } from 'wagmi';
|
|
6
|
+
import { useEnsAddress, useEnsName, useEnsAvatar, useConfig, useAccount, useBlockNumber, useBalance, useConnectors as useConnectors$1, useConnect as useConnect$1, useDisconnect, useChainId, http, useSwitchChain, usePublicClient, WagmiContext, useWalletClient } from 'wagmi';
|
|
7
7
|
import { motion, AnimatePresence, MotionConfig } from 'framer-motion';
|
|
8
8
|
import styled$1, { css, keyframes } from 'styled-components';
|
|
9
9
|
import { detect } from 'detect-browser';
|
|
@@ -21,8 +21,9 @@ import calculateEntropy from 'fast-password-entropy';
|
|
|
21
21
|
import { switchChain, signMessage } from '@wagmi/core';
|
|
22
22
|
import { AxiosError } from 'axios';
|
|
23
23
|
import { createSiweMessage } from 'viem/siwe';
|
|
24
|
-
import { parseSignature } from 'viem';
|
|
24
|
+
import { parseSignature, createWalletClient, custom } from 'viem';
|
|
25
25
|
import { hashAuthorization } from 'viem/utils';
|
|
26
|
+
import { erc7715Actions } from 'viem/experimental';
|
|
26
27
|
|
|
27
28
|
// import { createConfig, http } from 'wagmi'
|
|
28
29
|
// import { mainnet } from 'wagmi/chains'
|
|
@@ -4496,10 +4497,10 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, ...openfortPr
|
|
|
4496
4497
|
}
|
|
4497
4498
|
}, [openfort]);
|
|
4498
4499
|
const chainId = useChainId();
|
|
4500
|
+
const wagmiConfig = useConfig();
|
|
4499
4501
|
useEffect(() => {
|
|
4500
4502
|
if (!openfort || !walletConfig)
|
|
4501
4503
|
return;
|
|
4502
|
-
logger.log('Getting ethereum provider', chainId);
|
|
4503
4504
|
const resolvePolicy = () => {
|
|
4504
4505
|
const { ethereumProviderPolicyId } = walletConfig;
|
|
4505
4506
|
if (!ethereumProviderPolicyId)
|
|
@@ -4514,7 +4515,18 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, ...openfortPr
|
|
|
4514
4515
|
}
|
|
4515
4516
|
return { policy };
|
|
4516
4517
|
};
|
|
4517
|
-
|
|
4518
|
+
const rpcUrls = wagmiConfig.chains.reduce((acc, chain) => {
|
|
4519
|
+
const rpcUrl = wagmiConfig.getClient({ chainId: chain.id }).transport.url;
|
|
4520
|
+
if (rpcUrl) {
|
|
4521
|
+
acc[chain.id] = rpcUrl;
|
|
4522
|
+
}
|
|
4523
|
+
return acc;
|
|
4524
|
+
}, {});
|
|
4525
|
+
logger.log('Getting ethereum provider', { chainId, rpcUrls });
|
|
4526
|
+
openfort.embeddedWallet.getEthereumProvider({
|
|
4527
|
+
...resolvePolicy(),
|
|
4528
|
+
chains: rpcUrls,
|
|
4529
|
+
});
|
|
4518
4530
|
}, [openfort, walletConfig, chainId]);
|
|
4519
4531
|
const [isConnectedWithEmbeddedSigner, setIsConnectedWithEmbeddedSigner] = useState(false);
|
|
4520
4532
|
// will reset on logout
|
|
@@ -5444,7 +5456,7 @@ const FitText = ({ children, maxFontSize = 100, minFontSize = 70, }) => {
|
|
|
5444
5456
|
};
|
|
5445
5457
|
FitText.displayName = 'FitText';
|
|
5446
5458
|
|
|
5447
|
-
const OPENFORT_VERSION = '0.0.
|
|
5459
|
+
const OPENFORT_VERSION = '0.0.34';
|
|
5448
5460
|
|
|
5449
5461
|
const Portal = (props) => {
|
|
5450
5462
|
props = {
|
|
@@ -14723,6 +14735,167 @@ function use7702Authorization() {
|
|
|
14723
14735
|
return { signAuthorization };
|
|
14724
14736
|
}
|
|
14725
14737
|
|
|
14738
|
+
function useExtendedWalletClient() {
|
|
14739
|
+
const { data: wagmiWalletClient } = useWalletClient();
|
|
14740
|
+
if (!wagmiWalletClient)
|
|
14741
|
+
return undefined;
|
|
14742
|
+
// Convert the wagmi wallet client to a viem wallet client
|
|
14743
|
+
const client = createWalletClient({
|
|
14744
|
+
account: wagmiWalletClient.account,
|
|
14745
|
+
chain: wagmiWalletClient.chain,
|
|
14746
|
+
transport: custom(wagmiWalletClient.transport),
|
|
14747
|
+
}).extend(erc7715Actions());
|
|
14748
|
+
return client;
|
|
14749
|
+
}
|
|
14750
|
+
|
|
14751
|
+
/**
|
|
14752
|
+
* Hook for granting permissions to session keys (EIP-7715)
|
|
14753
|
+
*
|
|
14754
|
+
* This hook manages the creation and authorization of session keys, allowing users to
|
|
14755
|
+
* delegate permissions to specific accounts for a limited time. This enables use cases
|
|
14756
|
+
* like session-based authentication and gasless transactions within defined scopes.
|
|
14757
|
+
* The hook leverages EIP-7715 for permission granting.
|
|
14758
|
+
*
|
|
14759
|
+
* @param hookOptions - Optional configuration with callback functions
|
|
14760
|
+
* @returns Current grant permissions state and actions
|
|
14761
|
+
*
|
|
14762
|
+
* @example
|
|
14763
|
+
* ```tsx
|
|
14764
|
+
* import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
|
|
14765
|
+
* import { useGrantPermissions } from '@openfort/openfort-react';
|
|
14766
|
+
*
|
|
14767
|
+
* const { grantPermissions, isLoading, isError, error } = useGrantPermissions({
|
|
14768
|
+
* onSuccess: (result) => console.log('Permissions granted:', result),
|
|
14769
|
+
* onError: (error) => console.error('Permission grant failed:', error),
|
|
14770
|
+
* });
|
|
14771
|
+
*
|
|
14772
|
+
* // Grant permissions to a session key
|
|
14773
|
+
* const handleGrantPermissions = async () => {
|
|
14774
|
+
* try {
|
|
14775
|
+
* // Generate a new session key
|
|
14776
|
+
* const sessionKey = generatePrivateKey();
|
|
14777
|
+
* const accountSession = privateKeyToAccount(sessionKey).address;
|
|
14778
|
+
*
|
|
14779
|
+
* const result = await grantPermissions({
|
|
14780
|
+
* sessionKey,
|
|
14781
|
+
* request: {
|
|
14782
|
+
* signer: {
|
|
14783
|
+
* type: 'account',
|
|
14784
|
+
* data: {
|
|
14785
|
+
* id: accountSession,
|
|
14786
|
+
* },
|
|
14787
|
+
* },
|
|
14788
|
+
* expiry: 60 * 60 * 24, // 24 hours
|
|
14789
|
+
* permissions: [
|
|
14790
|
+
* {
|
|
14791
|
+
* type: 'contract-call',
|
|
14792
|
+
* data: {
|
|
14793
|
+
* address: '0x2522f4fc9af2e1954a3d13f7a5b2683a00a4543a',
|
|
14794
|
+
* },
|
|
14795
|
+
* },
|
|
14796
|
+
* ],
|
|
14797
|
+
* },
|
|
14798
|
+
* });
|
|
14799
|
+
*
|
|
14800
|
+
* if (result.address) {
|
|
14801
|
+
* console.log('Session created with address:', result.address);
|
|
14802
|
+
* console.log('Session private key:', result.privateKey);
|
|
14803
|
+
* }
|
|
14804
|
+
* } catch (error) {
|
|
14805
|
+
* console.error('Failed to grant permissions:', error);
|
|
14806
|
+
* }
|
|
14807
|
+
* };
|
|
14808
|
+
*
|
|
14809
|
+
* // Check permission grant state
|
|
14810
|
+
* if (isLoading) {
|
|
14811
|
+
* console.log('Granting permissions...');
|
|
14812
|
+
* } else if (isError) {
|
|
14813
|
+
* console.error('Permission grant error:', error);
|
|
14814
|
+
* }
|
|
14815
|
+
*
|
|
14816
|
+
* // Example usage in component
|
|
14817
|
+
* return (
|
|
14818
|
+
* <div>
|
|
14819
|
+
* <button
|
|
14820
|
+
* onClick={handleGrantPermissions}
|
|
14821
|
+
* disabled={isLoading}
|
|
14822
|
+
* >
|
|
14823
|
+
* {isLoading ? 'Granting Permissions...' : 'Create Session'}
|
|
14824
|
+
* </button>
|
|
14825
|
+
*
|
|
14826
|
+
* {isError && (
|
|
14827
|
+
* <p>Error: {error?.message}</p>
|
|
14828
|
+
* )}
|
|
14829
|
+
* </div>
|
|
14830
|
+
* );
|
|
14831
|
+
* ```
|
|
14832
|
+
*/
|
|
14833
|
+
const useGrantPermissions = (hookOptions = {}) => {
|
|
14834
|
+
const chains = useChains();
|
|
14835
|
+
const chainId = useChainId();
|
|
14836
|
+
const [status, setStatus] = useState({
|
|
14837
|
+
status: 'idle',
|
|
14838
|
+
});
|
|
14839
|
+
const walletClient = useExtendedWalletClient();
|
|
14840
|
+
const [data, setData] = useState(null);
|
|
14841
|
+
const grantPermissions = useCallback(async ({ request, sessionKey }, options = {}) => {
|
|
14842
|
+
try {
|
|
14843
|
+
if (!walletClient) {
|
|
14844
|
+
throw new OpenfortError('Wallet client not available', OpenfortErrorType.WALLET_ERROR);
|
|
14845
|
+
}
|
|
14846
|
+
setStatus({
|
|
14847
|
+
status: 'loading',
|
|
14848
|
+
});
|
|
14849
|
+
// Get the current chain configuration
|
|
14850
|
+
const chain = chains.find((c) => c.id === chainId);
|
|
14851
|
+
if (!chain) {
|
|
14852
|
+
throw new OpenfortError('No chain configured', OpenfortErrorType.CONFIGURATION_ERROR);
|
|
14853
|
+
}
|
|
14854
|
+
// Get the account address
|
|
14855
|
+
const [account] = await walletClient.getAddresses();
|
|
14856
|
+
// Grant permissions
|
|
14857
|
+
const grantPermissionsResult = await walletClient.grantPermissions(request);
|
|
14858
|
+
const data = {
|
|
14859
|
+
address: account,
|
|
14860
|
+
privateKey: sessionKey,
|
|
14861
|
+
...grantPermissionsResult,
|
|
14862
|
+
};
|
|
14863
|
+
setData(data);
|
|
14864
|
+
setStatus({
|
|
14865
|
+
status: 'success',
|
|
14866
|
+
});
|
|
14867
|
+
return onSuccess({
|
|
14868
|
+
hookOptions,
|
|
14869
|
+
options,
|
|
14870
|
+
data,
|
|
14871
|
+
});
|
|
14872
|
+
}
|
|
14873
|
+
catch (error) {
|
|
14874
|
+
const openfortError = new OpenfortError('Failed to grant permissions', OpenfortErrorType.WALLET_ERROR, {
|
|
14875
|
+
error,
|
|
14876
|
+
});
|
|
14877
|
+
setStatus({
|
|
14878
|
+
status: 'error',
|
|
14879
|
+
error: openfortError,
|
|
14880
|
+
});
|
|
14881
|
+
return onError({
|
|
14882
|
+
hookOptions,
|
|
14883
|
+
options,
|
|
14884
|
+
error: openfortError,
|
|
14885
|
+
});
|
|
14886
|
+
}
|
|
14887
|
+
}, [chains, chainId, setStatus, hookOptions]);
|
|
14888
|
+
return {
|
|
14889
|
+
grantPermissions,
|
|
14890
|
+
data,
|
|
14891
|
+
reset: () => {
|
|
14892
|
+
setStatus({ status: 'idle' });
|
|
14893
|
+
setData(null);
|
|
14894
|
+
},
|
|
14895
|
+
...mapStatus(status),
|
|
14896
|
+
};
|
|
14897
|
+
};
|
|
14898
|
+
|
|
14726
14899
|
const wallets = Object.keys(walletConfigs).reduce((acc, key) => {
|
|
14727
14900
|
var _a, _b, _c, _d, _e, _f;
|
|
14728
14901
|
const config = walletConfigs[key];
|
|
@@ -14749,5 +14922,5 @@ const wallets = Object.keys(walletConfigs).reduce((acc, key) => {
|
|
|
14749
14922
|
return acc;
|
|
14750
14923
|
}, {});
|
|
14751
14924
|
|
|
14752
|
-
export { UIAuthProvider as AuthProvider, Avatar, Chain as ChainIcon, OPENFORT_VERSION, OpenfortButton, OpenfortError, OpenfortErrorType, OpenfortProvider, embeddedWalletId, defaultConfig as getDefaultConfig, defaultConnectors as getDefaultConnectors, use7702Authorization, useAuthCallback, useChainIsSupported, useChains, useConnectWithSiwe, useEmailAuth, useGuestAuth, useOAuth, useOpenfortCore as useOpenfort, useSignOut, useUI, useUser, useWalletAuth, useWallets, wallets };
|
|
14925
|
+
export { UIAuthProvider as AuthProvider, Avatar, Chain as ChainIcon, OPENFORT_VERSION, OpenfortButton, OpenfortError, OpenfortErrorType, OpenfortProvider, embeddedWalletId, defaultConfig as getDefaultConfig, defaultConnectors as getDefaultConnectors, use7702Authorization, useAuthCallback, useChainIsSupported, useChains, useConnectWithSiwe, useEmailAuth, useGrantPermissions, useGuestAuth, useOAuth, useOpenfortCore as useOpenfort, useSignOut, useUI, useUser, useWalletAuth, useWallets, wallets };
|
|
14753
14926
|
//# sourceMappingURL=index.es.js.map
|
package/build/index.es.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
|
|
1
|
+
{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
|
package/build/version.d.ts
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
export declare const OPENFORT_VERSION = "0.0.
|
|
1
|
+
export declare const OPENFORT_VERSION = "0.0.34";
|