@bitwarden/sdk-internal 0.2.0-main.334 → 0.2.0-main.336
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +1 -1
- package/VERSION +0 -1
- package/bitwarden_wasm_internal.d.ts +0 -2190
- package/bitwarden_wasm_internal.js +0 -4
- package/bitwarden_wasm_internal_bg.js +0 -5026
- package/bitwarden_wasm_internal_bg.wasm +0 -0
- package/bitwarden_wasm_internal_bg.wasm.d.ts +0 -431
- package/bitwarden_wasm_internal_bg.wasm.js +0 -1
- package/node/bitwarden_wasm_internal.d.ts +0 -2190
- package/node/bitwarden_wasm_internal.js +0 -5050
- package/node/bitwarden_wasm_internal_bg.wasm +0 -0
- package/node/bitwarden_wasm_internal_bg.wasm.d.ts +0 -431
|
@@ -1,5050 +0,0 @@
|
|
|
1
|
-
let imports = {};
|
|
2
|
-
imports["__wbindgen_placeholder__"] = module.exports;
|
|
3
|
-
let wasm;
|
|
4
|
-
const { TextEncoder, TextDecoder } = require(`util`);
|
|
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
|
-
let cachedUint8ArrayMemory0 = null;
|
|
17
|
-
|
|
18
|
-
function getUint8ArrayMemory0() {
|
|
19
|
-
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
20
|
-
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
21
|
-
}
|
|
22
|
-
return cachedUint8ArrayMemory0;
|
|
23
|
-
}
|
|
24
|
-
|
|
25
|
-
let cachedTextEncoder = new TextEncoder("utf-8");
|
|
26
|
-
|
|
27
|
-
const encodeString =
|
|
28
|
-
typeof cachedTextEncoder.encodeInto === "function"
|
|
29
|
-
? function (arg, view) {
|
|
30
|
-
return cachedTextEncoder.encodeInto(arg, view);
|
|
31
|
-
}
|
|
32
|
-
: function (arg, view) {
|
|
33
|
-
const buf = cachedTextEncoder.encode(arg);
|
|
34
|
-
view.set(buf);
|
|
35
|
-
return {
|
|
36
|
-
read: arg.length,
|
|
37
|
-
written: buf.length,
|
|
38
|
-
};
|
|
39
|
-
};
|
|
40
|
-
|
|
41
|
-
function passStringToWasm0(arg, malloc, realloc) {
|
|
42
|
-
if (realloc === undefined) {
|
|
43
|
-
const buf = cachedTextEncoder.encode(arg);
|
|
44
|
-
const ptr = malloc(buf.length, 1) >>> 0;
|
|
45
|
-
getUint8ArrayMemory0()
|
|
46
|
-
.subarray(ptr, ptr + buf.length)
|
|
47
|
-
.set(buf);
|
|
48
|
-
WASM_VECTOR_LEN = buf.length;
|
|
49
|
-
return ptr;
|
|
50
|
-
}
|
|
51
|
-
|
|
52
|
-
let len = arg.length;
|
|
53
|
-
let ptr = malloc(len, 1) >>> 0;
|
|
54
|
-
|
|
55
|
-
const mem = getUint8ArrayMemory0();
|
|
56
|
-
|
|
57
|
-
let offset = 0;
|
|
58
|
-
|
|
59
|
-
for (; offset < len; offset++) {
|
|
60
|
-
const code = arg.charCodeAt(offset);
|
|
61
|
-
if (code > 0x7f) break;
|
|
62
|
-
mem[ptr + offset] = code;
|
|
63
|
-
}
|
|
64
|
-
|
|
65
|
-
if (offset !== len) {
|
|
66
|
-
if (offset !== 0) {
|
|
67
|
-
arg = arg.slice(offset);
|
|
68
|
-
}
|
|
69
|
-
ptr = realloc(ptr, len, (len = offset + arg.length * 3), 1) >>> 0;
|
|
70
|
-
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
|
|
71
|
-
const ret = encodeString(arg, view);
|
|
72
|
-
|
|
73
|
-
offset += ret.written;
|
|
74
|
-
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
75
|
-
}
|
|
76
|
-
|
|
77
|
-
WASM_VECTOR_LEN = offset;
|
|
78
|
-
return ptr;
|
|
79
|
-
}
|
|
80
|
-
|
|
81
|
-
let cachedDataViewMemory0 = null;
|
|
82
|
-
|
|
83
|
-
function getDataViewMemory0() {
|
|
84
|
-
if (
|
|
85
|
-
cachedDataViewMemory0 === null ||
|
|
86
|
-
cachedDataViewMemory0.buffer.detached === true ||
|
|
87
|
-
(cachedDataViewMemory0.buffer.detached === undefined &&
|
|
88
|
-
cachedDataViewMemory0.buffer !== wasm.memory.buffer)
|
|
89
|
-
) {
|
|
90
|
-
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
91
|
-
}
|
|
92
|
-
return cachedDataViewMemory0;
|
|
93
|
-
}
|
|
94
|
-
|
|
95
|
-
let heap_next = heap.length;
|
|
96
|
-
|
|
97
|
-
function addHeapObject(obj) {
|
|
98
|
-
if (heap_next === heap.length) heap.push(heap.length + 1);
|
|
99
|
-
const idx = heap_next;
|
|
100
|
-
heap_next = heap[idx];
|
|
101
|
-
|
|
102
|
-
heap[idx] = obj;
|
|
103
|
-
return idx;
|
|
104
|
-
}
|
|
105
|
-
|
|
106
|
-
function handleError(f, args) {
|
|
107
|
-
try {
|
|
108
|
-
return f.apply(this, args);
|
|
109
|
-
} catch (e) {
|
|
110
|
-
wasm.__wbindgen_exn_store(addHeapObject(e));
|
|
111
|
-
}
|
|
112
|
-
}
|
|
113
|
-
|
|
114
|
-
let cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
|
|
115
|
-
|
|
116
|
-
cachedTextDecoder.decode();
|
|
117
|
-
|
|
118
|
-
function getStringFromWasm0(ptr, len) {
|
|
119
|
-
ptr = ptr >>> 0;
|
|
120
|
-
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
|
|
121
|
-
}
|
|
122
|
-
|
|
123
|
-
function isLikeNone(x) {
|
|
124
|
-
return x === undefined || x === null;
|
|
125
|
-
}
|
|
126
|
-
|
|
127
|
-
function dropObject(idx) {
|
|
128
|
-
if (idx < 132) return;
|
|
129
|
-
heap[idx] = heap_next;
|
|
130
|
-
heap_next = idx;
|
|
131
|
-
}
|
|
132
|
-
|
|
133
|
-
function takeObject(idx) {
|
|
134
|
-
const ret = getObject(idx);
|
|
135
|
-
dropObject(idx);
|
|
136
|
-
return ret;
|
|
137
|
-
}
|
|
138
|
-
|
|
139
|
-
function getArrayU8FromWasm0(ptr, len) {
|
|
140
|
-
ptr = ptr >>> 0;
|
|
141
|
-
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
142
|
-
}
|
|
143
|
-
|
|
144
|
-
const CLOSURE_DTORS =
|
|
145
|
-
typeof FinalizationRegistry === "undefined"
|
|
146
|
-
? { register: () => {}, unregister: () => {} }
|
|
147
|
-
: new FinalizationRegistry((state) => {
|
|
148
|
-
wasm.__wbindgen_export_4.get(state.dtor)(state.a, state.b);
|
|
149
|
-
});
|
|
150
|
-
|
|
151
|
-
function makeMutClosure(arg0, arg1, dtor, f) {
|
|
152
|
-
const state = { a: arg0, b: arg1, cnt: 1, dtor };
|
|
153
|
-
const real = (...args) => {
|
|
154
|
-
// First up with a closure we increment the internal reference
|
|
155
|
-
// count. This ensures that the Rust closure environment won't
|
|
156
|
-
// be deallocated while we're invoking it.
|
|
157
|
-
state.cnt++;
|
|
158
|
-
const a = state.a;
|
|
159
|
-
state.a = 0;
|
|
160
|
-
try {
|
|
161
|
-
return f(a, state.b, ...args);
|
|
162
|
-
} finally {
|
|
163
|
-
if (--state.cnt === 0) {
|
|
164
|
-
wasm.__wbindgen_export_4.get(state.dtor)(a, state.b);
|
|
165
|
-
CLOSURE_DTORS.unregister(state);
|
|
166
|
-
} else {
|
|
167
|
-
state.a = a;
|
|
168
|
-
}
|
|
169
|
-
}
|
|
170
|
-
};
|
|
171
|
-
real.original = state;
|
|
172
|
-
CLOSURE_DTORS.register(real, state, state);
|
|
173
|
-
return real;
|
|
174
|
-
}
|
|
175
|
-
|
|
176
|
-
function debugString(val) {
|
|
177
|
-
// primitive types
|
|
178
|
-
const type = typeof val;
|
|
179
|
-
if (type == "number" || type == "boolean" || val == null) {
|
|
180
|
-
return `${val}`;
|
|
181
|
-
}
|
|
182
|
-
if (type == "string") {
|
|
183
|
-
return `"${val}"`;
|
|
184
|
-
}
|
|
185
|
-
if (type == "symbol") {
|
|
186
|
-
const description = val.description;
|
|
187
|
-
if (description == null) {
|
|
188
|
-
return "Symbol";
|
|
189
|
-
} else {
|
|
190
|
-
return `Symbol(${description})`;
|
|
191
|
-
}
|
|
192
|
-
}
|
|
193
|
-
if (type == "function") {
|
|
194
|
-
const name = val.name;
|
|
195
|
-
if (typeof name == "string" && name.length > 0) {
|
|
196
|
-
return `Function(${name})`;
|
|
197
|
-
} else {
|
|
198
|
-
return "Function";
|
|
199
|
-
}
|
|
200
|
-
}
|
|
201
|
-
// objects
|
|
202
|
-
if (Array.isArray(val)) {
|
|
203
|
-
const length = val.length;
|
|
204
|
-
let debug = "[";
|
|
205
|
-
if (length > 0) {
|
|
206
|
-
debug += debugString(val[0]);
|
|
207
|
-
}
|
|
208
|
-
for (let i = 1; i < length; i++) {
|
|
209
|
-
debug += ", " + debugString(val[i]);
|
|
210
|
-
}
|
|
211
|
-
debug += "]";
|
|
212
|
-
return debug;
|
|
213
|
-
}
|
|
214
|
-
// Test for built-in
|
|
215
|
-
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
216
|
-
let className;
|
|
217
|
-
if (builtInMatches && builtInMatches.length > 1) {
|
|
218
|
-
className = builtInMatches[1];
|
|
219
|
-
} else {
|
|
220
|
-
// Failed to match the standard '[object ClassName]'
|
|
221
|
-
return toString.call(val);
|
|
222
|
-
}
|
|
223
|
-
if (className == "Object") {
|
|
224
|
-
// we're a user defined class or Object
|
|
225
|
-
// JSON.stringify avoids problems with cycles, and is generally much
|
|
226
|
-
// easier than looping through ownProperties of `val`.
|
|
227
|
-
try {
|
|
228
|
-
return "Object(" + JSON.stringify(val) + ")";
|
|
229
|
-
} catch (_) {
|
|
230
|
-
return "Object";
|
|
231
|
-
}
|
|
232
|
-
}
|
|
233
|
-
// errors
|
|
234
|
-
if (val instanceof Error) {
|
|
235
|
-
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
236
|
-
}
|
|
237
|
-
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
238
|
-
return className;
|
|
239
|
-
}
|
|
240
|
-
/**
|
|
241
|
-
* @param {LogLevel} level
|
|
242
|
-
*/
|
|
243
|
-
module.exports.set_log_level = function (level) {
|
|
244
|
-
wasm.set_log_level(level);
|
|
245
|
-
};
|
|
246
|
-
|
|
247
|
-
/**
|
|
248
|
-
* @param {LogLevel | null} [log_level]
|
|
249
|
-
*/
|
|
250
|
-
module.exports.init_sdk = function (log_level) {
|
|
251
|
-
wasm.init_sdk(isLikeNone(log_level) ? 5 : log_level);
|
|
252
|
-
};
|
|
253
|
-
|
|
254
|
-
function passArray8ToWasm0(arg, malloc) {
|
|
255
|
-
const ptr = malloc(arg.length * 1, 1) >>> 0;
|
|
256
|
-
getUint8ArrayMemory0().set(arg, ptr / 1);
|
|
257
|
-
WASM_VECTOR_LEN = arg.length;
|
|
258
|
-
return ptr;
|
|
259
|
-
}
|
|
260
|
-
/**
|
|
261
|
-
* Generate a new SSH key pair
|
|
262
|
-
*
|
|
263
|
-
* # Arguments
|
|
264
|
-
* - `key_algorithm` - The algorithm to use for the key pair
|
|
265
|
-
*
|
|
266
|
-
* # Returns
|
|
267
|
-
* - `Ok(SshKey)` if the key was successfully generated
|
|
268
|
-
* - `Err(KeyGenerationError)` if the key could not be generated
|
|
269
|
-
* @param {KeyAlgorithm} key_algorithm
|
|
270
|
-
* @returns {SshKeyView}
|
|
271
|
-
*/
|
|
272
|
-
module.exports.generate_ssh_key = function (key_algorithm) {
|
|
273
|
-
try {
|
|
274
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
275
|
-
wasm.generate_ssh_key(retptr, addHeapObject(key_algorithm));
|
|
276
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
277
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
278
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
279
|
-
if (r2) {
|
|
280
|
-
throw takeObject(r1);
|
|
281
|
-
}
|
|
282
|
-
return takeObject(r0);
|
|
283
|
-
} finally {
|
|
284
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
285
|
-
}
|
|
286
|
-
};
|
|
287
|
-
|
|
288
|
-
/**
|
|
289
|
-
* Convert a PCKS8 or OpenSSH encrypted or unencrypted private key
|
|
290
|
-
* to an OpenSSH private key with public key and fingerprint
|
|
291
|
-
*
|
|
292
|
-
* # Arguments
|
|
293
|
-
* - `imported_key` - The private key to convert
|
|
294
|
-
* - `password` - The password to use for decrypting the key
|
|
295
|
-
*
|
|
296
|
-
* # Returns
|
|
297
|
-
* - `Ok(SshKey)` if the key was successfully coneverted
|
|
298
|
-
* - `Err(PasswordRequired)` if the key is encrypted and no password was provided
|
|
299
|
-
* - `Err(WrongPassword)` if the password provided is incorrect
|
|
300
|
-
* - `Err(ParsingError)` if the key could not be parsed
|
|
301
|
-
* - `Err(UnsupportedKeyType)` if the key type is not supported
|
|
302
|
-
* @param {string} imported_key
|
|
303
|
-
* @param {string | null} [password]
|
|
304
|
-
* @returns {SshKeyView}
|
|
305
|
-
*/
|
|
306
|
-
module.exports.import_ssh_key = function (imported_key, password) {
|
|
307
|
-
try {
|
|
308
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
309
|
-
const ptr0 = passStringToWasm0(imported_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
310
|
-
const len0 = WASM_VECTOR_LEN;
|
|
311
|
-
var ptr1 = isLikeNone(password)
|
|
312
|
-
? 0
|
|
313
|
-
: passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
314
|
-
var len1 = WASM_VECTOR_LEN;
|
|
315
|
-
wasm.import_ssh_key(retptr, ptr0, len0, ptr1, len1);
|
|
316
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
317
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
318
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
319
|
-
if (r2) {
|
|
320
|
-
throw takeObject(r1);
|
|
321
|
-
}
|
|
322
|
-
return takeObject(r0);
|
|
323
|
-
} finally {
|
|
324
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
325
|
-
}
|
|
326
|
-
};
|
|
327
|
-
|
|
328
|
-
let stack_pointer = 128;
|
|
329
|
-
|
|
330
|
-
function addBorrowedObject(obj) {
|
|
331
|
-
if (stack_pointer == 1) throw new Error("out of js stack");
|
|
332
|
-
heap[--stack_pointer] = obj;
|
|
333
|
-
return stack_pointer;
|
|
334
|
-
}
|
|
335
|
-
/**
|
|
336
|
-
* @param {any} error
|
|
337
|
-
* @returns {boolean}
|
|
338
|
-
*/
|
|
339
|
-
module.exports.isTestError = function (error) {
|
|
340
|
-
try {
|
|
341
|
-
const ret = wasm.isTestError(addBorrowedObject(error));
|
|
342
|
-
return ret !== 0;
|
|
343
|
-
} finally {
|
|
344
|
-
heap[stack_pointer++] = undefined;
|
|
345
|
-
}
|
|
346
|
-
};
|
|
347
|
-
|
|
348
|
-
/**
|
|
349
|
-
* @param {any} error
|
|
350
|
-
* @returns {boolean}
|
|
351
|
-
*/
|
|
352
|
-
module.exports.isCollectionDecryptError = function (error) {
|
|
353
|
-
try {
|
|
354
|
-
const ret = wasm.isCollectionDecryptError(addBorrowedObject(error));
|
|
355
|
-
return ret !== 0;
|
|
356
|
-
} finally {
|
|
357
|
-
heap[stack_pointer++] = undefined;
|
|
358
|
-
}
|
|
359
|
-
};
|
|
360
|
-
|
|
361
|
-
/**
|
|
362
|
-
* @param {any} error
|
|
363
|
-
* @returns {boolean}
|
|
364
|
-
*/
|
|
365
|
-
module.exports.isMasterPasswordError = function (error) {
|
|
366
|
-
try {
|
|
367
|
-
const ret = wasm.isMasterPasswordError(addBorrowedObject(error));
|
|
368
|
-
return ret !== 0;
|
|
369
|
-
} finally {
|
|
370
|
-
heap[stack_pointer++] = undefined;
|
|
371
|
-
}
|
|
372
|
-
};
|
|
373
|
-
|
|
374
|
-
/**
|
|
375
|
-
* @param {any} error
|
|
376
|
-
* @returns {boolean}
|
|
377
|
-
*/
|
|
378
|
-
module.exports.isDeriveKeyConnectorError = function (error) {
|
|
379
|
-
try {
|
|
380
|
-
const ret = wasm.isDeriveKeyConnectorError(addBorrowedObject(error));
|
|
381
|
-
return ret !== 0;
|
|
382
|
-
} finally {
|
|
383
|
-
heap[stack_pointer++] = undefined;
|
|
384
|
-
}
|
|
385
|
-
};
|
|
386
|
-
|
|
387
|
-
/**
|
|
388
|
-
* @param {any} error
|
|
389
|
-
* @returns {boolean}
|
|
390
|
-
*/
|
|
391
|
-
module.exports.isEnrollAdminPasswordResetError = function (error) {
|
|
392
|
-
try {
|
|
393
|
-
const ret = wasm.isEnrollAdminPasswordResetError(addBorrowedObject(error));
|
|
394
|
-
return ret !== 0;
|
|
395
|
-
} finally {
|
|
396
|
-
heap[stack_pointer++] = undefined;
|
|
397
|
-
}
|
|
398
|
-
};
|
|
399
|
-
|
|
400
|
-
/**
|
|
401
|
-
* @param {any} error
|
|
402
|
-
* @returns {boolean}
|
|
403
|
-
*/
|
|
404
|
-
module.exports.isCryptoClientError = function (error) {
|
|
405
|
-
try {
|
|
406
|
-
const ret = wasm.isCryptoClientError(addBorrowedObject(error));
|
|
407
|
-
return ret !== 0;
|
|
408
|
-
} finally {
|
|
409
|
-
heap[stack_pointer++] = undefined;
|
|
410
|
-
}
|
|
411
|
-
};
|
|
412
|
-
|
|
413
|
-
/**
|
|
414
|
-
* @param {any} error
|
|
415
|
-
* @returns {boolean}
|
|
416
|
-
*/
|
|
417
|
-
module.exports.isStatefulCryptoError = function (error) {
|
|
418
|
-
try {
|
|
419
|
-
const ret = wasm.isStatefulCryptoError(addBorrowedObject(error));
|
|
420
|
-
return ret !== 0;
|
|
421
|
-
} finally {
|
|
422
|
-
heap[stack_pointer++] = undefined;
|
|
423
|
-
}
|
|
424
|
-
};
|
|
425
|
-
|
|
426
|
-
/**
|
|
427
|
-
* @param {any} error
|
|
428
|
-
* @returns {boolean}
|
|
429
|
-
*/
|
|
430
|
-
module.exports.isEncryptionSettingsError = function (error) {
|
|
431
|
-
try {
|
|
432
|
-
const ret = wasm.isEncryptionSettingsError(addBorrowedObject(error));
|
|
433
|
-
return ret !== 0;
|
|
434
|
-
} finally {
|
|
435
|
-
heap[stack_pointer++] = undefined;
|
|
436
|
-
}
|
|
437
|
-
};
|
|
438
|
-
|
|
439
|
-
/**
|
|
440
|
-
* @param {any} error
|
|
441
|
-
* @returns {boolean}
|
|
442
|
-
*/
|
|
443
|
-
module.exports.isCryptoError = function (error) {
|
|
444
|
-
try {
|
|
445
|
-
const ret = wasm.isCryptoError(addBorrowedObject(error));
|
|
446
|
-
return ret !== 0;
|
|
447
|
-
} finally {
|
|
448
|
-
heap[stack_pointer++] = undefined;
|
|
449
|
-
}
|
|
450
|
-
};
|
|
451
|
-
|
|
452
|
-
function passArrayJsValueToWasm0(array, malloc) {
|
|
453
|
-
const ptr = malloc(array.length * 4, 4) >>> 0;
|
|
454
|
-
const mem = getDataViewMemory0();
|
|
455
|
-
for (let i = 0; i < array.length; i++) {
|
|
456
|
-
mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
|
|
457
|
-
}
|
|
458
|
-
WASM_VECTOR_LEN = array.length;
|
|
459
|
-
return ptr;
|
|
460
|
-
}
|
|
461
|
-
|
|
462
|
-
function getArrayJsValueFromWasm0(ptr, len) {
|
|
463
|
-
ptr = ptr >>> 0;
|
|
464
|
-
const mem = getDataViewMemory0();
|
|
465
|
-
const result = [];
|
|
466
|
-
for (let i = ptr; i < ptr + 4 * len; i += 4) {
|
|
467
|
-
result.push(takeObject(mem.getUint32(i, true)));
|
|
468
|
-
}
|
|
469
|
-
return result;
|
|
470
|
-
}
|
|
471
|
-
/**
|
|
472
|
-
* @param {any} error
|
|
473
|
-
* @returns {boolean}
|
|
474
|
-
*/
|
|
475
|
-
module.exports.isExportError = function (error) {
|
|
476
|
-
try {
|
|
477
|
-
const ret = wasm.isExportError(addBorrowedObject(error));
|
|
478
|
-
return ret !== 0;
|
|
479
|
-
} finally {
|
|
480
|
-
heap[stack_pointer++] = undefined;
|
|
481
|
-
}
|
|
482
|
-
};
|
|
483
|
-
|
|
484
|
-
/**
|
|
485
|
-
* @param {any} error
|
|
486
|
-
* @returns {boolean}
|
|
487
|
-
*/
|
|
488
|
-
module.exports.isUsernameError = function (error) {
|
|
489
|
-
try {
|
|
490
|
-
const ret = wasm.isUsernameError(addBorrowedObject(error));
|
|
491
|
-
return ret !== 0;
|
|
492
|
-
} finally {
|
|
493
|
-
heap[stack_pointer++] = undefined;
|
|
494
|
-
}
|
|
495
|
-
};
|
|
496
|
-
|
|
497
|
-
/**
|
|
498
|
-
* @param {any} error
|
|
499
|
-
* @returns {boolean}
|
|
500
|
-
*/
|
|
501
|
-
module.exports.isPasswordError = function (error) {
|
|
502
|
-
try {
|
|
503
|
-
const ret = wasm.isPasswordError(addBorrowedObject(error));
|
|
504
|
-
return ret !== 0;
|
|
505
|
-
} finally {
|
|
506
|
-
heap[stack_pointer++] = undefined;
|
|
507
|
-
}
|
|
508
|
-
};
|
|
509
|
-
|
|
510
|
-
function _assertClass(instance, klass) {
|
|
511
|
-
if (!(instance instanceof klass)) {
|
|
512
|
-
throw new Error(`expected instance of ${klass.name}`);
|
|
513
|
-
}
|
|
514
|
-
}
|
|
515
|
-
/**
|
|
516
|
-
* Registers a DiscoverHandler so that the client can respond to DiscoverRequests.
|
|
517
|
-
* @param {IpcClient} ipc_client
|
|
518
|
-
* @param {DiscoverResponse} response
|
|
519
|
-
* @returns {Promise<void>}
|
|
520
|
-
*/
|
|
521
|
-
module.exports.ipcRegisterDiscoverHandler = function (ipc_client, response) {
|
|
522
|
-
_assertClass(ipc_client, IpcClient);
|
|
523
|
-
const ret = wasm.ipcRegisterDiscoverHandler(ipc_client.__wbg_ptr, addHeapObject(response));
|
|
524
|
-
return takeObject(ret);
|
|
525
|
-
};
|
|
526
|
-
|
|
527
|
-
/**
|
|
528
|
-
* Sends a DiscoverRequest to the specified destination and returns the response.
|
|
529
|
-
* @param {IpcClient} ipc_client
|
|
530
|
-
* @param {Endpoint} destination
|
|
531
|
-
* @param {AbortSignal | null} [abort_signal]
|
|
532
|
-
* @returns {Promise<DiscoverResponse>}
|
|
533
|
-
*/
|
|
534
|
-
module.exports.ipcRequestDiscover = function (ipc_client, destination, abort_signal) {
|
|
535
|
-
_assertClass(ipc_client, IpcClient);
|
|
536
|
-
const ret = wasm.ipcRequestDiscover(
|
|
537
|
-
ipc_client.__wbg_ptr,
|
|
538
|
-
addHeapObject(destination),
|
|
539
|
-
isLikeNone(abort_signal) ? 0 : addHeapObject(abort_signal),
|
|
540
|
-
);
|
|
541
|
-
return takeObject(ret);
|
|
542
|
-
};
|
|
543
|
-
|
|
544
|
-
/**
|
|
545
|
-
* @param {any} error
|
|
546
|
-
* @returns {boolean}
|
|
547
|
-
*/
|
|
548
|
-
module.exports.isChannelError = function (error) {
|
|
549
|
-
try {
|
|
550
|
-
const ret = wasm.isChannelError(addBorrowedObject(error));
|
|
551
|
-
return ret !== 0;
|
|
552
|
-
} finally {
|
|
553
|
-
heap[stack_pointer++] = undefined;
|
|
554
|
-
}
|
|
555
|
-
};
|
|
556
|
-
|
|
557
|
-
/**
|
|
558
|
-
* @param {any} error
|
|
559
|
-
* @returns {boolean}
|
|
560
|
-
*/
|
|
561
|
-
module.exports.isDeserializeError = function (error) {
|
|
562
|
-
try {
|
|
563
|
-
const ret = wasm.isDeserializeError(addBorrowedObject(error));
|
|
564
|
-
return ret !== 0;
|
|
565
|
-
} finally {
|
|
566
|
-
heap[stack_pointer++] = undefined;
|
|
567
|
-
}
|
|
568
|
-
};
|
|
569
|
-
|
|
570
|
-
/**
|
|
571
|
-
* @param {any} error
|
|
572
|
-
* @returns {boolean}
|
|
573
|
-
*/
|
|
574
|
-
module.exports.isRequestError = function (error) {
|
|
575
|
-
try {
|
|
576
|
-
const ret = wasm.isRequestError(addBorrowedObject(error));
|
|
577
|
-
return ret !== 0;
|
|
578
|
-
} finally {
|
|
579
|
-
heap[stack_pointer++] = undefined;
|
|
580
|
-
}
|
|
581
|
-
};
|
|
582
|
-
|
|
583
|
-
/**
|
|
584
|
-
* @param {any} error
|
|
585
|
-
* @returns {boolean}
|
|
586
|
-
*/
|
|
587
|
-
module.exports.isTypedReceiveError = function (error) {
|
|
588
|
-
try {
|
|
589
|
-
const ret = wasm.isTypedReceiveError(addBorrowedObject(error));
|
|
590
|
-
return ret !== 0;
|
|
591
|
-
} finally {
|
|
592
|
-
heap[stack_pointer++] = undefined;
|
|
593
|
-
}
|
|
594
|
-
};
|
|
595
|
-
|
|
596
|
-
/**
|
|
597
|
-
* @param {any} error
|
|
598
|
-
* @returns {boolean}
|
|
599
|
-
*/
|
|
600
|
-
module.exports.isReceiveError = function (error) {
|
|
601
|
-
try {
|
|
602
|
-
const ret = wasm.isReceiveError(addBorrowedObject(error));
|
|
603
|
-
return ret !== 0;
|
|
604
|
-
} finally {
|
|
605
|
-
heap[stack_pointer++] = undefined;
|
|
606
|
-
}
|
|
607
|
-
};
|
|
608
|
-
|
|
609
|
-
/**
|
|
610
|
-
* @param {any} error
|
|
611
|
-
* @returns {boolean}
|
|
612
|
-
*/
|
|
613
|
-
module.exports.isSubscribeError = function (error) {
|
|
614
|
-
try {
|
|
615
|
-
const ret = wasm.isSubscribeError(addBorrowedObject(error));
|
|
616
|
-
return ret !== 0;
|
|
617
|
-
} finally {
|
|
618
|
-
heap[stack_pointer++] = undefined;
|
|
619
|
-
}
|
|
620
|
-
};
|
|
621
|
-
|
|
622
|
-
/**
|
|
623
|
-
* @param {any} error
|
|
624
|
-
* @returns {boolean}
|
|
625
|
-
*/
|
|
626
|
-
module.exports.isSshKeyExportError = function (error) {
|
|
627
|
-
try {
|
|
628
|
-
const ret = wasm.isSshKeyExportError(addBorrowedObject(error));
|
|
629
|
-
return ret !== 0;
|
|
630
|
-
} finally {
|
|
631
|
-
heap[stack_pointer++] = undefined;
|
|
632
|
-
}
|
|
633
|
-
};
|
|
634
|
-
|
|
635
|
-
/**
|
|
636
|
-
* @param {any} error
|
|
637
|
-
* @returns {boolean}
|
|
638
|
-
*/
|
|
639
|
-
module.exports.isSshKeyImportError = function (error) {
|
|
640
|
-
try {
|
|
641
|
-
const ret = wasm.isSshKeyImportError(addBorrowedObject(error));
|
|
642
|
-
return ret !== 0;
|
|
643
|
-
} finally {
|
|
644
|
-
heap[stack_pointer++] = undefined;
|
|
645
|
-
}
|
|
646
|
-
};
|
|
647
|
-
|
|
648
|
-
/**
|
|
649
|
-
* @param {any} error
|
|
650
|
-
* @returns {boolean}
|
|
651
|
-
*/
|
|
652
|
-
module.exports.isKeyGenerationError = function (error) {
|
|
653
|
-
try {
|
|
654
|
-
const ret = wasm.isKeyGenerationError(addBorrowedObject(error));
|
|
655
|
-
return ret !== 0;
|
|
656
|
-
} finally {
|
|
657
|
-
heap[stack_pointer++] = undefined;
|
|
658
|
-
}
|
|
659
|
-
};
|
|
660
|
-
|
|
661
|
-
/**
|
|
662
|
-
* @param {any} error
|
|
663
|
-
* @returns {boolean}
|
|
664
|
-
*/
|
|
665
|
-
module.exports.isDatabaseError = function (error) {
|
|
666
|
-
try {
|
|
667
|
-
const ret = wasm.isDatabaseError(addBorrowedObject(error));
|
|
668
|
-
return ret !== 0;
|
|
669
|
-
} finally {
|
|
670
|
-
heap[stack_pointer++] = undefined;
|
|
671
|
-
}
|
|
672
|
-
};
|
|
673
|
-
|
|
674
|
-
/**
|
|
675
|
-
* @param {any} error
|
|
676
|
-
* @returns {boolean}
|
|
677
|
-
*/
|
|
678
|
-
module.exports.isStateRegistryError = function (error) {
|
|
679
|
-
try {
|
|
680
|
-
const ret = wasm.isStateRegistryError(addBorrowedObject(error));
|
|
681
|
-
return ret !== 0;
|
|
682
|
-
} finally {
|
|
683
|
-
heap[stack_pointer++] = undefined;
|
|
684
|
-
}
|
|
685
|
-
};
|
|
686
|
-
|
|
687
|
-
/**
|
|
688
|
-
* @param {any} error
|
|
689
|
-
* @returns {boolean}
|
|
690
|
-
*/
|
|
691
|
-
module.exports.isCallError = function (error) {
|
|
692
|
-
try {
|
|
693
|
-
const ret = wasm.isCallError(addBorrowedObject(error));
|
|
694
|
-
return ret !== 0;
|
|
695
|
-
} finally {
|
|
696
|
-
heap[stack_pointer++] = undefined;
|
|
697
|
-
}
|
|
698
|
-
};
|
|
699
|
-
|
|
700
|
-
/**
|
|
701
|
-
* @param {any} error
|
|
702
|
-
* @returns {boolean}
|
|
703
|
-
*/
|
|
704
|
-
module.exports.isDecryptError = function (error) {
|
|
705
|
-
try {
|
|
706
|
-
const ret = wasm.isDecryptError(addBorrowedObject(error));
|
|
707
|
-
return ret !== 0;
|
|
708
|
-
} finally {
|
|
709
|
-
heap[stack_pointer++] = undefined;
|
|
710
|
-
}
|
|
711
|
-
};
|
|
712
|
-
|
|
713
|
-
/**
|
|
714
|
-
* @param {any} error
|
|
715
|
-
* @returns {boolean}
|
|
716
|
-
*/
|
|
717
|
-
module.exports.isEncryptError = function (error) {
|
|
718
|
-
try {
|
|
719
|
-
const ret = wasm.isEncryptError(addBorrowedObject(error));
|
|
720
|
-
return ret !== 0;
|
|
721
|
-
} finally {
|
|
722
|
-
heap[stack_pointer++] = undefined;
|
|
723
|
-
}
|
|
724
|
-
};
|
|
725
|
-
|
|
726
|
-
/**
|
|
727
|
-
* @param {any} error
|
|
728
|
-
* @returns {boolean}
|
|
729
|
-
*/
|
|
730
|
-
module.exports.isTotpError = function (error) {
|
|
731
|
-
try {
|
|
732
|
-
const ret = wasm.isTotpError(addBorrowedObject(error));
|
|
733
|
-
return ret !== 0;
|
|
734
|
-
} finally {
|
|
735
|
-
heap[stack_pointer++] = undefined;
|
|
736
|
-
}
|
|
737
|
-
};
|
|
738
|
-
|
|
739
|
-
/**
|
|
740
|
-
* @param {any} error
|
|
741
|
-
* @returns {boolean}
|
|
742
|
-
*/
|
|
743
|
-
module.exports.isGetFolderError = function (error) {
|
|
744
|
-
try {
|
|
745
|
-
const ret = wasm.isGetFolderError(addBorrowedObject(error));
|
|
746
|
-
return ret !== 0;
|
|
747
|
-
} finally {
|
|
748
|
-
heap[stack_pointer++] = undefined;
|
|
749
|
-
}
|
|
750
|
-
};
|
|
751
|
-
|
|
752
|
-
/**
|
|
753
|
-
* @param {any} error
|
|
754
|
-
* @returns {boolean}
|
|
755
|
-
*/
|
|
756
|
-
module.exports.isEditFolderError = function (error) {
|
|
757
|
-
try {
|
|
758
|
-
const ret = wasm.isEditFolderError(addBorrowedObject(error));
|
|
759
|
-
return ret !== 0;
|
|
760
|
-
} finally {
|
|
761
|
-
heap[stack_pointer++] = undefined;
|
|
762
|
-
}
|
|
763
|
-
};
|
|
764
|
-
|
|
765
|
-
/**
|
|
766
|
-
* @param {any} error
|
|
767
|
-
* @returns {boolean}
|
|
768
|
-
*/
|
|
769
|
-
module.exports.isCreateFolderError = function (error) {
|
|
770
|
-
try {
|
|
771
|
-
const ret = wasm.isCreateFolderError(addBorrowedObject(error));
|
|
772
|
-
return ret !== 0;
|
|
773
|
-
} finally {
|
|
774
|
-
heap[stack_pointer++] = undefined;
|
|
775
|
-
}
|
|
776
|
-
};
|
|
777
|
-
|
|
778
|
-
/**
|
|
779
|
-
* @param {any} error
|
|
780
|
-
* @returns {boolean}
|
|
781
|
-
*/
|
|
782
|
-
module.exports.isCipherError = function (error) {
|
|
783
|
-
try {
|
|
784
|
-
const ret = wasm.isCipherError(addBorrowedObject(error));
|
|
785
|
-
return ret !== 0;
|
|
786
|
-
} finally {
|
|
787
|
-
heap[stack_pointer++] = undefined;
|
|
788
|
-
}
|
|
789
|
-
};
|
|
790
|
-
|
|
791
|
-
/**
|
|
792
|
-
* @param {any} error
|
|
793
|
-
* @returns {boolean}
|
|
794
|
-
*/
|
|
795
|
-
module.exports.isDecryptFileError = function (error) {
|
|
796
|
-
try {
|
|
797
|
-
const ret = wasm.isDecryptFileError(addBorrowedObject(error));
|
|
798
|
-
return ret !== 0;
|
|
799
|
-
} finally {
|
|
800
|
-
heap[stack_pointer++] = undefined;
|
|
801
|
-
}
|
|
802
|
-
};
|
|
803
|
-
|
|
804
|
-
/**
|
|
805
|
-
* @param {any} error
|
|
806
|
-
* @returns {boolean}
|
|
807
|
-
*/
|
|
808
|
-
module.exports.isEncryptFileError = function (error) {
|
|
809
|
-
try {
|
|
810
|
-
const ret = wasm.isEncryptFileError(addBorrowedObject(error));
|
|
811
|
-
return ret !== 0;
|
|
812
|
-
} finally {
|
|
813
|
-
heap[stack_pointer++] = undefined;
|
|
814
|
-
}
|
|
815
|
-
};
|
|
816
|
-
|
|
817
|
-
function __wbg_adapter_54(arg0, arg1, arg2) {
|
|
818
|
-
wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb3d7232059e1cc02(
|
|
819
|
-
arg0,
|
|
820
|
-
arg1,
|
|
821
|
-
addHeapObject(arg2),
|
|
822
|
-
);
|
|
823
|
-
}
|
|
824
|
-
|
|
825
|
-
function __wbg_adapter_57(arg0, arg1, arg2) {
|
|
826
|
-
try {
|
|
827
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
828
|
-
wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hbddb05d650eb93e1(
|
|
829
|
-
retptr,
|
|
830
|
-
arg0,
|
|
831
|
-
arg1,
|
|
832
|
-
addHeapObject(arg2),
|
|
833
|
-
);
|
|
834
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
835
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
836
|
-
if (r1) {
|
|
837
|
-
throw takeObject(r0);
|
|
838
|
-
}
|
|
839
|
-
} finally {
|
|
840
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
841
|
-
}
|
|
842
|
-
}
|
|
843
|
-
|
|
844
|
-
function __wbg_adapter_60(arg0, arg1) {
|
|
845
|
-
wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h091423ccfc08366e(
|
|
846
|
-
arg0,
|
|
847
|
-
arg1,
|
|
848
|
-
);
|
|
849
|
-
}
|
|
850
|
-
|
|
851
|
-
function __wbg_adapter_341(arg0, arg1, arg2, arg3) {
|
|
852
|
-
wasm.wasm_bindgen__convert__closures__invoke2_mut__h54a8613170fef18e(
|
|
853
|
-
arg0,
|
|
854
|
-
arg1,
|
|
855
|
-
addHeapObject(arg2),
|
|
856
|
-
addHeapObject(arg3),
|
|
857
|
-
);
|
|
858
|
-
}
|
|
859
|
-
|
|
860
|
-
/**
|
|
861
|
-
* @enum {300 | 301 | 302 | 303 | 304 | 305}
|
|
862
|
-
*/
|
|
863
|
-
module.exports.CardLinkedIdType = Object.freeze({
|
|
864
|
-
CardholderName: 300,
|
|
865
|
-
300: "CardholderName",
|
|
866
|
-
ExpMonth: 301,
|
|
867
|
-
301: "ExpMonth",
|
|
868
|
-
ExpYear: 302,
|
|
869
|
-
302: "ExpYear",
|
|
870
|
-
Code: 303,
|
|
871
|
-
303: "Code",
|
|
872
|
-
Brand: 304,
|
|
873
|
-
304: "Brand",
|
|
874
|
-
Number: 305,
|
|
875
|
-
305: "Number",
|
|
876
|
-
});
|
|
877
|
-
/**
|
|
878
|
-
* @enum {0 | 1}
|
|
879
|
-
*/
|
|
880
|
-
module.exports.CipherRepromptType = Object.freeze({
|
|
881
|
-
None: 0,
|
|
882
|
-
0: "None",
|
|
883
|
-
Password: 1,
|
|
884
|
-
1: "Password",
|
|
885
|
-
});
|
|
886
|
-
/**
|
|
887
|
-
* @enum {1 | 2 | 3 | 4 | 5}
|
|
888
|
-
*/
|
|
889
|
-
module.exports.CipherType = Object.freeze({
|
|
890
|
-
Login: 1,
|
|
891
|
-
1: "Login",
|
|
892
|
-
SecureNote: 2,
|
|
893
|
-
2: "SecureNote",
|
|
894
|
-
Card: 3,
|
|
895
|
-
3: "Card",
|
|
896
|
-
Identity: 4,
|
|
897
|
-
4: "Identity",
|
|
898
|
-
SshKey: 5,
|
|
899
|
-
5: "SshKey",
|
|
900
|
-
});
|
|
901
|
-
/**
|
|
902
|
-
* Represents the type of a [FieldView].
|
|
903
|
-
* @enum {0 | 1 | 2 | 3}
|
|
904
|
-
*/
|
|
905
|
-
module.exports.FieldType = Object.freeze({
|
|
906
|
-
/**
|
|
907
|
-
* Text field
|
|
908
|
-
*/
|
|
909
|
-
Text: 0,
|
|
910
|
-
0: "Text",
|
|
911
|
-
/**
|
|
912
|
-
* Hidden text field
|
|
913
|
-
*/
|
|
914
|
-
Hidden: 1,
|
|
915
|
-
1: "Hidden",
|
|
916
|
-
/**
|
|
917
|
-
* Boolean field
|
|
918
|
-
*/
|
|
919
|
-
Boolean: 2,
|
|
920
|
-
2: "Boolean",
|
|
921
|
-
/**
|
|
922
|
-
* Linked field
|
|
923
|
-
*/
|
|
924
|
-
Linked: 3,
|
|
925
|
-
3: "Linked",
|
|
926
|
-
});
|
|
927
|
-
/**
|
|
928
|
-
* @enum {400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418}
|
|
929
|
-
*/
|
|
930
|
-
module.exports.IdentityLinkedIdType = Object.freeze({
|
|
931
|
-
Title: 400,
|
|
932
|
-
400: "Title",
|
|
933
|
-
MiddleName: 401,
|
|
934
|
-
401: "MiddleName",
|
|
935
|
-
Address1: 402,
|
|
936
|
-
402: "Address1",
|
|
937
|
-
Address2: 403,
|
|
938
|
-
403: "Address2",
|
|
939
|
-
Address3: 404,
|
|
940
|
-
404: "Address3",
|
|
941
|
-
City: 405,
|
|
942
|
-
405: "City",
|
|
943
|
-
State: 406,
|
|
944
|
-
406: "State",
|
|
945
|
-
PostalCode: 407,
|
|
946
|
-
407: "PostalCode",
|
|
947
|
-
Country: 408,
|
|
948
|
-
408: "Country",
|
|
949
|
-
Company: 409,
|
|
950
|
-
409: "Company",
|
|
951
|
-
Email: 410,
|
|
952
|
-
410: "Email",
|
|
953
|
-
Phone: 411,
|
|
954
|
-
411: "Phone",
|
|
955
|
-
Ssn: 412,
|
|
956
|
-
412: "Ssn",
|
|
957
|
-
Username: 413,
|
|
958
|
-
413: "Username",
|
|
959
|
-
PassportNumber: 414,
|
|
960
|
-
414: "PassportNumber",
|
|
961
|
-
LicenseNumber: 415,
|
|
962
|
-
415: "LicenseNumber",
|
|
963
|
-
FirstName: 416,
|
|
964
|
-
416: "FirstName",
|
|
965
|
-
LastName: 417,
|
|
966
|
-
417: "LastName",
|
|
967
|
-
FullName: 418,
|
|
968
|
-
418: "FullName",
|
|
969
|
-
});
|
|
970
|
-
/**
|
|
971
|
-
* @enum {0 | 1 | 2 | 3 | 4}
|
|
972
|
-
*/
|
|
973
|
-
module.exports.LogLevel = Object.freeze({
|
|
974
|
-
Trace: 0,
|
|
975
|
-
0: "Trace",
|
|
976
|
-
Debug: 1,
|
|
977
|
-
1: "Debug",
|
|
978
|
-
Info: 2,
|
|
979
|
-
2: "Info",
|
|
980
|
-
Warn: 3,
|
|
981
|
-
3: "Warn",
|
|
982
|
-
Error: 4,
|
|
983
|
-
4: "Error",
|
|
984
|
-
});
|
|
985
|
-
/**
|
|
986
|
-
* @enum {100 | 101}
|
|
987
|
-
*/
|
|
988
|
-
module.exports.LoginLinkedIdType = Object.freeze({
|
|
989
|
-
Username: 100,
|
|
990
|
-
100: "Username",
|
|
991
|
-
Password: 101,
|
|
992
|
-
101: "Password",
|
|
993
|
-
});
|
|
994
|
-
/**
|
|
995
|
-
* @enum {0}
|
|
996
|
-
*/
|
|
997
|
-
module.exports.SecureNoteType = Object.freeze({
|
|
998
|
-
Generic: 0,
|
|
999
|
-
0: "Generic",
|
|
1000
|
-
});
|
|
1001
|
-
/**
|
|
1002
|
-
* @enum {0 | 1 | 2 | 3 | 4 | 5}
|
|
1003
|
-
*/
|
|
1004
|
-
module.exports.UriMatchType = Object.freeze({
|
|
1005
|
-
Domain: 0,
|
|
1006
|
-
0: "Domain",
|
|
1007
|
-
Host: 1,
|
|
1008
|
-
1: "Host",
|
|
1009
|
-
StartsWith: 2,
|
|
1010
|
-
2: "StartsWith",
|
|
1011
|
-
Exact: 3,
|
|
1012
|
-
3: "Exact",
|
|
1013
|
-
RegularExpression: 4,
|
|
1014
|
-
4: "RegularExpression",
|
|
1015
|
-
Never: 5,
|
|
1016
|
-
5: "Never",
|
|
1017
|
-
});
|
|
1018
|
-
|
|
1019
|
-
const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
|
|
1020
|
-
|
|
1021
|
-
const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
|
|
1022
|
-
|
|
1023
|
-
const AttachmentsClientFinalization =
|
|
1024
|
-
typeof FinalizationRegistry === "undefined"
|
|
1025
|
-
? { register: () => {}, unregister: () => {} }
|
|
1026
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_attachmentsclient_free(ptr >>> 0, 1));
|
|
1027
|
-
|
|
1028
|
-
class AttachmentsClient {
|
|
1029
|
-
static __wrap(ptr) {
|
|
1030
|
-
ptr = ptr >>> 0;
|
|
1031
|
-
const obj = Object.create(AttachmentsClient.prototype);
|
|
1032
|
-
obj.__wbg_ptr = ptr;
|
|
1033
|
-
AttachmentsClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1034
|
-
return obj;
|
|
1035
|
-
}
|
|
1036
|
-
|
|
1037
|
-
__destroy_into_raw() {
|
|
1038
|
-
const ptr = this.__wbg_ptr;
|
|
1039
|
-
this.__wbg_ptr = 0;
|
|
1040
|
-
AttachmentsClientFinalization.unregister(this);
|
|
1041
|
-
return ptr;
|
|
1042
|
-
}
|
|
1043
|
-
|
|
1044
|
-
free() {
|
|
1045
|
-
const ptr = this.__destroy_into_raw();
|
|
1046
|
-
wasm.__wbg_attachmentsclient_free(ptr, 0);
|
|
1047
|
-
}
|
|
1048
|
-
/**
|
|
1049
|
-
* @param {Cipher} cipher
|
|
1050
|
-
* @param {AttachmentView} attachment
|
|
1051
|
-
* @param {Uint8Array} encrypted_buffer
|
|
1052
|
-
* @returns {Uint8Array}
|
|
1053
|
-
*/
|
|
1054
|
-
decrypt_buffer(cipher, attachment, encrypted_buffer) {
|
|
1055
|
-
try {
|
|
1056
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1057
|
-
const ptr0 = passArray8ToWasm0(encrypted_buffer, wasm.__wbindgen_malloc);
|
|
1058
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1059
|
-
wasm.attachmentsclient_decrypt_buffer(
|
|
1060
|
-
retptr,
|
|
1061
|
-
this.__wbg_ptr,
|
|
1062
|
-
addHeapObject(cipher),
|
|
1063
|
-
addHeapObject(attachment),
|
|
1064
|
-
ptr0,
|
|
1065
|
-
len0,
|
|
1066
|
-
);
|
|
1067
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1068
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1069
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1070
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1071
|
-
if (r3) {
|
|
1072
|
-
throw takeObject(r2);
|
|
1073
|
-
}
|
|
1074
|
-
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
1075
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
1076
|
-
return v2;
|
|
1077
|
-
} finally {
|
|
1078
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1079
|
-
}
|
|
1080
|
-
}
|
|
1081
|
-
}
|
|
1082
|
-
module.exports.AttachmentsClient = AttachmentsClient;
|
|
1083
|
-
|
|
1084
|
-
const AuthClientFinalization =
|
|
1085
|
-
typeof FinalizationRegistry === "undefined"
|
|
1086
|
-
? { register: () => {}, unregister: () => {} }
|
|
1087
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_authclient_free(ptr >>> 0, 1));
|
|
1088
|
-
/**
|
|
1089
|
-
* Subclient containing auth functionality.
|
|
1090
|
-
*/
|
|
1091
|
-
class AuthClient {
|
|
1092
|
-
static __wrap(ptr) {
|
|
1093
|
-
ptr = ptr >>> 0;
|
|
1094
|
-
const obj = Object.create(AuthClient.prototype);
|
|
1095
|
-
obj.__wbg_ptr = ptr;
|
|
1096
|
-
AuthClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1097
|
-
return obj;
|
|
1098
|
-
}
|
|
1099
|
-
|
|
1100
|
-
__destroy_into_raw() {
|
|
1101
|
-
const ptr = this.__wbg_ptr;
|
|
1102
|
-
this.__wbg_ptr = 0;
|
|
1103
|
-
AuthClientFinalization.unregister(this);
|
|
1104
|
-
return ptr;
|
|
1105
|
-
}
|
|
1106
|
-
|
|
1107
|
-
free() {
|
|
1108
|
-
const ptr = this.__destroy_into_raw();
|
|
1109
|
-
wasm.__wbg_authclient_free(ptr, 0);
|
|
1110
|
-
}
|
|
1111
|
-
/**
|
|
1112
|
-
* Client for send access functionality
|
|
1113
|
-
* @returns {SendAccessClient}
|
|
1114
|
-
*/
|
|
1115
|
-
send_access() {
|
|
1116
|
-
const ret = wasm.authclient_send_access(this.__wbg_ptr);
|
|
1117
|
-
return SendAccessClient.__wrap(ret);
|
|
1118
|
-
}
|
|
1119
|
-
}
|
|
1120
|
-
module.exports.AuthClient = AuthClient;
|
|
1121
|
-
|
|
1122
|
-
const BitwardenClientFinalization =
|
|
1123
|
-
typeof FinalizationRegistry === "undefined"
|
|
1124
|
-
? { register: () => {}, unregister: () => {} }
|
|
1125
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_bitwardenclient_free(ptr >>> 0, 1));
|
|
1126
|
-
/**
|
|
1127
|
-
* The main entry point for the Bitwarden SDK in WebAssembly environments
|
|
1128
|
-
*/
|
|
1129
|
-
class BitwardenClient {
|
|
1130
|
-
__destroy_into_raw() {
|
|
1131
|
-
const ptr = this.__wbg_ptr;
|
|
1132
|
-
this.__wbg_ptr = 0;
|
|
1133
|
-
BitwardenClientFinalization.unregister(this);
|
|
1134
|
-
return ptr;
|
|
1135
|
-
}
|
|
1136
|
-
|
|
1137
|
-
free() {
|
|
1138
|
-
const ptr = this.__destroy_into_raw();
|
|
1139
|
-
wasm.__wbg_bitwardenclient_free(ptr, 0);
|
|
1140
|
-
}
|
|
1141
|
-
/**
|
|
1142
|
-
* Initialize a new instance of the SDK client
|
|
1143
|
-
* @param {any} token_provider
|
|
1144
|
-
* @param {ClientSettings | null} [settings]
|
|
1145
|
-
*/
|
|
1146
|
-
constructor(token_provider, settings) {
|
|
1147
|
-
const ret = wasm.bitwardenclient_new(
|
|
1148
|
-
addHeapObject(token_provider),
|
|
1149
|
-
isLikeNone(settings) ? 0 : addHeapObject(settings),
|
|
1150
|
-
);
|
|
1151
|
-
this.__wbg_ptr = ret >>> 0;
|
|
1152
|
-
BitwardenClientFinalization.register(this, this.__wbg_ptr, this);
|
|
1153
|
-
return this;
|
|
1154
|
-
}
|
|
1155
|
-
/**
|
|
1156
|
-
* Test method, echoes back the input
|
|
1157
|
-
* @param {string} msg
|
|
1158
|
-
* @returns {string}
|
|
1159
|
-
*/
|
|
1160
|
-
echo(msg) {
|
|
1161
|
-
let deferred2_0;
|
|
1162
|
-
let deferred2_1;
|
|
1163
|
-
try {
|
|
1164
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1165
|
-
const ptr0 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1166
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1167
|
-
wasm.bitwardenclient_echo(retptr, this.__wbg_ptr, ptr0, len0);
|
|
1168
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1169
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1170
|
-
deferred2_0 = r0;
|
|
1171
|
-
deferred2_1 = r1;
|
|
1172
|
-
return getStringFromWasm0(r0, r1);
|
|
1173
|
-
} finally {
|
|
1174
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1175
|
-
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1176
|
-
}
|
|
1177
|
-
}
|
|
1178
|
-
/**
|
|
1179
|
-
* Returns the current SDK version
|
|
1180
|
-
* @returns {string}
|
|
1181
|
-
*/
|
|
1182
|
-
version() {
|
|
1183
|
-
let deferred1_0;
|
|
1184
|
-
let deferred1_1;
|
|
1185
|
-
try {
|
|
1186
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1187
|
-
wasm.bitwardenclient_version(retptr, this.__wbg_ptr);
|
|
1188
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1189
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1190
|
-
deferred1_0 = r0;
|
|
1191
|
-
deferred1_1 = r1;
|
|
1192
|
-
return getStringFromWasm0(r0, r1);
|
|
1193
|
-
} finally {
|
|
1194
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1195
|
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1196
|
-
}
|
|
1197
|
-
}
|
|
1198
|
-
/**
|
|
1199
|
-
* Test method, always throws an error
|
|
1200
|
-
* @param {string} msg
|
|
1201
|
-
*/
|
|
1202
|
-
throw(msg) {
|
|
1203
|
-
try {
|
|
1204
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1205
|
-
const ptr0 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1206
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1207
|
-
wasm.bitwardenclient_throw(retptr, this.__wbg_ptr, ptr0, len0);
|
|
1208
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1209
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1210
|
-
if (r1) {
|
|
1211
|
-
throw takeObject(r0);
|
|
1212
|
-
}
|
|
1213
|
-
} finally {
|
|
1214
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1215
|
-
}
|
|
1216
|
-
}
|
|
1217
|
-
/**
|
|
1218
|
-
* Test method, calls http endpoint
|
|
1219
|
-
* @param {string} url
|
|
1220
|
-
* @returns {Promise<string>}
|
|
1221
|
-
*/
|
|
1222
|
-
http_get(url) {
|
|
1223
|
-
const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1224
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1225
|
-
const ret = wasm.bitwardenclient_http_get(this.__wbg_ptr, ptr0, len0);
|
|
1226
|
-
return takeObject(ret);
|
|
1227
|
-
}
|
|
1228
|
-
/**
|
|
1229
|
-
* Auth related operations.
|
|
1230
|
-
* @returns {AuthClient}
|
|
1231
|
-
*/
|
|
1232
|
-
auth() {
|
|
1233
|
-
const ret = wasm.bitwardenclient_auth(this.__wbg_ptr);
|
|
1234
|
-
return AuthClient.__wrap(ret);
|
|
1235
|
-
}
|
|
1236
|
-
/**
|
|
1237
|
-
* Crypto related operations.
|
|
1238
|
-
* @returns {CryptoClient}
|
|
1239
|
-
*/
|
|
1240
|
-
crypto() {
|
|
1241
|
-
const ret = wasm.bitwardenclient_crypto(this.__wbg_ptr);
|
|
1242
|
-
return CryptoClient.__wrap(ret);
|
|
1243
|
-
}
|
|
1244
|
-
/**
|
|
1245
|
-
* Vault item related operations.
|
|
1246
|
-
* @returns {VaultClient}
|
|
1247
|
-
*/
|
|
1248
|
-
vault() {
|
|
1249
|
-
const ret = wasm.bitwardenclient_vault(this.__wbg_ptr);
|
|
1250
|
-
return VaultClient.__wrap(ret);
|
|
1251
|
-
}
|
|
1252
|
-
/**
|
|
1253
|
-
* Constructs a specific client for platform-specific functionality
|
|
1254
|
-
* @returns {PlatformClient}
|
|
1255
|
-
*/
|
|
1256
|
-
platform() {
|
|
1257
|
-
const ret = wasm.bitwardenclient_platform(this.__wbg_ptr);
|
|
1258
|
-
return PlatformClient.__wrap(ret);
|
|
1259
|
-
}
|
|
1260
|
-
/**
|
|
1261
|
-
* Constructs a specific client for generating passwords and passphrases
|
|
1262
|
-
* @returns {GeneratorClient}
|
|
1263
|
-
*/
|
|
1264
|
-
generator() {
|
|
1265
|
-
const ret = wasm.bitwardenclient_generator(this.__wbg_ptr);
|
|
1266
|
-
return GeneratorClient.__wrap(ret);
|
|
1267
|
-
}
|
|
1268
|
-
/**
|
|
1269
|
-
* Exporter related operations.
|
|
1270
|
-
* @returns {ExporterClient}
|
|
1271
|
-
*/
|
|
1272
|
-
exporters() {
|
|
1273
|
-
const ret = wasm.bitwardenclient_exporters(this.__wbg_ptr);
|
|
1274
|
-
return ExporterClient.__wrap(ret);
|
|
1275
|
-
}
|
|
1276
|
-
}
|
|
1277
|
-
module.exports.BitwardenClient = BitwardenClient;
|
|
1278
|
-
|
|
1279
|
-
const CiphersClientFinalization =
|
|
1280
|
-
typeof FinalizationRegistry === "undefined"
|
|
1281
|
-
? { register: () => {}, unregister: () => {} }
|
|
1282
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_ciphersclient_free(ptr >>> 0, 1));
|
|
1283
|
-
|
|
1284
|
-
class CiphersClient {
|
|
1285
|
-
static __wrap(ptr) {
|
|
1286
|
-
ptr = ptr >>> 0;
|
|
1287
|
-
const obj = Object.create(CiphersClient.prototype);
|
|
1288
|
-
obj.__wbg_ptr = ptr;
|
|
1289
|
-
CiphersClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1290
|
-
return obj;
|
|
1291
|
-
}
|
|
1292
|
-
|
|
1293
|
-
__destroy_into_raw() {
|
|
1294
|
-
const ptr = this.__wbg_ptr;
|
|
1295
|
-
this.__wbg_ptr = 0;
|
|
1296
|
-
CiphersClientFinalization.unregister(this);
|
|
1297
|
-
return ptr;
|
|
1298
|
-
}
|
|
1299
|
-
|
|
1300
|
-
free() {
|
|
1301
|
-
const ptr = this.__destroy_into_raw();
|
|
1302
|
-
wasm.__wbg_ciphersclient_free(ptr, 0);
|
|
1303
|
-
}
|
|
1304
|
-
/**
|
|
1305
|
-
* @param {CipherView} cipher_view
|
|
1306
|
-
* @returns {EncryptionContext}
|
|
1307
|
-
*/
|
|
1308
|
-
encrypt(cipher_view) {
|
|
1309
|
-
try {
|
|
1310
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1311
|
-
wasm.ciphersclient_encrypt(retptr, this.__wbg_ptr, addHeapObject(cipher_view));
|
|
1312
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1313
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1314
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1315
|
-
if (r2) {
|
|
1316
|
-
throw takeObject(r1);
|
|
1317
|
-
}
|
|
1318
|
-
return takeObject(r0);
|
|
1319
|
-
} finally {
|
|
1320
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1321
|
-
}
|
|
1322
|
-
}
|
|
1323
|
-
/**
|
|
1324
|
-
* Encrypt a cipher with the provided key. This should only be used when rotating encryption
|
|
1325
|
-
* keys in the Web client.
|
|
1326
|
-
*
|
|
1327
|
-
* Until key rotation is fully implemented in the SDK, this method must be provided the new
|
|
1328
|
-
* symmetric key in base64 format. See PM-23084
|
|
1329
|
-
*
|
|
1330
|
-
* If the cipher has a CipherKey, it will be re-encrypted with the new key.
|
|
1331
|
-
* If the cipher does not have a CipherKey and CipherKeyEncryption is enabled, one will be
|
|
1332
|
-
* generated using the new key. Otherwise, the cipher's data will be encrypted with the new
|
|
1333
|
-
* key directly.
|
|
1334
|
-
* @param {CipherView} cipher_view
|
|
1335
|
-
* @param {B64} new_key
|
|
1336
|
-
* @returns {EncryptionContext}
|
|
1337
|
-
*/
|
|
1338
|
-
encrypt_cipher_for_rotation(cipher_view, new_key) {
|
|
1339
|
-
try {
|
|
1340
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1341
|
-
wasm.ciphersclient_encrypt_cipher_for_rotation(
|
|
1342
|
-
retptr,
|
|
1343
|
-
this.__wbg_ptr,
|
|
1344
|
-
addHeapObject(cipher_view),
|
|
1345
|
-
addHeapObject(new_key),
|
|
1346
|
-
);
|
|
1347
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1348
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1349
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1350
|
-
if (r2) {
|
|
1351
|
-
throw takeObject(r1);
|
|
1352
|
-
}
|
|
1353
|
-
return takeObject(r0);
|
|
1354
|
-
} finally {
|
|
1355
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1356
|
-
}
|
|
1357
|
-
}
|
|
1358
|
-
/**
|
|
1359
|
-
* @param {Cipher} cipher
|
|
1360
|
-
* @returns {CipherView}
|
|
1361
|
-
*/
|
|
1362
|
-
decrypt(cipher) {
|
|
1363
|
-
try {
|
|
1364
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1365
|
-
wasm.ciphersclient_decrypt(retptr, this.__wbg_ptr, addHeapObject(cipher));
|
|
1366
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1367
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1368
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1369
|
-
if (r2) {
|
|
1370
|
-
throw takeObject(r1);
|
|
1371
|
-
}
|
|
1372
|
-
return takeObject(r0);
|
|
1373
|
-
} finally {
|
|
1374
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1375
|
-
}
|
|
1376
|
-
}
|
|
1377
|
-
/**
|
|
1378
|
-
* @param {Cipher[]} ciphers
|
|
1379
|
-
* @returns {CipherListView[]}
|
|
1380
|
-
*/
|
|
1381
|
-
decrypt_list(ciphers) {
|
|
1382
|
-
try {
|
|
1383
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1384
|
-
const ptr0 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
|
|
1385
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1386
|
-
wasm.ciphersclient_decrypt_list(retptr, this.__wbg_ptr, ptr0, len0);
|
|
1387
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1388
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1389
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1390
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1391
|
-
if (r3) {
|
|
1392
|
-
throw takeObject(r2);
|
|
1393
|
-
}
|
|
1394
|
-
var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
|
|
1395
|
-
wasm.__wbindgen_free(r0, r1 * 4, 4);
|
|
1396
|
-
return v2;
|
|
1397
|
-
} finally {
|
|
1398
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1399
|
-
}
|
|
1400
|
-
}
|
|
1401
|
-
/**
|
|
1402
|
-
* Decrypt cipher list with failures
|
|
1403
|
-
* Returns both successfully decrypted ciphers and any that failed to decrypt
|
|
1404
|
-
* @param {Cipher[]} ciphers
|
|
1405
|
-
* @returns {DecryptCipherListResult}
|
|
1406
|
-
*/
|
|
1407
|
-
decrypt_list_with_failures(ciphers) {
|
|
1408
|
-
const ptr0 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
|
|
1409
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1410
|
-
const ret = wasm.ciphersclient_decrypt_list_with_failures(this.__wbg_ptr, ptr0, len0);
|
|
1411
|
-
return takeObject(ret);
|
|
1412
|
-
}
|
|
1413
|
-
/**
|
|
1414
|
-
* @param {CipherView} cipher_view
|
|
1415
|
-
* @returns {Fido2CredentialView[]}
|
|
1416
|
-
*/
|
|
1417
|
-
decrypt_fido2_credentials(cipher_view) {
|
|
1418
|
-
try {
|
|
1419
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1420
|
-
wasm.ciphersclient_decrypt_fido2_credentials(
|
|
1421
|
-
retptr,
|
|
1422
|
-
this.__wbg_ptr,
|
|
1423
|
-
addHeapObject(cipher_view),
|
|
1424
|
-
);
|
|
1425
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1426
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1427
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1428
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1429
|
-
if (r3) {
|
|
1430
|
-
throw takeObject(r2);
|
|
1431
|
-
}
|
|
1432
|
-
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
|
|
1433
|
-
wasm.__wbindgen_free(r0, r1 * 4, 4);
|
|
1434
|
-
return v1;
|
|
1435
|
-
} finally {
|
|
1436
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1437
|
-
}
|
|
1438
|
-
}
|
|
1439
|
-
/**
|
|
1440
|
-
* Temporary method used to re-encrypt FIDO2 credentials for a cipher view.
|
|
1441
|
-
* Necessary until the TS clients utilize the SDK entirely for FIDO2 credentials management.
|
|
1442
|
-
* TS clients create decrypted FIDO2 credentials that need to be encrypted manually when
|
|
1443
|
-
* encrypting the rest of the CipherView.
|
|
1444
|
-
* TODO: Remove once TS passkey provider implementation uses SDK - PM-8313
|
|
1445
|
-
* @param {CipherView} cipher_view
|
|
1446
|
-
* @param {Fido2CredentialFullView[]} fido2_credentials
|
|
1447
|
-
* @returns {CipherView}
|
|
1448
|
-
*/
|
|
1449
|
-
set_fido2_credentials(cipher_view, fido2_credentials) {
|
|
1450
|
-
try {
|
|
1451
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1452
|
-
const ptr0 = passArrayJsValueToWasm0(fido2_credentials, wasm.__wbindgen_malloc);
|
|
1453
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1454
|
-
wasm.ciphersclient_set_fido2_credentials(
|
|
1455
|
-
retptr,
|
|
1456
|
-
this.__wbg_ptr,
|
|
1457
|
-
addHeapObject(cipher_view),
|
|
1458
|
-
ptr0,
|
|
1459
|
-
len0,
|
|
1460
|
-
);
|
|
1461
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1462
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1463
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1464
|
-
if (r2) {
|
|
1465
|
-
throw takeObject(r1);
|
|
1466
|
-
}
|
|
1467
|
-
return takeObject(r0);
|
|
1468
|
-
} finally {
|
|
1469
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1470
|
-
}
|
|
1471
|
-
}
|
|
1472
|
-
/**
|
|
1473
|
-
* @param {CipherView} cipher_view
|
|
1474
|
-
* @param {OrganizationId} organization_id
|
|
1475
|
-
* @returns {CipherView}
|
|
1476
|
-
*/
|
|
1477
|
-
move_to_organization(cipher_view, organization_id) {
|
|
1478
|
-
try {
|
|
1479
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1480
|
-
wasm.ciphersclient_move_to_organization(
|
|
1481
|
-
retptr,
|
|
1482
|
-
this.__wbg_ptr,
|
|
1483
|
-
addHeapObject(cipher_view),
|
|
1484
|
-
addHeapObject(organization_id),
|
|
1485
|
-
);
|
|
1486
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1487
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1488
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1489
|
-
if (r2) {
|
|
1490
|
-
throw takeObject(r1);
|
|
1491
|
-
}
|
|
1492
|
-
return takeObject(r0);
|
|
1493
|
-
} finally {
|
|
1494
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1495
|
-
}
|
|
1496
|
-
}
|
|
1497
|
-
/**
|
|
1498
|
-
* @param {CipherView} cipher_view
|
|
1499
|
-
* @returns {string}
|
|
1500
|
-
*/
|
|
1501
|
-
decrypt_fido2_private_key(cipher_view) {
|
|
1502
|
-
let deferred2_0;
|
|
1503
|
-
let deferred2_1;
|
|
1504
|
-
try {
|
|
1505
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1506
|
-
wasm.ciphersclient_decrypt_fido2_private_key(
|
|
1507
|
-
retptr,
|
|
1508
|
-
this.__wbg_ptr,
|
|
1509
|
-
addHeapObject(cipher_view),
|
|
1510
|
-
);
|
|
1511
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1512
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1513
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1514
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1515
|
-
var ptr1 = r0;
|
|
1516
|
-
var len1 = r1;
|
|
1517
|
-
if (r3) {
|
|
1518
|
-
ptr1 = 0;
|
|
1519
|
-
len1 = 0;
|
|
1520
|
-
throw takeObject(r2);
|
|
1521
|
-
}
|
|
1522
|
-
deferred2_0 = ptr1;
|
|
1523
|
-
deferred2_1 = len1;
|
|
1524
|
-
return getStringFromWasm0(ptr1, len1);
|
|
1525
|
-
} finally {
|
|
1526
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1527
|
-
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1528
|
-
}
|
|
1529
|
-
}
|
|
1530
|
-
}
|
|
1531
|
-
module.exports.CiphersClient = CiphersClient;
|
|
1532
|
-
|
|
1533
|
-
const CollectionViewNodeItemFinalization =
|
|
1534
|
-
typeof FinalizationRegistry === "undefined"
|
|
1535
|
-
? { register: () => {}, unregister: () => {} }
|
|
1536
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_collectionviewnodeitem_free(ptr >>> 0, 1));
|
|
1537
|
-
|
|
1538
|
-
class CollectionViewNodeItem {
|
|
1539
|
-
static __wrap(ptr) {
|
|
1540
|
-
ptr = ptr >>> 0;
|
|
1541
|
-
const obj = Object.create(CollectionViewNodeItem.prototype);
|
|
1542
|
-
obj.__wbg_ptr = ptr;
|
|
1543
|
-
CollectionViewNodeItemFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1544
|
-
return obj;
|
|
1545
|
-
}
|
|
1546
|
-
|
|
1547
|
-
__destroy_into_raw() {
|
|
1548
|
-
const ptr = this.__wbg_ptr;
|
|
1549
|
-
this.__wbg_ptr = 0;
|
|
1550
|
-
CollectionViewNodeItemFinalization.unregister(this);
|
|
1551
|
-
return ptr;
|
|
1552
|
-
}
|
|
1553
|
-
|
|
1554
|
-
free() {
|
|
1555
|
-
const ptr = this.__destroy_into_raw();
|
|
1556
|
-
wasm.__wbg_collectionviewnodeitem_free(ptr, 0);
|
|
1557
|
-
}
|
|
1558
|
-
/**
|
|
1559
|
-
* @returns {CollectionView}
|
|
1560
|
-
*/
|
|
1561
|
-
get_item() {
|
|
1562
|
-
const ret = wasm.collectionviewnodeitem_get_item(this.__wbg_ptr);
|
|
1563
|
-
return takeObject(ret);
|
|
1564
|
-
}
|
|
1565
|
-
/**
|
|
1566
|
-
* @returns {CollectionView | undefined}
|
|
1567
|
-
*/
|
|
1568
|
-
get_parent() {
|
|
1569
|
-
const ret = wasm.collectionviewnodeitem_get_parent(this.__wbg_ptr);
|
|
1570
|
-
return takeObject(ret);
|
|
1571
|
-
}
|
|
1572
|
-
/**
|
|
1573
|
-
* @returns {CollectionView[]}
|
|
1574
|
-
*/
|
|
1575
|
-
get_children() {
|
|
1576
|
-
try {
|
|
1577
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1578
|
-
wasm.collectionviewnodeitem_get_children(retptr, this.__wbg_ptr);
|
|
1579
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1580
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1581
|
-
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
|
|
1582
|
-
wasm.__wbindgen_free(r0, r1 * 4, 4);
|
|
1583
|
-
return v1;
|
|
1584
|
-
} finally {
|
|
1585
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1586
|
-
}
|
|
1587
|
-
}
|
|
1588
|
-
/**
|
|
1589
|
-
* @returns {AncestorMap}
|
|
1590
|
-
*/
|
|
1591
|
-
get_ancestors() {
|
|
1592
|
-
const ret = wasm.collectionviewnodeitem_get_ancestors(this.__wbg_ptr);
|
|
1593
|
-
return takeObject(ret);
|
|
1594
|
-
}
|
|
1595
|
-
}
|
|
1596
|
-
module.exports.CollectionViewNodeItem = CollectionViewNodeItem;
|
|
1597
|
-
|
|
1598
|
-
const CollectionViewTreeFinalization =
|
|
1599
|
-
typeof FinalizationRegistry === "undefined"
|
|
1600
|
-
? { register: () => {}, unregister: () => {} }
|
|
1601
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_collectionviewtree_free(ptr >>> 0, 1));
|
|
1602
|
-
|
|
1603
|
-
class CollectionViewTree {
|
|
1604
|
-
static __wrap(ptr) {
|
|
1605
|
-
ptr = ptr >>> 0;
|
|
1606
|
-
const obj = Object.create(CollectionViewTree.prototype);
|
|
1607
|
-
obj.__wbg_ptr = ptr;
|
|
1608
|
-
CollectionViewTreeFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1609
|
-
return obj;
|
|
1610
|
-
}
|
|
1611
|
-
|
|
1612
|
-
__destroy_into_raw() {
|
|
1613
|
-
const ptr = this.__wbg_ptr;
|
|
1614
|
-
this.__wbg_ptr = 0;
|
|
1615
|
-
CollectionViewTreeFinalization.unregister(this);
|
|
1616
|
-
return ptr;
|
|
1617
|
-
}
|
|
1618
|
-
|
|
1619
|
-
free() {
|
|
1620
|
-
const ptr = this.__destroy_into_raw();
|
|
1621
|
-
wasm.__wbg_collectionviewtree_free(ptr, 0);
|
|
1622
|
-
}
|
|
1623
|
-
/**
|
|
1624
|
-
* @param {CollectionView} collection_view
|
|
1625
|
-
* @returns {CollectionViewNodeItem | undefined}
|
|
1626
|
-
*/
|
|
1627
|
-
get_item_for_view(collection_view) {
|
|
1628
|
-
const ret = wasm.collectionviewtree_get_item_for_view(
|
|
1629
|
-
this.__wbg_ptr,
|
|
1630
|
-
addHeapObject(collection_view),
|
|
1631
|
-
);
|
|
1632
|
-
return ret === 0 ? undefined : CollectionViewNodeItem.__wrap(ret);
|
|
1633
|
-
}
|
|
1634
|
-
/**
|
|
1635
|
-
* @returns {CollectionViewNodeItem[]}
|
|
1636
|
-
*/
|
|
1637
|
-
get_root_items() {
|
|
1638
|
-
try {
|
|
1639
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1640
|
-
wasm.collectionviewtree_get_root_items(retptr, this.__wbg_ptr);
|
|
1641
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1642
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1643
|
-
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
|
|
1644
|
-
wasm.__wbindgen_free(r0, r1 * 4, 4);
|
|
1645
|
-
return v1;
|
|
1646
|
-
} finally {
|
|
1647
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1648
|
-
}
|
|
1649
|
-
}
|
|
1650
|
-
/**
|
|
1651
|
-
* @returns {CollectionViewNodeItem[]}
|
|
1652
|
-
*/
|
|
1653
|
-
get_flat_items() {
|
|
1654
|
-
try {
|
|
1655
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1656
|
-
wasm.collectionviewtree_get_flat_items(retptr, this.__wbg_ptr);
|
|
1657
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1658
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1659
|
-
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
|
|
1660
|
-
wasm.__wbindgen_free(r0, r1 * 4, 4);
|
|
1661
|
-
return v1;
|
|
1662
|
-
} finally {
|
|
1663
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1664
|
-
}
|
|
1665
|
-
}
|
|
1666
|
-
}
|
|
1667
|
-
module.exports.CollectionViewTree = CollectionViewTree;
|
|
1668
|
-
|
|
1669
|
-
const CollectionsClientFinalization =
|
|
1670
|
-
typeof FinalizationRegistry === "undefined"
|
|
1671
|
-
? { register: () => {}, unregister: () => {} }
|
|
1672
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_collectionsclient_free(ptr >>> 0, 1));
|
|
1673
|
-
|
|
1674
|
-
class CollectionsClient {
|
|
1675
|
-
static __wrap(ptr) {
|
|
1676
|
-
ptr = ptr >>> 0;
|
|
1677
|
-
const obj = Object.create(CollectionsClient.prototype);
|
|
1678
|
-
obj.__wbg_ptr = ptr;
|
|
1679
|
-
CollectionsClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1680
|
-
return obj;
|
|
1681
|
-
}
|
|
1682
|
-
|
|
1683
|
-
__destroy_into_raw() {
|
|
1684
|
-
const ptr = this.__wbg_ptr;
|
|
1685
|
-
this.__wbg_ptr = 0;
|
|
1686
|
-
CollectionsClientFinalization.unregister(this);
|
|
1687
|
-
return ptr;
|
|
1688
|
-
}
|
|
1689
|
-
|
|
1690
|
-
free() {
|
|
1691
|
-
const ptr = this.__destroy_into_raw();
|
|
1692
|
-
wasm.__wbg_collectionsclient_free(ptr, 0);
|
|
1693
|
-
}
|
|
1694
|
-
/**
|
|
1695
|
-
* @param {Collection} collection
|
|
1696
|
-
* @returns {CollectionView}
|
|
1697
|
-
*/
|
|
1698
|
-
decrypt(collection) {
|
|
1699
|
-
try {
|
|
1700
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1701
|
-
wasm.collectionsclient_decrypt(retptr, this.__wbg_ptr, addHeapObject(collection));
|
|
1702
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1703
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1704
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1705
|
-
if (r2) {
|
|
1706
|
-
throw takeObject(r1);
|
|
1707
|
-
}
|
|
1708
|
-
return takeObject(r0);
|
|
1709
|
-
} finally {
|
|
1710
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1711
|
-
}
|
|
1712
|
-
}
|
|
1713
|
-
/**
|
|
1714
|
-
* @param {Collection[]} collections
|
|
1715
|
-
* @returns {CollectionView[]}
|
|
1716
|
-
*/
|
|
1717
|
-
decrypt_list(collections) {
|
|
1718
|
-
try {
|
|
1719
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1720
|
-
const ptr0 = passArrayJsValueToWasm0(collections, wasm.__wbindgen_malloc);
|
|
1721
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1722
|
-
wasm.collectionsclient_decrypt_list(retptr, this.__wbg_ptr, ptr0, len0);
|
|
1723
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1724
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1725
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1726
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1727
|
-
if (r3) {
|
|
1728
|
-
throw takeObject(r2);
|
|
1729
|
-
}
|
|
1730
|
-
var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
|
|
1731
|
-
wasm.__wbindgen_free(r0, r1 * 4, 4);
|
|
1732
|
-
return v2;
|
|
1733
|
-
} finally {
|
|
1734
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1735
|
-
}
|
|
1736
|
-
}
|
|
1737
|
-
/**
|
|
1738
|
-
*
|
|
1739
|
-
* Returns the vector of CollectionView objects in a tree structure based on its implemented
|
|
1740
|
-
* path().
|
|
1741
|
-
* @param {CollectionView[]} collections
|
|
1742
|
-
* @returns {CollectionViewTree}
|
|
1743
|
-
*/
|
|
1744
|
-
get_collection_tree(collections) {
|
|
1745
|
-
const ptr0 = passArrayJsValueToWasm0(collections, wasm.__wbindgen_malloc);
|
|
1746
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1747
|
-
const ret = wasm.collectionsclient_get_collection_tree(this.__wbg_ptr, ptr0, len0);
|
|
1748
|
-
return CollectionViewTree.__wrap(ret);
|
|
1749
|
-
}
|
|
1750
|
-
}
|
|
1751
|
-
module.exports.CollectionsClient = CollectionsClient;
|
|
1752
|
-
|
|
1753
|
-
const CryptoClientFinalization =
|
|
1754
|
-
typeof FinalizationRegistry === "undefined"
|
|
1755
|
-
? { register: () => {}, unregister: () => {} }
|
|
1756
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_cryptoclient_free(ptr >>> 0, 1));
|
|
1757
|
-
/**
|
|
1758
|
-
* A client for the crypto operations.
|
|
1759
|
-
*/
|
|
1760
|
-
class CryptoClient {
|
|
1761
|
-
static __wrap(ptr) {
|
|
1762
|
-
ptr = ptr >>> 0;
|
|
1763
|
-
const obj = Object.create(CryptoClient.prototype);
|
|
1764
|
-
obj.__wbg_ptr = ptr;
|
|
1765
|
-
CryptoClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1766
|
-
return obj;
|
|
1767
|
-
}
|
|
1768
|
-
|
|
1769
|
-
__destroy_into_raw() {
|
|
1770
|
-
const ptr = this.__wbg_ptr;
|
|
1771
|
-
this.__wbg_ptr = 0;
|
|
1772
|
-
CryptoClientFinalization.unregister(this);
|
|
1773
|
-
return ptr;
|
|
1774
|
-
}
|
|
1775
|
-
|
|
1776
|
-
free() {
|
|
1777
|
-
const ptr = this.__destroy_into_raw();
|
|
1778
|
-
wasm.__wbg_cryptoclient_free(ptr, 0);
|
|
1779
|
-
}
|
|
1780
|
-
/**
|
|
1781
|
-
* Initialization method for the user crypto. Needs to be called before any other crypto
|
|
1782
|
-
* operations.
|
|
1783
|
-
* @param {InitUserCryptoRequest} req
|
|
1784
|
-
* @returns {Promise<void>}
|
|
1785
|
-
*/
|
|
1786
|
-
initialize_user_crypto(req) {
|
|
1787
|
-
const ret = wasm.cryptoclient_initialize_user_crypto(this.__wbg_ptr, addHeapObject(req));
|
|
1788
|
-
return takeObject(ret);
|
|
1789
|
-
}
|
|
1790
|
-
/**
|
|
1791
|
-
* Initialization method for the organization crypto. Needs to be called after
|
|
1792
|
-
* `initialize_user_crypto` but before any other crypto operations.
|
|
1793
|
-
* @param {InitOrgCryptoRequest} req
|
|
1794
|
-
* @returns {Promise<void>}
|
|
1795
|
-
*/
|
|
1796
|
-
initialize_org_crypto(req) {
|
|
1797
|
-
const ret = wasm.cryptoclient_initialize_org_crypto(this.__wbg_ptr, addHeapObject(req));
|
|
1798
|
-
return takeObject(ret);
|
|
1799
|
-
}
|
|
1800
|
-
/**
|
|
1801
|
-
* Generates a new key pair and encrypts the private key with the provided user key.
|
|
1802
|
-
* Crypto initialization not required.
|
|
1803
|
-
* @param {B64} user_key
|
|
1804
|
-
* @returns {MakeKeyPairResponse}
|
|
1805
|
-
*/
|
|
1806
|
-
make_key_pair(user_key) {
|
|
1807
|
-
try {
|
|
1808
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1809
|
-
wasm.cryptoclient_make_key_pair(retptr, this.__wbg_ptr, addHeapObject(user_key));
|
|
1810
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1811
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1812
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1813
|
-
if (r2) {
|
|
1814
|
-
throw takeObject(r1);
|
|
1815
|
-
}
|
|
1816
|
-
return takeObject(r0);
|
|
1817
|
-
} finally {
|
|
1818
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1819
|
-
}
|
|
1820
|
-
}
|
|
1821
|
-
/**
|
|
1822
|
-
* Verifies a user's asymmetric keys by decrypting the private key with the provided user
|
|
1823
|
-
* key. Returns if the private key is decryptable and if it is a valid matching key.
|
|
1824
|
-
* Crypto initialization not required.
|
|
1825
|
-
* @param {VerifyAsymmetricKeysRequest} request
|
|
1826
|
-
* @returns {VerifyAsymmetricKeysResponse}
|
|
1827
|
-
*/
|
|
1828
|
-
verify_asymmetric_keys(request) {
|
|
1829
|
-
try {
|
|
1830
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1831
|
-
wasm.cryptoclient_verify_asymmetric_keys(retptr, this.__wbg_ptr, addHeapObject(request));
|
|
1832
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1833
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1834
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1835
|
-
if (r2) {
|
|
1836
|
-
throw takeObject(r1);
|
|
1837
|
-
}
|
|
1838
|
-
return takeObject(r0);
|
|
1839
|
-
} finally {
|
|
1840
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1841
|
-
}
|
|
1842
|
-
}
|
|
1843
|
-
/**
|
|
1844
|
-
* Makes a new signing key pair and signs the public key for the user
|
|
1845
|
-
* @returns {UserCryptoV2KeysResponse}
|
|
1846
|
-
*/
|
|
1847
|
-
make_keys_for_user_crypto_v2() {
|
|
1848
|
-
try {
|
|
1849
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1850
|
-
wasm.cryptoclient_make_keys_for_user_crypto_v2(retptr, this.__wbg_ptr);
|
|
1851
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1852
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1853
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1854
|
-
if (r2) {
|
|
1855
|
-
throw takeObject(r1);
|
|
1856
|
-
}
|
|
1857
|
-
return takeObject(r0);
|
|
1858
|
-
} finally {
|
|
1859
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1860
|
-
}
|
|
1861
|
-
}
|
|
1862
|
-
/**
|
|
1863
|
-
* Creates a rotated set of account keys for the current state
|
|
1864
|
-
* @returns {UserCryptoV2KeysResponse}
|
|
1865
|
-
*/
|
|
1866
|
-
get_v2_rotated_account_keys() {
|
|
1867
|
-
try {
|
|
1868
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1869
|
-
wasm.cryptoclient_get_v2_rotated_account_keys(retptr, this.__wbg_ptr);
|
|
1870
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1871
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1872
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1873
|
-
if (r2) {
|
|
1874
|
-
throw takeObject(r1);
|
|
1875
|
-
}
|
|
1876
|
-
return takeObject(r0);
|
|
1877
|
-
} finally {
|
|
1878
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1879
|
-
}
|
|
1880
|
-
}
|
|
1881
|
-
/**
|
|
1882
|
-
* Create the data necessary to update the user's kdf settings. The user's encryption key is
|
|
1883
|
-
* re-encrypted for the password under the new kdf settings. This returns the re-encrypted
|
|
1884
|
-
* user key and the new password hash but does not update sdk state.
|
|
1885
|
-
* @param {string} password
|
|
1886
|
-
* @param {Kdf} kdf
|
|
1887
|
-
* @returns {UpdateKdfResponse}
|
|
1888
|
-
*/
|
|
1889
|
-
make_update_kdf(password, kdf) {
|
|
1890
|
-
try {
|
|
1891
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1892
|
-
const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1893
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1894
|
-
wasm.cryptoclient_make_update_kdf(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(kdf));
|
|
1895
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1896
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1897
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1898
|
-
if (r2) {
|
|
1899
|
-
throw takeObject(r1);
|
|
1900
|
-
}
|
|
1901
|
-
return takeObject(r0);
|
|
1902
|
-
} finally {
|
|
1903
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1904
|
-
}
|
|
1905
|
-
}
|
|
1906
|
-
/**
|
|
1907
|
-
* Protects the current user key with the provided PIN. The result can be stored and later
|
|
1908
|
-
* used to initialize another client instance by using the PIN and the PIN key with
|
|
1909
|
-
* `initialize_user_crypto`.
|
|
1910
|
-
* @param {string} pin
|
|
1911
|
-
* @returns {EnrollPinResponse}
|
|
1912
|
-
*/
|
|
1913
|
-
enroll_pin(pin) {
|
|
1914
|
-
try {
|
|
1915
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1916
|
-
const ptr0 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1917
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1918
|
-
wasm.cryptoclient_enroll_pin(retptr, this.__wbg_ptr, ptr0, len0);
|
|
1919
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1920
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1921
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1922
|
-
if (r2) {
|
|
1923
|
-
throw takeObject(r1);
|
|
1924
|
-
}
|
|
1925
|
-
return takeObject(r0);
|
|
1926
|
-
} finally {
|
|
1927
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1928
|
-
}
|
|
1929
|
-
}
|
|
1930
|
-
/**
|
|
1931
|
-
* Protects the current user key with the provided PIN. The result can be stored and later
|
|
1932
|
-
* used to initialize another client instance by using the PIN and the PIN key with
|
|
1933
|
-
* `initialize_user_crypto`. The provided pin is encrypted with the user key.
|
|
1934
|
-
* @param {string} encrypted_pin
|
|
1935
|
-
* @returns {EnrollPinResponse}
|
|
1936
|
-
*/
|
|
1937
|
-
enroll_pin_with_encrypted_pin(encrypted_pin) {
|
|
1938
|
-
try {
|
|
1939
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1940
|
-
const ptr0 = passStringToWasm0(
|
|
1941
|
-
encrypted_pin,
|
|
1942
|
-
wasm.__wbindgen_malloc,
|
|
1943
|
-
wasm.__wbindgen_realloc,
|
|
1944
|
-
);
|
|
1945
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1946
|
-
wasm.cryptoclient_enroll_pin_with_encrypted_pin(retptr, this.__wbg_ptr, ptr0, len0);
|
|
1947
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1948
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1949
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1950
|
-
if (r2) {
|
|
1951
|
-
throw takeObject(r1);
|
|
1952
|
-
}
|
|
1953
|
-
return takeObject(r0);
|
|
1954
|
-
} finally {
|
|
1955
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1956
|
-
}
|
|
1957
|
-
}
|
|
1958
|
-
/**
|
|
1959
|
-
* Decrypts a `PasswordProtectedKeyEnvelope`, returning the user key, if successful.
|
|
1960
|
-
* This is a stop-gap solution, until initialization of the SDK is used.
|
|
1961
|
-
* @param {string} pin
|
|
1962
|
-
* @param {PasswordProtectedKeyEnvelope} envelope
|
|
1963
|
-
* @returns {Uint8Array}
|
|
1964
|
-
*/
|
|
1965
|
-
unseal_password_protected_key_envelope(pin, envelope) {
|
|
1966
|
-
try {
|
|
1967
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1968
|
-
const ptr0 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1969
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1970
|
-
wasm.cryptoclient_unseal_password_protected_key_envelope(
|
|
1971
|
-
retptr,
|
|
1972
|
-
this.__wbg_ptr,
|
|
1973
|
-
ptr0,
|
|
1974
|
-
len0,
|
|
1975
|
-
addHeapObject(envelope),
|
|
1976
|
-
);
|
|
1977
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1978
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1979
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1980
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1981
|
-
if (r3) {
|
|
1982
|
-
throw takeObject(r2);
|
|
1983
|
-
}
|
|
1984
|
-
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
1985
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
1986
|
-
return v2;
|
|
1987
|
-
} finally {
|
|
1988
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1989
|
-
}
|
|
1990
|
-
}
|
|
1991
|
-
}
|
|
1992
|
-
module.exports.CryptoClient = CryptoClient;
|
|
1993
|
-
|
|
1994
|
-
const ExporterClientFinalization =
|
|
1995
|
-
typeof FinalizationRegistry === "undefined"
|
|
1996
|
-
? { register: () => {}, unregister: () => {} }
|
|
1997
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_exporterclient_free(ptr >>> 0, 1));
|
|
1998
|
-
|
|
1999
|
-
class ExporterClient {
|
|
2000
|
-
static __wrap(ptr) {
|
|
2001
|
-
ptr = ptr >>> 0;
|
|
2002
|
-
const obj = Object.create(ExporterClient.prototype);
|
|
2003
|
-
obj.__wbg_ptr = ptr;
|
|
2004
|
-
ExporterClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
2005
|
-
return obj;
|
|
2006
|
-
}
|
|
2007
|
-
|
|
2008
|
-
__destroy_into_raw() {
|
|
2009
|
-
const ptr = this.__wbg_ptr;
|
|
2010
|
-
this.__wbg_ptr = 0;
|
|
2011
|
-
ExporterClientFinalization.unregister(this);
|
|
2012
|
-
return ptr;
|
|
2013
|
-
}
|
|
2014
|
-
|
|
2015
|
-
free() {
|
|
2016
|
-
const ptr = this.__destroy_into_raw();
|
|
2017
|
-
wasm.__wbg_exporterclient_free(ptr, 0);
|
|
2018
|
-
}
|
|
2019
|
-
/**
|
|
2020
|
-
* @param {Folder[]} folders
|
|
2021
|
-
* @param {Cipher[]} ciphers
|
|
2022
|
-
* @param {ExportFormat} format
|
|
2023
|
-
* @returns {string}
|
|
2024
|
-
*/
|
|
2025
|
-
export_vault(folders, ciphers, format) {
|
|
2026
|
-
let deferred4_0;
|
|
2027
|
-
let deferred4_1;
|
|
2028
|
-
try {
|
|
2029
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2030
|
-
const ptr0 = passArrayJsValueToWasm0(folders, wasm.__wbindgen_malloc);
|
|
2031
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2032
|
-
const ptr1 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
|
|
2033
|
-
const len1 = WASM_VECTOR_LEN;
|
|
2034
|
-
wasm.exporterclient_export_vault(
|
|
2035
|
-
retptr,
|
|
2036
|
-
this.__wbg_ptr,
|
|
2037
|
-
ptr0,
|
|
2038
|
-
len0,
|
|
2039
|
-
ptr1,
|
|
2040
|
-
len1,
|
|
2041
|
-
addHeapObject(format),
|
|
2042
|
-
);
|
|
2043
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2044
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2045
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2046
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
2047
|
-
var ptr3 = r0;
|
|
2048
|
-
var len3 = r1;
|
|
2049
|
-
if (r3) {
|
|
2050
|
-
ptr3 = 0;
|
|
2051
|
-
len3 = 0;
|
|
2052
|
-
throw takeObject(r2);
|
|
2053
|
-
}
|
|
2054
|
-
deferred4_0 = ptr3;
|
|
2055
|
-
deferred4_1 = len3;
|
|
2056
|
-
return getStringFromWasm0(ptr3, len3);
|
|
2057
|
-
} finally {
|
|
2058
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2059
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2060
|
-
}
|
|
2061
|
-
}
|
|
2062
|
-
/**
|
|
2063
|
-
* @param {Collection[]} collections
|
|
2064
|
-
* @param {Cipher[]} ciphers
|
|
2065
|
-
* @param {ExportFormat} format
|
|
2066
|
-
* @returns {string}
|
|
2067
|
-
*/
|
|
2068
|
-
export_organization_vault(collections, ciphers, format) {
|
|
2069
|
-
let deferred4_0;
|
|
2070
|
-
let deferred4_1;
|
|
2071
|
-
try {
|
|
2072
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2073
|
-
const ptr0 = passArrayJsValueToWasm0(collections, wasm.__wbindgen_malloc);
|
|
2074
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2075
|
-
const ptr1 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
|
|
2076
|
-
const len1 = WASM_VECTOR_LEN;
|
|
2077
|
-
wasm.exporterclient_export_organization_vault(
|
|
2078
|
-
retptr,
|
|
2079
|
-
this.__wbg_ptr,
|
|
2080
|
-
ptr0,
|
|
2081
|
-
len0,
|
|
2082
|
-
ptr1,
|
|
2083
|
-
len1,
|
|
2084
|
-
addHeapObject(format),
|
|
2085
|
-
);
|
|
2086
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2087
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2088
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2089
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
2090
|
-
var ptr3 = r0;
|
|
2091
|
-
var len3 = r1;
|
|
2092
|
-
if (r3) {
|
|
2093
|
-
ptr3 = 0;
|
|
2094
|
-
len3 = 0;
|
|
2095
|
-
throw takeObject(r2);
|
|
2096
|
-
}
|
|
2097
|
-
deferred4_0 = ptr3;
|
|
2098
|
-
deferred4_1 = len3;
|
|
2099
|
-
return getStringFromWasm0(ptr3, len3);
|
|
2100
|
-
} finally {
|
|
2101
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2102
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2103
|
-
}
|
|
2104
|
-
}
|
|
2105
|
-
/**
|
|
2106
|
-
* Credential Exchange Format (CXF)
|
|
2107
|
-
*
|
|
2108
|
-
* *Warning:* Expect this API to be unstable, and it will change in the future.
|
|
2109
|
-
*
|
|
2110
|
-
* For use with Apple using [ASCredentialExportManager](https://developer.apple.com/documentation/authenticationservices/ascredentialexportmanager).
|
|
2111
|
-
* Ideally, the input should be immediately serialized from [ASImportableAccount](https://developer.apple.com/documentation/authenticationservices/asimportableaccount).
|
|
2112
|
-
* @param {Account} account
|
|
2113
|
-
* @param {Cipher[]} ciphers
|
|
2114
|
-
* @returns {string}
|
|
2115
|
-
*/
|
|
2116
|
-
export_cxf(account, ciphers) {
|
|
2117
|
-
let deferred3_0;
|
|
2118
|
-
let deferred3_1;
|
|
2119
|
-
try {
|
|
2120
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2121
|
-
const ptr0 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
|
|
2122
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2123
|
-
wasm.exporterclient_export_cxf(retptr, this.__wbg_ptr, addHeapObject(account), ptr0, len0);
|
|
2124
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2125
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2126
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2127
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
2128
|
-
var ptr2 = r0;
|
|
2129
|
-
var len2 = r1;
|
|
2130
|
-
if (r3) {
|
|
2131
|
-
ptr2 = 0;
|
|
2132
|
-
len2 = 0;
|
|
2133
|
-
throw takeObject(r2);
|
|
2134
|
-
}
|
|
2135
|
-
deferred3_0 = ptr2;
|
|
2136
|
-
deferred3_1 = len2;
|
|
2137
|
-
return getStringFromWasm0(ptr2, len2);
|
|
2138
|
-
} finally {
|
|
2139
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2140
|
-
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2141
|
-
}
|
|
2142
|
-
}
|
|
2143
|
-
/**
|
|
2144
|
-
* Credential Exchange Format (CXF)
|
|
2145
|
-
*
|
|
2146
|
-
* *Warning:* Expect this API to be unstable, and it will change in the future.
|
|
2147
|
-
*
|
|
2148
|
-
* For use with Apple using [ASCredentialExportManager](https://developer.apple.com/documentation/authenticationservices/ascredentialexportmanager).
|
|
2149
|
-
* Ideally, the input should be immediately serialized from [ASImportableAccount](https://developer.apple.com/documentation/authenticationservices/asimportableaccount).
|
|
2150
|
-
* @param {string} payload
|
|
2151
|
-
* @returns {Cipher[]}
|
|
2152
|
-
*/
|
|
2153
|
-
import_cxf(payload) {
|
|
2154
|
-
try {
|
|
2155
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2156
|
-
const ptr0 = passStringToWasm0(payload, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2157
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2158
|
-
wasm.exporterclient_import_cxf(retptr, this.__wbg_ptr, ptr0, len0);
|
|
2159
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2160
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2161
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2162
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
2163
|
-
if (r3) {
|
|
2164
|
-
throw takeObject(r2);
|
|
2165
|
-
}
|
|
2166
|
-
var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
|
|
2167
|
-
wasm.__wbindgen_free(r0, r1 * 4, 4);
|
|
2168
|
-
return v2;
|
|
2169
|
-
} finally {
|
|
2170
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2171
|
-
}
|
|
2172
|
-
}
|
|
2173
|
-
}
|
|
2174
|
-
module.exports.ExporterClient = ExporterClient;
|
|
2175
|
-
|
|
2176
|
-
const FoldersClientFinalization =
|
|
2177
|
-
typeof FinalizationRegistry === "undefined"
|
|
2178
|
-
? { register: () => {}, unregister: () => {} }
|
|
2179
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_foldersclient_free(ptr >>> 0, 1));
|
|
2180
|
-
/**
|
|
2181
|
-
* Wrapper for folder specific functionality.
|
|
2182
|
-
*/
|
|
2183
|
-
class FoldersClient {
|
|
2184
|
-
static __wrap(ptr) {
|
|
2185
|
-
ptr = ptr >>> 0;
|
|
2186
|
-
const obj = Object.create(FoldersClient.prototype);
|
|
2187
|
-
obj.__wbg_ptr = ptr;
|
|
2188
|
-
FoldersClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
2189
|
-
return obj;
|
|
2190
|
-
}
|
|
2191
|
-
|
|
2192
|
-
__destroy_into_raw() {
|
|
2193
|
-
const ptr = this.__wbg_ptr;
|
|
2194
|
-
this.__wbg_ptr = 0;
|
|
2195
|
-
FoldersClientFinalization.unregister(this);
|
|
2196
|
-
return ptr;
|
|
2197
|
-
}
|
|
2198
|
-
|
|
2199
|
-
free() {
|
|
2200
|
-
const ptr = this.__destroy_into_raw();
|
|
2201
|
-
wasm.__wbg_foldersclient_free(ptr, 0);
|
|
2202
|
-
}
|
|
2203
|
-
/**
|
|
2204
|
-
* Encrypt a [FolderView] to a [Folder].
|
|
2205
|
-
* @param {FolderView} folder_view
|
|
2206
|
-
* @returns {Folder}
|
|
2207
|
-
*/
|
|
2208
|
-
encrypt(folder_view) {
|
|
2209
|
-
try {
|
|
2210
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2211
|
-
wasm.foldersclient_encrypt(retptr, this.__wbg_ptr, addHeapObject(folder_view));
|
|
2212
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2213
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2214
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2215
|
-
if (r2) {
|
|
2216
|
-
throw takeObject(r1);
|
|
2217
|
-
}
|
|
2218
|
-
return takeObject(r0);
|
|
2219
|
-
} finally {
|
|
2220
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2221
|
-
}
|
|
2222
|
-
}
|
|
2223
|
-
/**
|
|
2224
|
-
* Encrypt a [Folder] to [FolderView].
|
|
2225
|
-
* @param {Folder} folder
|
|
2226
|
-
* @returns {FolderView}
|
|
2227
|
-
*/
|
|
2228
|
-
decrypt(folder) {
|
|
2229
|
-
try {
|
|
2230
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2231
|
-
wasm.foldersclient_decrypt(retptr, this.__wbg_ptr, addHeapObject(folder));
|
|
2232
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2233
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2234
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2235
|
-
if (r2) {
|
|
2236
|
-
throw takeObject(r1);
|
|
2237
|
-
}
|
|
2238
|
-
return takeObject(r0);
|
|
2239
|
-
} finally {
|
|
2240
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2241
|
-
}
|
|
2242
|
-
}
|
|
2243
|
-
/**
|
|
2244
|
-
* Decrypt a list of [Folder]s to a list of [FolderView]s.
|
|
2245
|
-
* @param {Folder[]} folders
|
|
2246
|
-
* @returns {FolderView[]}
|
|
2247
|
-
*/
|
|
2248
|
-
decrypt_list(folders) {
|
|
2249
|
-
try {
|
|
2250
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2251
|
-
const ptr0 = passArrayJsValueToWasm0(folders, wasm.__wbindgen_malloc);
|
|
2252
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2253
|
-
wasm.foldersclient_decrypt_list(retptr, this.__wbg_ptr, ptr0, len0);
|
|
2254
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2255
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2256
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2257
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
2258
|
-
if (r3) {
|
|
2259
|
-
throw takeObject(r2);
|
|
2260
|
-
}
|
|
2261
|
-
var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
|
|
2262
|
-
wasm.__wbindgen_free(r0, r1 * 4, 4);
|
|
2263
|
-
return v2;
|
|
2264
|
-
} finally {
|
|
2265
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2266
|
-
}
|
|
2267
|
-
}
|
|
2268
|
-
/**
|
|
2269
|
-
* Get all folders from state and decrypt them to a list of [FolderView].
|
|
2270
|
-
* @returns {Promise<FolderView[]>}
|
|
2271
|
-
*/
|
|
2272
|
-
list() {
|
|
2273
|
-
const ret = wasm.foldersclient_list(this.__wbg_ptr);
|
|
2274
|
-
return takeObject(ret);
|
|
2275
|
-
}
|
|
2276
|
-
/**
|
|
2277
|
-
* Get a specific [Folder] by its ID from state and decrypt it to a [FolderView].
|
|
2278
|
-
* @param {FolderId} folder_id
|
|
2279
|
-
* @returns {Promise<FolderView>}
|
|
2280
|
-
*/
|
|
2281
|
-
get(folder_id) {
|
|
2282
|
-
const ret = wasm.foldersclient_get(this.__wbg_ptr, addHeapObject(folder_id));
|
|
2283
|
-
return takeObject(ret);
|
|
2284
|
-
}
|
|
2285
|
-
/**
|
|
2286
|
-
* Create a new [Folder] and save it to the server.
|
|
2287
|
-
* @param {FolderAddEditRequest} request
|
|
2288
|
-
* @returns {Promise<FolderView>}
|
|
2289
|
-
*/
|
|
2290
|
-
create(request) {
|
|
2291
|
-
const ret = wasm.foldersclient_create(this.__wbg_ptr, addHeapObject(request));
|
|
2292
|
-
return takeObject(ret);
|
|
2293
|
-
}
|
|
2294
|
-
/**
|
|
2295
|
-
* Edit the [Folder] and save it to the server.
|
|
2296
|
-
* @param {FolderId} folder_id
|
|
2297
|
-
* @param {FolderAddEditRequest} request
|
|
2298
|
-
* @returns {Promise<FolderView>}
|
|
2299
|
-
*/
|
|
2300
|
-
edit(folder_id, request) {
|
|
2301
|
-
const ret = wasm.foldersclient_edit(
|
|
2302
|
-
this.__wbg_ptr,
|
|
2303
|
-
addHeapObject(folder_id),
|
|
2304
|
-
addHeapObject(request),
|
|
2305
|
-
);
|
|
2306
|
-
return takeObject(ret);
|
|
2307
|
-
}
|
|
2308
|
-
}
|
|
2309
|
-
module.exports.FoldersClient = FoldersClient;
|
|
2310
|
-
|
|
2311
|
-
const GeneratorClientFinalization =
|
|
2312
|
-
typeof FinalizationRegistry === "undefined"
|
|
2313
|
-
? { register: () => {}, unregister: () => {} }
|
|
2314
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_generatorclient_free(ptr >>> 0, 1));
|
|
2315
|
-
|
|
2316
|
-
class GeneratorClient {
|
|
2317
|
-
static __wrap(ptr) {
|
|
2318
|
-
ptr = ptr >>> 0;
|
|
2319
|
-
const obj = Object.create(GeneratorClient.prototype);
|
|
2320
|
-
obj.__wbg_ptr = ptr;
|
|
2321
|
-
GeneratorClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
2322
|
-
return obj;
|
|
2323
|
-
}
|
|
2324
|
-
|
|
2325
|
-
__destroy_into_raw() {
|
|
2326
|
-
const ptr = this.__wbg_ptr;
|
|
2327
|
-
this.__wbg_ptr = 0;
|
|
2328
|
-
GeneratorClientFinalization.unregister(this);
|
|
2329
|
-
return ptr;
|
|
2330
|
-
}
|
|
2331
|
-
|
|
2332
|
-
free() {
|
|
2333
|
-
const ptr = this.__destroy_into_raw();
|
|
2334
|
-
wasm.__wbg_generatorclient_free(ptr, 0);
|
|
2335
|
-
}
|
|
2336
|
-
/**
|
|
2337
|
-
* Generates a random password.
|
|
2338
|
-
*
|
|
2339
|
-
* The character sets and password length can be customized using the `input` parameter.
|
|
2340
|
-
*
|
|
2341
|
-
* # Examples
|
|
2342
|
-
*
|
|
2343
|
-
* ```
|
|
2344
|
-
* use bitwarden_core::Client;
|
|
2345
|
-
* use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PasswordGeneratorRequest};
|
|
2346
|
-
*
|
|
2347
|
-
* async fn test() -> Result<(), PassphraseError> {
|
|
2348
|
-
* let input = PasswordGeneratorRequest {
|
|
2349
|
-
* lowercase: true,
|
|
2350
|
-
* uppercase: true,
|
|
2351
|
-
* numbers: true,
|
|
2352
|
-
* length: 20,
|
|
2353
|
-
* ..Default::default()
|
|
2354
|
-
* };
|
|
2355
|
-
* let password = Client::new(None).generator().password(input).unwrap();
|
|
2356
|
-
* println!("{}", password);
|
|
2357
|
-
* Ok(())
|
|
2358
|
-
* }
|
|
2359
|
-
* ```
|
|
2360
|
-
* @param {PasswordGeneratorRequest} input
|
|
2361
|
-
* @returns {string}
|
|
2362
|
-
*/
|
|
2363
|
-
password(input) {
|
|
2364
|
-
let deferred2_0;
|
|
2365
|
-
let deferred2_1;
|
|
2366
|
-
try {
|
|
2367
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2368
|
-
wasm.generatorclient_password(retptr, this.__wbg_ptr, addHeapObject(input));
|
|
2369
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2370
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2371
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2372
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
2373
|
-
var ptr1 = r0;
|
|
2374
|
-
var len1 = r1;
|
|
2375
|
-
if (r3) {
|
|
2376
|
-
ptr1 = 0;
|
|
2377
|
-
len1 = 0;
|
|
2378
|
-
throw takeObject(r2);
|
|
2379
|
-
}
|
|
2380
|
-
deferred2_0 = ptr1;
|
|
2381
|
-
deferred2_1 = len1;
|
|
2382
|
-
return getStringFromWasm0(ptr1, len1);
|
|
2383
|
-
} finally {
|
|
2384
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2385
|
-
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
2386
|
-
}
|
|
2387
|
-
}
|
|
2388
|
-
/**
|
|
2389
|
-
* Generates a random passphrase.
|
|
2390
|
-
* A passphrase is a combination of random words separated by a character.
|
|
2391
|
-
* An example of passphrase is `correct horse battery staple`.
|
|
2392
|
-
*
|
|
2393
|
-
* The number of words and their case, the word separator, and the inclusion of
|
|
2394
|
-
* a number in the passphrase can be customized using the `input` parameter.
|
|
2395
|
-
*
|
|
2396
|
-
* # Examples
|
|
2397
|
-
*
|
|
2398
|
-
* ```
|
|
2399
|
-
* use bitwarden_core::Client;
|
|
2400
|
-
* use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PassphraseGeneratorRequest};
|
|
2401
|
-
*
|
|
2402
|
-
* async fn test() -> Result<(), PassphraseError> {
|
|
2403
|
-
* let input = PassphraseGeneratorRequest {
|
|
2404
|
-
* num_words: 4,
|
|
2405
|
-
* ..Default::default()
|
|
2406
|
-
* };
|
|
2407
|
-
* let passphrase = Client::new(None).generator().passphrase(input).unwrap();
|
|
2408
|
-
* println!("{}", passphrase);
|
|
2409
|
-
* Ok(())
|
|
2410
|
-
* }
|
|
2411
|
-
* ```
|
|
2412
|
-
* @param {PassphraseGeneratorRequest} input
|
|
2413
|
-
* @returns {string}
|
|
2414
|
-
*/
|
|
2415
|
-
passphrase(input) {
|
|
2416
|
-
let deferred2_0;
|
|
2417
|
-
let deferred2_1;
|
|
2418
|
-
try {
|
|
2419
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2420
|
-
wasm.generatorclient_passphrase(retptr, this.__wbg_ptr, addHeapObject(input));
|
|
2421
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2422
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2423
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2424
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
2425
|
-
var ptr1 = r0;
|
|
2426
|
-
var len1 = r1;
|
|
2427
|
-
if (r3) {
|
|
2428
|
-
ptr1 = 0;
|
|
2429
|
-
len1 = 0;
|
|
2430
|
-
throw takeObject(r2);
|
|
2431
|
-
}
|
|
2432
|
-
deferred2_0 = ptr1;
|
|
2433
|
-
deferred2_1 = len1;
|
|
2434
|
-
return getStringFromWasm0(ptr1, len1);
|
|
2435
|
-
} finally {
|
|
2436
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2437
|
-
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
2438
|
-
}
|
|
2439
|
-
}
|
|
2440
|
-
}
|
|
2441
|
-
module.exports.GeneratorClient = GeneratorClient;
|
|
2442
|
-
|
|
2443
|
-
const IncomingMessageFinalization =
|
|
2444
|
-
typeof FinalizationRegistry === "undefined"
|
|
2445
|
-
? { register: () => {}, unregister: () => {} }
|
|
2446
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_incomingmessage_free(ptr >>> 0, 1));
|
|
2447
|
-
|
|
2448
|
-
class IncomingMessage {
|
|
2449
|
-
static __wrap(ptr) {
|
|
2450
|
-
ptr = ptr >>> 0;
|
|
2451
|
-
const obj = Object.create(IncomingMessage.prototype);
|
|
2452
|
-
obj.__wbg_ptr = ptr;
|
|
2453
|
-
IncomingMessageFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
2454
|
-
return obj;
|
|
2455
|
-
}
|
|
2456
|
-
|
|
2457
|
-
__destroy_into_raw() {
|
|
2458
|
-
const ptr = this.__wbg_ptr;
|
|
2459
|
-
this.__wbg_ptr = 0;
|
|
2460
|
-
IncomingMessageFinalization.unregister(this);
|
|
2461
|
-
return ptr;
|
|
2462
|
-
}
|
|
2463
|
-
|
|
2464
|
-
free() {
|
|
2465
|
-
const ptr = this.__destroy_into_raw();
|
|
2466
|
-
wasm.__wbg_incomingmessage_free(ptr, 0);
|
|
2467
|
-
}
|
|
2468
|
-
/**
|
|
2469
|
-
* @returns {Uint8Array}
|
|
2470
|
-
*/
|
|
2471
|
-
get payload() {
|
|
2472
|
-
try {
|
|
2473
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2474
|
-
wasm.__wbg_get_incomingmessage_payload(retptr, this.__wbg_ptr);
|
|
2475
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2476
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2477
|
-
var v1 = getArrayU8FromWasm0(r0, r1).slice();
|
|
2478
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
2479
|
-
return v1;
|
|
2480
|
-
} finally {
|
|
2481
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2482
|
-
}
|
|
2483
|
-
}
|
|
2484
|
-
/**
|
|
2485
|
-
* @param {Uint8Array} arg0
|
|
2486
|
-
*/
|
|
2487
|
-
set payload(arg0) {
|
|
2488
|
-
const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
|
|
2489
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2490
|
-
wasm.__wbg_set_incomingmessage_payload(this.__wbg_ptr, ptr0, len0);
|
|
2491
|
-
}
|
|
2492
|
-
/**
|
|
2493
|
-
* @returns {Endpoint}
|
|
2494
|
-
*/
|
|
2495
|
-
get destination() {
|
|
2496
|
-
const ret = wasm.__wbg_get_incomingmessage_destination(this.__wbg_ptr);
|
|
2497
|
-
return takeObject(ret);
|
|
2498
|
-
}
|
|
2499
|
-
/**
|
|
2500
|
-
* @param {Endpoint} arg0
|
|
2501
|
-
*/
|
|
2502
|
-
set destination(arg0) {
|
|
2503
|
-
wasm.__wbg_set_incomingmessage_destination(this.__wbg_ptr, addHeapObject(arg0));
|
|
2504
|
-
}
|
|
2505
|
-
/**
|
|
2506
|
-
* @returns {Endpoint}
|
|
2507
|
-
*/
|
|
2508
|
-
get source() {
|
|
2509
|
-
const ret = wasm.__wbg_get_incomingmessage_source(this.__wbg_ptr);
|
|
2510
|
-
return takeObject(ret);
|
|
2511
|
-
}
|
|
2512
|
-
/**
|
|
2513
|
-
* @param {Endpoint} arg0
|
|
2514
|
-
*/
|
|
2515
|
-
set source(arg0) {
|
|
2516
|
-
wasm.__wbg_set_incomingmessage_source(this.__wbg_ptr, addHeapObject(arg0));
|
|
2517
|
-
}
|
|
2518
|
-
/**
|
|
2519
|
-
* @returns {string | undefined}
|
|
2520
|
-
*/
|
|
2521
|
-
get topic() {
|
|
2522
|
-
try {
|
|
2523
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2524
|
-
wasm.__wbg_get_incomingmessage_topic(retptr, this.__wbg_ptr);
|
|
2525
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2526
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2527
|
-
let v1;
|
|
2528
|
-
if (r0 !== 0) {
|
|
2529
|
-
v1 = getStringFromWasm0(r0, r1).slice();
|
|
2530
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
2531
|
-
}
|
|
2532
|
-
return v1;
|
|
2533
|
-
} finally {
|
|
2534
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2535
|
-
}
|
|
2536
|
-
}
|
|
2537
|
-
/**
|
|
2538
|
-
* @param {string | null} [arg0]
|
|
2539
|
-
*/
|
|
2540
|
-
set topic(arg0) {
|
|
2541
|
-
var ptr0 = isLikeNone(arg0)
|
|
2542
|
-
? 0
|
|
2543
|
-
: passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2544
|
-
var len0 = WASM_VECTOR_LEN;
|
|
2545
|
-
wasm.__wbg_set_incomingmessage_topic(this.__wbg_ptr, ptr0, len0);
|
|
2546
|
-
}
|
|
2547
|
-
/**
|
|
2548
|
-
* @param {Uint8Array} payload
|
|
2549
|
-
* @param {Endpoint} destination
|
|
2550
|
-
* @param {Endpoint} source
|
|
2551
|
-
* @param {string | null} [topic]
|
|
2552
|
-
*/
|
|
2553
|
-
constructor(payload, destination, source, topic) {
|
|
2554
|
-
const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
|
|
2555
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2556
|
-
var ptr1 = isLikeNone(topic)
|
|
2557
|
-
? 0
|
|
2558
|
-
: passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2559
|
-
var len1 = WASM_VECTOR_LEN;
|
|
2560
|
-
const ret = wasm.incomingmessage_new(
|
|
2561
|
-
ptr0,
|
|
2562
|
-
len0,
|
|
2563
|
-
addHeapObject(destination),
|
|
2564
|
-
addHeapObject(source),
|
|
2565
|
-
ptr1,
|
|
2566
|
-
len1,
|
|
2567
|
-
);
|
|
2568
|
-
this.__wbg_ptr = ret >>> 0;
|
|
2569
|
-
IncomingMessageFinalization.register(this, this.__wbg_ptr, this);
|
|
2570
|
-
return this;
|
|
2571
|
-
}
|
|
2572
|
-
/**
|
|
2573
|
-
* Try to parse the payload as JSON.
|
|
2574
|
-
* @returns {any} The parsed JSON value, or undefined if the payload is not valid JSON.
|
|
2575
|
-
*/
|
|
2576
|
-
parse_payload_as_json() {
|
|
2577
|
-
const ret = wasm.incomingmessage_parse_payload_as_json(this.__wbg_ptr);
|
|
2578
|
-
return takeObject(ret);
|
|
2579
|
-
}
|
|
2580
|
-
}
|
|
2581
|
-
module.exports.IncomingMessage = IncomingMessage;
|
|
2582
|
-
|
|
2583
|
-
const IpcClientFinalization =
|
|
2584
|
-
typeof FinalizationRegistry === "undefined"
|
|
2585
|
-
? { register: () => {}, unregister: () => {} }
|
|
2586
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_ipcclient_free(ptr >>> 0, 1));
|
|
2587
|
-
/**
|
|
2588
|
-
* JavaScript wrapper around the IPC client. For more information, see the
|
|
2589
|
-
* [IpcClient] documentation.
|
|
2590
|
-
*/
|
|
2591
|
-
class IpcClient {
|
|
2592
|
-
__destroy_into_raw() {
|
|
2593
|
-
const ptr = this.__wbg_ptr;
|
|
2594
|
-
this.__wbg_ptr = 0;
|
|
2595
|
-
IpcClientFinalization.unregister(this);
|
|
2596
|
-
return ptr;
|
|
2597
|
-
}
|
|
2598
|
-
|
|
2599
|
-
free() {
|
|
2600
|
-
const ptr = this.__destroy_into_raw();
|
|
2601
|
-
wasm.__wbg_ipcclient_free(ptr, 0);
|
|
2602
|
-
}
|
|
2603
|
-
/**
|
|
2604
|
-
* @param {IpcCommunicationBackend} communication_provider
|
|
2605
|
-
*/
|
|
2606
|
-
constructor(communication_provider) {
|
|
2607
|
-
_assertClass(communication_provider, IpcCommunicationBackend);
|
|
2608
|
-
const ret = wasm.ipcclient_new(communication_provider.__wbg_ptr);
|
|
2609
|
-
this.__wbg_ptr = ret >>> 0;
|
|
2610
|
-
IpcClientFinalization.register(this, this.__wbg_ptr, this);
|
|
2611
|
-
return this;
|
|
2612
|
-
}
|
|
2613
|
-
/**
|
|
2614
|
-
* @returns {Promise<void>}
|
|
2615
|
-
*/
|
|
2616
|
-
start() {
|
|
2617
|
-
const ret = wasm.ipcclient_start(this.__wbg_ptr);
|
|
2618
|
-
return takeObject(ret);
|
|
2619
|
-
}
|
|
2620
|
-
/**
|
|
2621
|
-
* @returns {Promise<boolean>}
|
|
2622
|
-
*/
|
|
2623
|
-
isRunning() {
|
|
2624
|
-
const ret = wasm.ipcclient_isRunning(this.__wbg_ptr);
|
|
2625
|
-
return takeObject(ret);
|
|
2626
|
-
}
|
|
2627
|
-
/**
|
|
2628
|
-
* @param {OutgoingMessage} message
|
|
2629
|
-
* @returns {Promise<void>}
|
|
2630
|
-
*/
|
|
2631
|
-
send(message) {
|
|
2632
|
-
_assertClass(message, OutgoingMessage);
|
|
2633
|
-
var ptr0 = message.__destroy_into_raw();
|
|
2634
|
-
const ret = wasm.ipcclient_send(this.__wbg_ptr, ptr0);
|
|
2635
|
-
return takeObject(ret);
|
|
2636
|
-
}
|
|
2637
|
-
/**
|
|
2638
|
-
* @returns {Promise<IpcClientSubscription>}
|
|
2639
|
-
*/
|
|
2640
|
-
subscribe() {
|
|
2641
|
-
const ret = wasm.ipcclient_subscribe(this.__wbg_ptr);
|
|
2642
|
-
return takeObject(ret);
|
|
2643
|
-
}
|
|
2644
|
-
}
|
|
2645
|
-
module.exports.IpcClient = IpcClient;
|
|
2646
|
-
|
|
2647
|
-
const IpcClientSubscriptionFinalization =
|
|
2648
|
-
typeof FinalizationRegistry === "undefined"
|
|
2649
|
-
? { register: () => {}, unregister: () => {} }
|
|
2650
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_ipcclientsubscription_free(ptr >>> 0, 1));
|
|
2651
|
-
/**
|
|
2652
|
-
* JavaScript wrapper around the IPC client subscription. For more information, see the
|
|
2653
|
-
* [IpcClientSubscription](crate::IpcClientSubscription) documentation.
|
|
2654
|
-
*/
|
|
2655
|
-
class IpcClientSubscription {
|
|
2656
|
-
static __wrap(ptr) {
|
|
2657
|
-
ptr = ptr >>> 0;
|
|
2658
|
-
const obj = Object.create(IpcClientSubscription.prototype);
|
|
2659
|
-
obj.__wbg_ptr = ptr;
|
|
2660
|
-
IpcClientSubscriptionFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
2661
|
-
return obj;
|
|
2662
|
-
}
|
|
2663
|
-
|
|
2664
|
-
__destroy_into_raw() {
|
|
2665
|
-
const ptr = this.__wbg_ptr;
|
|
2666
|
-
this.__wbg_ptr = 0;
|
|
2667
|
-
IpcClientSubscriptionFinalization.unregister(this);
|
|
2668
|
-
return ptr;
|
|
2669
|
-
}
|
|
2670
|
-
|
|
2671
|
-
free() {
|
|
2672
|
-
const ptr = this.__destroy_into_raw();
|
|
2673
|
-
wasm.__wbg_ipcclientsubscription_free(ptr, 0);
|
|
2674
|
-
}
|
|
2675
|
-
/**
|
|
2676
|
-
* @param {AbortSignal | null} [abort_signal]
|
|
2677
|
-
* @returns {Promise<IncomingMessage>}
|
|
2678
|
-
*/
|
|
2679
|
-
receive(abort_signal) {
|
|
2680
|
-
const ret = wasm.ipcclientsubscription_receive(
|
|
2681
|
-
this.__wbg_ptr,
|
|
2682
|
-
isLikeNone(abort_signal) ? 0 : addHeapObject(abort_signal),
|
|
2683
|
-
);
|
|
2684
|
-
return takeObject(ret);
|
|
2685
|
-
}
|
|
2686
|
-
}
|
|
2687
|
-
module.exports.IpcClientSubscription = IpcClientSubscription;
|
|
2688
|
-
|
|
2689
|
-
const IpcCommunicationBackendFinalization =
|
|
2690
|
-
typeof FinalizationRegistry === "undefined"
|
|
2691
|
-
? { register: () => {}, unregister: () => {} }
|
|
2692
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_ipccommunicationbackend_free(ptr >>> 0, 1));
|
|
2693
|
-
/**
|
|
2694
|
-
* JavaScript implementation of the `CommunicationBackend` trait for IPC communication.
|
|
2695
|
-
*/
|
|
2696
|
-
class IpcCommunicationBackend {
|
|
2697
|
-
__destroy_into_raw() {
|
|
2698
|
-
const ptr = this.__wbg_ptr;
|
|
2699
|
-
this.__wbg_ptr = 0;
|
|
2700
|
-
IpcCommunicationBackendFinalization.unregister(this);
|
|
2701
|
-
return ptr;
|
|
2702
|
-
}
|
|
2703
|
-
|
|
2704
|
-
free() {
|
|
2705
|
-
const ptr = this.__destroy_into_raw();
|
|
2706
|
-
wasm.__wbg_ipccommunicationbackend_free(ptr, 0);
|
|
2707
|
-
}
|
|
2708
|
-
/**
|
|
2709
|
-
* Creates a new instance of the JavaScript communication backend.
|
|
2710
|
-
* @param {IpcCommunicationBackendSender} sender
|
|
2711
|
-
*/
|
|
2712
|
-
constructor(sender) {
|
|
2713
|
-
const ret = wasm.ipccommunicationbackend_new(addHeapObject(sender));
|
|
2714
|
-
this.__wbg_ptr = ret >>> 0;
|
|
2715
|
-
IpcCommunicationBackendFinalization.register(this, this.__wbg_ptr, this);
|
|
2716
|
-
return this;
|
|
2717
|
-
}
|
|
2718
|
-
/**
|
|
2719
|
-
* Used by JavaScript to provide an incoming message to the IPC framework.
|
|
2720
|
-
* @param {IncomingMessage} message
|
|
2721
|
-
*/
|
|
2722
|
-
receive(message) {
|
|
2723
|
-
try {
|
|
2724
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2725
|
-
_assertClass(message, IncomingMessage);
|
|
2726
|
-
var ptr0 = message.__destroy_into_raw();
|
|
2727
|
-
wasm.ipccommunicationbackend_receive(retptr, this.__wbg_ptr, ptr0);
|
|
2728
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2729
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2730
|
-
if (r1) {
|
|
2731
|
-
throw takeObject(r0);
|
|
2732
|
-
}
|
|
2733
|
-
} finally {
|
|
2734
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2735
|
-
}
|
|
2736
|
-
}
|
|
2737
|
-
}
|
|
2738
|
-
module.exports.IpcCommunicationBackend = IpcCommunicationBackend;
|
|
2739
|
-
|
|
2740
|
-
const OutgoingMessageFinalization =
|
|
2741
|
-
typeof FinalizationRegistry === "undefined"
|
|
2742
|
-
? { register: () => {}, unregister: () => {} }
|
|
2743
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_outgoingmessage_free(ptr >>> 0, 1));
|
|
2744
|
-
|
|
2745
|
-
class OutgoingMessage {
|
|
2746
|
-
static __wrap(ptr) {
|
|
2747
|
-
ptr = ptr >>> 0;
|
|
2748
|
-
const obj = Object.create(OutgoingMessage.prototype);
|
|
2749
|
-
obj.__wbg_ptr = ptr;
|
|
2750
|
-
OutgoingMessageFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
2751
|
-
return obj;
|
|
2752
|
-
}
|
|
2753
|
-
|
|
2754
|
-
__destroy_into_raw() {
|
|
2755
|
-
const ptr = this.__wbg_ptr;
|
|
2756
|
-
this.__wbg_ptr = 0;
|
|
2757
|
-
OutgoingMessageFinalization.unregister(this);
|
|
2758
|
-
return ptr;
|
|
2759
|
-
}
|
|
2760
|
-
|
|
2761
|
-
free() {
|
|
2762
|
-
const ptr = this.__destroy_into_raw();
|
|
2763
|
-
wasm.__wbg_outgoingmessage_free(ptr, 0);
|
|
2764
|
-
}
|
|
2765
|
-
/**
|
|
2766
|
-
* @returns {Uint8Array}
|
|
2767
|
-
*/
|
|
2768
|
-
get payload() {
|
|
2769
|
-
try {
|
|
2770
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2771
|
-
wasm.__wbg_get_outgoingmessage_payload(retptr, this.__wbg_ptr);
|
|
2772
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2773
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2774
|
-
var v1 = getArrayU8FromWasm0(r0, r1).slice();
|
|
2775
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
2776
|
-
return v1;
|
|
2777
|
-
} finally {
|
|
2778
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2779
|
-
}
|
|
2780
|
-
}
|
|
2781
|
-
/**
|
|
2782
|
-
* @param {Uint8Array} arg0
|
|
2783
|
-
*/
|
|
2784
|
-
set payload(arg0) {
|
|
2785
|
-
const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
|
|
2786
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2787
|
-
wasm.__wbg_set_outgoingmessage_payload(this.__wbg_ptr, ptr0, len0);
|
|
2788
|
-
}
|
|
2789
|
-
/**
|
|
2790
|
-
* @returns {Endpoint}
|
|
2791
|
-
*/
|
|
2792
|
-
get destination() {
|
|
2793
|
-
const ret = wasm.__wbg_get_incomingmessage_destination(this.__wbg_ptr);
|
|
2794
|
-
return takeObject(ret);
|
|
2795
|
-
}
|
|
2796
|
-
/**
|
|
2797
|
-
* @param {Endpoint} arg0
|
|
2798
|
-
*/
|
|
2799
|
-
set destination(arg0) {
|
|
2800
|
-
wasm.__wbg_set_incomingmessage_destination(this.__wbg_ptr, addHeapObject(arg0));
|
|
2801
|
-
}
|
|
2802
|
-
/**
|
|
2803
|
-
* @returns {string | undefined}
|
|
2804
|
-
*/
|
|
2805
|
-
get topic() {
|
|
2806
|
-
try {
|
|
2807
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2808
|
-
wasm.__wbg_get_outgoingmessage_topic(retptr, this.__wbg_ptr);
|
|
2809
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2810
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2811
|
-
let v1;
|
|
2812
|
-
if (r0 !== 0) {
|
|
2813
|
-
v1 = getStringFromWasm0(r0, r1).slice();
|
|
2814
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
2815
|
-
}
|
|
2816
|
-
return v1;
|
|
2817
|
-
} finally {
|
|
2818
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2819
|
-
}
|
|
2820
|
-
}
|
|
2821
|
-
/**
|
|
2822
|
-
* @param {string | null} [arg0]
|
|
2823
|
-
*/
|
|
2824
|
-
set topic(arg0) {
|
|
2825
|
-
var ptr0 = isLikeNone(arg0)
|
|
2826
|
-
? 0
|
|
2827
|
-
: passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2828
|
-
var len0 = WASM_VECTOR_LEN;
|
|
2829
|
-
wasm.__wbg_set_outgoingmessage_topic(this.__wbg_ptr, ptr0, len0);
|
|
2830
|
-
}
|
|
2831
|
-
/**
|
|
2832
|
-
* @param {Uint8Array} payload
|
|
2833
|
-
* @param {Endpoint} destination
|
|
2834
|
-
* @param {string | null} [topic]
|
|
2835
|
-
*/
|
|
2836
|
-
constructor(payload, destination, topic) {
|
|
2837
|
-
const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
|
|
2838
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2839
|
-
var ptr1 = isLikeNone(topic)
|
|
2840
|
-
? 0
|
|
2841
|
-
: passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2842
|
-
var len1 = WASM_VECTOR_LEN;
|
|
2843
|
-
const ret = wasm.outgoingmessage_new(ptr0, len0, addHeapObject(destination), ptr1, len1);
|
|
2844
|
-
this.__wbg_ptr = ret >>> 0;
|
|
2845
|
-
OutgoingMessageFinalization.register(this, this.__wbg_ptr, this);
|
|
2846
|
-
return this;
|
|
2847
|
-
}
|
|
2848
|
-
/**
|
|
2849
|
-
* Create a new message and encode the payload as JSON.
|
|
2850
|
-
* @param {any} payload
|
|
2851
|
-
* @param {Endpoint} destination
|
|
2852
|
-
* @param {string | null} [topic]
|
|
2853
|
-
* @returns {OutgoingMessage}
|
|
2854
|
-
*/
|
|
2855
|
-
static new_json_payload(payload, destination, topic) {
|
|
2856
|
-
try {
|
|
2857
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2858
|
-
var ptr0 = isLikeNone(topic)
|
|
2859
|
-
? 0
|
|
2860
|
-
: passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2861
|
-
var len0 = WASM_VECTOR_LEN;
|
|
2862
|
-
wasm.outgoingmessage_new_json_payload(
|
|
2863
|
-
retptr,
|
|
2864
|
-
addHeapObject(payload),
|
|
2865
|
-
addHeapObject(destination),
|
|
2866
|
-
ptr0,
|
|
2867
|
-
len0,
|
|
2868
|
-
);
|
|
2869
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2870
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2871
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2872
|
-
if (r2) {
|
|
2873
|
-
throw takeObject(r1);
|
|
2874
|
-
}
|
|
2875
|
-
return OutgoingMessage.__wrap(r0);
|
|
2876
|
-
} finally {
|
|
2877
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2878
|
-
}
|
|
2879
|
-
}
|
|
2880
|
-
}
|
|
2881
|
-
module.exports.OutgoingMessage = OutgoingMessage;
|
|
2882
|
-
|
|
2883
|
-
const PlatformClientFinalization =
|
|
2884
|
-
typeof FinalizationRegistry === "undefined"
|
|
2885
|
-
? { register: () => {}, unregister: () => {} }
|
|
2886
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_platformclient_free(ptr >>> 0, 1));
|
|
2887
|
-
|
|
2888
|
-
class PlatformClient {
|
|
2889
|
-
static __wrap(ptr) {
|
|
2890
|
-
ptr = ptr >>> 0;
|
|
2891
|
-
const obj = Object.create(PlatformClient.prototype);
|
|
2892
|
-
obj.__wbg_ptr = ptr;
|
|
2893
|
-
PlatformClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
2894
|
-
return obj;
|
|
2895
|
-
}
|
|
2896
|
-
|
|
2897
|
-
__destroy_into_raw() {
|
|
2898
|
-
const ptr = this.__wbg_ptr;
|
|
2899
|
-
this.__wbg_ptr = 0;
|
|
2900
|
-
PlatformClientFinalization.unregister(this);
|
|
2901
|
-
return ptr;
|
|
2902
|
-
}
|
|
2903
|
-
|
|
2904
|
-
free() {
|
|
2905
|
-
const ptr = this.__destroy_into_raw();
|
|
2906
|
-
wasm.__wbg_platformclient_free(ptr, 0);
|
|
2907
|
-
}
|
|
2908
|
-
/**
|
|
2909
|
-
* @returns {StateClient}
|
|
2910
|
-
*/
|
|
2911
|
-
state() {
|
|
2912
|
-
const ret = wasm.bitwardenclient_platform(this.__wbg_ptr);
|
|
2913
|
-
return StateClient.__wrap(ret);
|
|
2914
|
-
}
|
|
2915
|
-
/**
|
|
2916
|
-
* Load feature flags into the client
|
|
2917
|
-
* @param {FeatureFlags} flags
|
|
2918
|
-
*/
|
|
2919
|
-
load_flags(flags) {
|
|
2920
|
-
try {
|
|
2921
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2922
|
-
wasm.platformclient_load_flags(retptr, this.__wbg_ptr, addHeapObject(flags));
|
|
2923
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2924
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2925
|
-
if (r1) {
|
|
2926
|
-
throw takeObject(r0);
|
|
2927
|
-
}
|
|
2928
|
-
} finally {
|
|
2929
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2930
|
-
}
|
|
2931
|
-
}
|
|
2932
|
-
}
|
|
2933
|
-
module.exports.PlatformClient = PlatformClient;
|
|
2934
|
-
|
|
2935
|
-
const PureCryptoFinalization =
|
|
2936
|
-
typeof FinalizationRegistry === "undefined"
|
|
2937
|
-
? { register: () => {}, unregister: () => {} }
|
|
2938
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_purecrypto_free(ptr >>> 0, 1));
|
|
2939
|
-
/**
|
|
2940
|
-
* This module represents a stopgap solution to provide access to primitive crypto functions for JS
|
|
2941
|
-
* clients. It is not intended to be used outside of the JS clients and this pattern should not be
|
|
2942
|
-
* proliferated. It is necessary because we want to use SDK crypto prior to the SDK being fully
|
|
2943
|
-
* responsible for state and keys.
|
|
2944
|
-
*/
|
|
2945
|
-
class PureCrypto {
|
|
2946
|
-
__destroy_into_raw() {
|
|
2947
|
-
const ptr = this.__wbg_ptr;
|
|
2948
|
-
this.__wbg_ptr = 0;
|
|
2949
|
-
PureCryptoFinalization.unregister(this);
|
|
2950
|
-
return ptr;
|
|
2951
|
-
}
|
|
2952
|
-
|
|
2953
|
-
free() {
|
|
2954
|
-
const ptr = this.__destroy_into_raw();
|
|
2955
|
-
wasm.__wbg_purecrypto_free(ptr, 0);
|
|
2956
|
-
}
|
|
2957
|
-
/**
|
|
2958
|
-
* DEPRECATED: Use `symmetric_decrypt_string` instead.
|
|
2959
|
-
* Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
|
|
2960
|
-
* @param {string} enc_string
|
|
2961
|
-
* @param {Uint8Array} key
|
|
2962
|
-
* @returns {string}
|
|
2963
|
-
*/
|
|
2964
|
-
static symmetric_decrypt(enc_string, key) {
|
|
2965
|
-
let deferred4_0;
|
|
2966
|
-
let deferred4_1;
|
|
2967
|
-
try {
|
|
2968
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
2969
|
-
const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2970
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2971
|
-
const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
2972
|
-
const len1 = WASM_VECTOR_LEN;
|
|
2973
|
-
wasm.purecrypto_symmetric_decrypt(retptr, ptr0, len0, ptr1, len1);
|
|
2974
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
2975
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
2976
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
2977
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
2978
|
-
var ptr3 = r0;
|
|
2979
|
-
var len3 = r1;
|
|
2980
|
-
if (r3) {
|
|
2981
|
-
ptr3 = 0;
|
|
2982
|
-
len3 = 0;
|
|
2983
|
-
throw takeObject(r2);
|
|
2984
|
-
}
|
|
2985
|
-
deferred4_0 = ptr3;
|
|
2986
|
-
deferred4_1 = len3;
|
|
2987
|
-
return getStringFromWasm0(ptr3, len3);
|
|
2988
|
-
} finally {
|
|
2989
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
2990
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2991
|
-
}
|
|
2992
|
-
}
|
|
2993
|
-
/**
|
|
2994
|
-
* @param {string} enc_string
|
|
2995
|
-
* @param {Uint8Array} key
|
|
2996
|
-
* @returns {string}
|
|
2997
|
-
*/
|
|
2998
|
-
static symmetric_decrypt_string(enc_string, key) {
|
|
2999
|
-
let deferred4_0;
|
|
3000
|
-
let deferred4_1;
|
|
3001
|
-
try {
|
|
3002
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3003
|
-
const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3004
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3005
|
-
const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
3006
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3007
|
-
wasm.purecrypto_symmetric_decrypt_string(retptr, ptr0, len0, ptr1, len1);
|
|
3008
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3009
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3010
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3011
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3012
|
-
var ptr3 = r0;
|
|
3013
|
-
var len3 = r1;
|
|
3014
|
-
if (r3) {
|
|
3015
|
-
ptr3 = 0;
|
|
3016
|
-
len3 = 0;
|
|
3017
|
-
throw takeObject(r2);
|
|
3018
|
-
}
|
|
3019
|
-
deferred4_0 = ptr3;
|
|
3020
|
-
deferred4_1 = len3;
|
|
3021
|
-
return getStringFromWasm0(ptr3, len3);
|
|
3022
|
-
} finally {
|
|
3023
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3024
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3025
|
-
}
|
|
3026
|
-
}
|
|
3027
|
-
/**
|
|
3028
|
-
* @param {string} enc_string
|
|
3029
|
-
* @param {Uint8Array} key
|
|
3030
|
-
* @returns {Uint8Array}
|
|
3031
|
-
*/
|
|
3032
|
-
static symmetric_decrypt_bytes(enc_string, key) {
|
|
3033
|
-
try {
|
|
3034
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3035
|
-
const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3036
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3037
|
-
const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
3038
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3039
|
-
wasm.purecrypto_symmetric_decrypt_bytes(retptr, ptr0, len0, ptr1, len1);
|
|
3040
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3041
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3042
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3043
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3044
|
-
if (r3) {
|
|
3045
|
-
throw takeObject(r2);
|
|
3046
|
-
}
|
|
3047
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3048
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3049
|
-
return v3;
|
|
3050
|
-
} finally {
|
|
3051
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3052
|
-
}
|
|
3053
|
-
}
|
|
3054
|
-
/**
|
|
3055
|
-
* DEPRECATED: Use `symmetric_decrypt_filedata` instead.
|
|
3056
|
-
* Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
|
|
3057
|
-
* @param {Uint8Array} enc_bytes
|
|
3058
|
-
* @param {Uint8Array} key
|
|
3059
|
-
* @returns {Uint8Array}
|
|
3060
|
-
*/
|
|
3061
|
-
static symmetric_decrypt_array_buffer(enc_bytes, key) {
|
|
3062
|
-
try {
|
|
3063
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3064
|
-
const ptr0 = passArray8ToWasm0(enc_bytes, wasm.__wbindgen_malloc);
|
|
3065
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3066
|
-
const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
3067
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3068
|
-
wasm.purecrypto_symmetric_decrypt_array_buffer(retptr, ptr0, len0, ptr1, len1);
|
|
3069
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3070
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3071
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3072
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3073
|
-
if (r3) {
|
|
3074
|
-
throw takeObject(r2);
|
|
3075
|
-
}
|
|
3076
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3077
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3078
|
-
return v3;
|
|
3079
|
-
} finally {
|
|
3080
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3081
|
-
}
|
|
3082
|
-
}
|
|
3083
|
-
/**
|
|
3084
|
-
* @param {Uint8Array} enc_bytes
|
|
3085
|
-
* @param {Uint8Array} key
|
|
3086
|
-
* @returns {Uint8Array}
|
|
3087
|
-
*/
|
|
3088
|
-
static symmetric_decrypt_filedata(enc_bytes, key) {
|
|
3089
|
-
try {
|
|
3090
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3091
|
-
const ptr0 = passArray8ToWasm0(enc_bytes, wasm.__wbindgen_malloc);
|
|
3092
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3093
|
-
const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
3094
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3095
|
-
wasm.purecrypto_symmetric_decrypt_filedata(retptr, ptr0, len0, ptr1, len1);
|
|
3096
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3097
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3098
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3099
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3100
|
-
if (r3) {
|
|
3101
|
-
throw takeObject(r2);
|
|
3102
|
-
}
|
|
3103
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3104
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3105
|
-
return v3;
|
|
3106
|
-
} finally {
|
|
3107
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3108
|
-
}
|
|
3109
|
-
}
|
|
3110
|
-
/**
|
|
3111
|
-
* @param {string} plain
|
|
3112
|
-
* @param {Uint8Array} key
|
|
3113
|
-
* @returns {string}
|
|
3114
|
-
*/
|
|
3115
|
-
static symmetric_encrypt_string(plain, key) {
|
|
3116
|
-
let deferred4_0;
|
|
3117
|
-
let deferred4_1;
|
|
3118
|
-
try {
|
|
3119
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3120
|
-
const ptr0 = passStringToWasm0(plain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3121
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3122
|
-
const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
3123
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3124
|
-
wasm.purecrypto_symmetric_encrypt_string(retptr, ptr0, len0, ptr1, len1);
|
|
3125
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3126
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3127
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3128
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3129
|
-
var ptr3 = r0;
|
|
3130
|
-
var len3 = r1;
|
|
3131
|
-
if (r3) {
|
|
3132
|
-
ptr3 = 0;
|
|
3133
|
-
len3 = 0;
|
|
3134
|
-
throw takeObject(r2);
|
|
3135
|
-
}
|
|
3136
|
-
deferred4_0 = ptr3;
|
|
3137
|
-
deferred4_1 = len3;
|
|
3138
|
-
return getStringFromWasm0(ptr3, len3);
|
|
3139
|
-
} finally {
|
|
3140
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3141
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3142
|
-
}
|
|
3143
|
-
}
|
|
3144
|
-
/**
|
|
3145
|
-
* DEPRECATED: Only used by send keys
|
|
3146
|
-
* @param {Uint8Array} plain
|
|
3147
|
-
* @param {Uint8Array} key
|
|
3148
|
-
* @returns {string}
|
|
3149
|
-
*/
|
|
3150
|
-
static symmetric_encrypt_bytes(plain, key) {
|
|
3151
|
-
let deferred4_0;
|
|
3152
|
-
let deferred4_1;
|
|
3153
|
-
try {
|
|
3154
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3155
|
-
const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
|
|
3156
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3157
|
-
const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
3158
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3159
|
-
wasm.purecrypto_symmetric_encrypt_bytes(retptr, ptr0, len0, ptr1, len1);
|
|
3160
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3161
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3162
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3163
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3164
|
-
var ptr3 = r0;
|
|
3165
|
-
var len3 = r1;
|
|
3166
|
-
if (r3) {
|
|
3167
|
-
ptr3 = 0;
|
|
3168
|
-
len3 = 0;
|
|
3169
|
-
throw takeObject(r2);
|
|
3170
|
-
}
|
|
3171
|
-
deferred4_0 = ptr3;
|
|
3172
|
-
deferred4_1 = len3;
|
|
3173
|
-
return getStringFromWasm0(ptr3, len3);
|
|
3174
|
-
} finally {
|
|
3175
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3176
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3177
|
-
}
|
|
3178
|
-
}
|
|
3179
|
-
/**
|
|
3180
|
-
* @param {Uint8Array} plain
|
|
3181
|
-
* @param {Uint8Array} key
|
|
3182
|
-
* @returns {Uint8Array}
|
|
3183
|
-
*/
|
|
3184
|
-
static symmetric_encrypt_filedata(plain, key) {
|
|
3185
|
-
try {
|
|
3186
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3187
|
-
const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
|
|
3188
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3189
|
-
const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
3190
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3191
|
-
wasm.purecrypto_symmetric_encrypt_filedata(retptr, ptr0, len0, ptr1, len1);
|
|
3192
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3193
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3194
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3195
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3196
|
-
if (r3) {
|
|
3197
|
-
throw takeObject(r2);
|
|
3198
|
-
}
|
|
3199
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3200
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3201
|
-
return v3;
|
|
3202
|
-
} finally {
|
|
3203
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3204
|
-
}
|
|
3205
|
-
}
|
|
3206
|
-
/**
|
|
3207
|
-
* @param {string} encrypted_user_key
|
|
3208
|
-
* @param {string} master_password
|
|
3209
|
-
* @param {string} email
|
|
3210
|
-
* @param {Kdf} kdf
|
|
3211
|
-
* @returns {Uint8Array}
|
|
3212
|
-
*/
|
|
3213
|
-
static decrypt_user_key_with_master_password(encrypted_user_key, master_password, email, kdf) {
|
|
3214
|
-
try {
|
|
3215
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3216
|
-
const ptr0 = passStringToWasm0(
|
|
3217
|
-
encrypted_user_key,
|
|
3218
|
-
wasm.__wbindgen_malloc,
|
|
3219
|
-
wasm.__wbindgen_realloc,
|
|
3220
|
-
);
|
|
3221
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3222
|
-
const ptr1 = passStringToWasm0(
|
|
3223
|
-
master_password,
|
|
3224
|
-
wasm.__wbindgen_malloc,
|
|
3225
|
-
wasm.__wbindgen_realloc,
|
|
3226
|
-
);
|
|
3227
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3228
|
-
const ptr2 = passStringToWasm0(email, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3229
|
-
const len2 = WASM_VECTOR_LEN;
|
|
3230
|
-
wasm.purecrypto_decrypt_user_key_with_master_password(
|
|
3231
|
-
retptr,
|
|
3232
|
-
ptr0,
|
|
3233
|
-
len0,
|
|
3234
|
-
ptr1,
|
|
3235
|
-
len1,
|
|
3236
|
-
ptr2,
|
|
3237
|
-
len2,
|
|
3238
|
-
addHeapObject(kdf),
|
|
3239
|
-
);
|
|
3240
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3241
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3242
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3243
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3244
|
-
if (r3) {
|
|
3245
|
-
throw takeObject(r2);
|
|
3246
|
-
}
|
|
3247
|
-
var v4 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3248
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3249
|
-
return v4;
|
|
3250
|
-
} finally {
|
|
3251
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3252
|
-
}
|
|
3253
|
-
}
|
|
3254
|
-
/**
|
|
3255
|
-
* @param {Uint8Array} user_key
|
|
3256
|
-
* @param {string} master_password
|
|
3257
|
-
* @param {string} email
|
|
3258
|
-
* @param {Kdf} kdf
|
|
3259
|
-
* @returns {string}
|
|
3260
|
-
*/
|
|
3261
|
-
static encrypt_user_key_with_master_password(user_key, master_password, email, kdf) {
|
|
3262
|
-
let deferred5_0;
|
|
3263
|
-
let deferred5_1;
|
|
3264
|
-
try {
|
|
3265
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3266
|
-
const ptr0 = passArray8ToWasm0(user_key, wasm.__wbindgen_malloc);
|
|
3267
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3268
|
-
const ptr1 = passStringToWasm0(
|
|
3269
|
-
master_password,
|
|
3270
|
-
wasm.__wbindgen_malloc,
|
|
3271
|
-
wasm.__wbindgen_realloc,
|
|
3272
|
-
);
|
|
3273
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3274
|
-
const ptr2 = passStringToWasm0(email, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3275
|
-
const len2 = WASM_VECTOR_LEN;
|
|
3276
|
-
wasm.purecrypto_encrypt_user_key_with_master_password(
|
|
3277
|
-
retptr,
|
|
3278
|
-
ptr0,
|
|
3279
|
-
len0,
|
|
3280
|
-
ptr1,
|
|
3281
|
-
len1,
|
|
3282
|
-
ptr2,
|
|
3283
|
-
len2,
|
|
3284
|
-
addHeapObject(kdf),
|
|
3285
|
-
);
|
|
3286
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3287
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3288
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3289
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3290
|
-
var ptr4 = r0;
|
|
3291
|
-
var len4 = r1;
|
|
3292
|
-
if (r3) {
|
|
3293
|
-
ptr4 = 0;
|
|
3294
|
-
len4 = 0;
|
|
3295
|
-
throw takeObject(r2);
|
|
3296
|
-
}
|
|
3297
|
-
deferred5_0 = ptr4;
|
|
3298
|
-
deferred5_1 = len4;
|
|
3299
|
-
return getStringFromWasm0(ptr4, len4);
|
|
3300
|
-
} finally {
|
|
3301
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3302
|
-
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
3303
|
-
}
|
|
3304
|
-
}
|
|
3305
|
-
/**
|
|
3306
|
-
* @returns {Uint8Array}
|
|
3307
|
-
*/
|
|
3308
|
-
static make_user_key_aes256_cbc_hmac() {
|
|
3309
|
-
try {
|
|
3310
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3311
|
-
wasm.purecrypto_make_user_key_aes256_cbc_hmac(retptr);
|
|
3312
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3313
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3314
|
-
var v1 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3315
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3316
|
-
return v1;
|
|
3317
|
-
} finally {
|
|
3318
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3319
|
-
}
|
|
3320
|
-
}
|
|
3321
|
-
/**
|
|
3322
|
-
* @returns {Uint8Array}
|
|
3323
|
-
*/
|
|
3324
|
-
static make_user_key_xchacha20_poly1305() {
|
|
3325
|
-
try {
|
|
3326
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3327
|
-
wasm.purecrypto_make_user_key_xchacha20_poly1305(retptr);
|
|
3328
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3329
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3330
|
-
var v1 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3331
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3332
|
-
return v1;
|
|
3333
|
-
} finally {
|
|
3334
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3335
|
-
}
|
|
3336
|
-
}
|
|
3337
|
-
/**
|
|
3338
|
-
* Wraps (encrypts) a symmetric key using a symmetric wrapping key, returning the wrapped key
|
|
3339
|
-
* as an EncString.
|
|
3340
|
-
* @param {Uint8Array} key_to_be_wrapped
|
|
3341
|
-
* @param {Uint8Array} wrapping_key
|
|
3342
|
-
* @returns {string}
|
|
3343
|
-
*/
|
|
3344
|
-
static wrap_symmetric_key(key_to_be_wrapped, wrapping_key) {
|
|
3345
|
-
let deferred4_0;
|
|
3346
|
-
let deferred4_1;
|
|
3347
|
-
try {
|
|
3348
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3349
|
-
const ptr0 = passArray8ToWasm0(key_to_be_wrapped, wasm.__wbindgen_malloc);
|
|
3350
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3351
|
-
const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
|
|
3352
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3353
|
-
wasm.purecrypto_wrap_symmetric_key(retptr, ptr0, len0, ptr1, len1);
|
|
3354
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3355
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3356
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3357
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3358
|
-
var ptr3 = r0;
|
|
3359
|
-
var len3 = r1;
|
|
3360
|
-
if (r3) {
|
|
3361
|
-
ptr3 = 0;
|
|
3362
|
-
len3 = 0;
|
|
3363
|
-
throw takeObject(r2);
|
|
3364
|
-
}
|
|
3365
|
-
deferred4_0 = ptr3;
|
|
3366
|
-
deferred4_1 = len3;
|
|
3367
|
-
return getStringFromWasm0(ptr3, len3);
|
|
3368
|
-
} finally {
|
|
3369
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3370
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3371
|
-
}
|
|
3372
|
-
}
|
|
3373
|
-
/**
|
|
3374
|
-
* Unwraps (decrypts) a wrapped symmetric key using a symmetric wrapping key, returning the
|
|
3375
|
-
* unwrapped key as a serialized byte array.
|
|
3376
|
-
* @param {string} wrapped_key
|
|
3377
|
-
* @param {Uint8Array} wrapping_key
|
|
3378
|
-
* @returns {Uint8Array}
|
|
3379
|
-
*/
|
|
3380
|
-
static unwrap_symmetric_key(wrapped_key, wrapping_key) {
|
|
3381
|
-
try {
|
|
3382
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3383
|
-
const ptr0 = passStringToWasm0(wrapped_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3384
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3385
|
-
const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
|
|
3386
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3387
|
-
wasm.purecrypto_unwrap_symmetric_key(retptr, ptr0, len0, ptr1, len1);
|
|
3388
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3389
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3390
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3391
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3392
|
-
if (r3) {
|
|
3393
|
-
throw takeObject(r2);
|
|
3394
|
-
}
|
|
3395
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3396
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3397
|
-
return v3;
|
|
3398
|
-
} finally {
|
|
3399
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3400
|
-
}
|
|
3401
|
-
}
|
|
3402
|
-
/**
|
|
3403
|
-
* Wraps (encrypts) an SPKI DER encoded encapsulation (public) key using a symmetric wrapping
|
|
3404
|
-
* key. Note: Usually, a public key is - by definition - public, so this should not be
|
|
3405
|
-
* used. The specific use-case for this function is to enable rotateable key sets, where
|
|
3406
|
-
* the "public key" is not public, with the intent of preventing the server from being able
|
|
3407
|
-
* to overwrite the user key unlocked by the rotateable keyset.
|
|
3408
|
-
* @param {Uint8Array} encapsulation_key
|
|
3409
|
-
* @param {Uint8Array} wrapping_key
|
|
3410
|
-
* @returns {string}
|
|
3411
|
-
*/
|
|
3412
|
-
static wrap_encapsulation_key(encapsulation_key, wrapping_key) {
|
|
3413
|
-
let deferred4_0;
|
|
3414
|
-
let deferred4_1;
|
|
3415
|
-
try {
|
|
3416
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3417
|
-
const ptr0 = passArray8ToWasm0(encapsulation_key, wasm.__wbindgen_malloc);
|
|
3418
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3419
|
-
const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
|
|
3420
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3421
|
-
wasm.purecrypto_wrap_encapsulation_key(retptr, ptr0, len0, ptr1, len1);
|
|
3422
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3423
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3424
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3425
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3426
|
-
var ptr3 = r0;
|
|
3427
|
-
var len3 = r1;
|
|
3428
|
-
if (r3) {
|
|
3429
|
-
ptr3 = 0;
|
|
3430
|
-
len3 = 0;
|
|
3431
|
-
throw takeObject(r2);
|
|
3432
|
-
}
|
|
3433
|
-
deferred4_0 = ptr3;
|
|
3434
|
-
deferred4_1 = len3;
|
|
3435
|
-
return getStringFromWasm0(ptr3, len3);
|
|
3436
|
-
} finally {
|
|
3437
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3438
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3439
|
-
}
|
|
3440
|
-
}
|
|
3441
|
-
/**
|
|
3442
|
-
* Unwraps (decrypts) a wrapped SPKI DER encoded encapsulation (public) key using a symmetric
|
|
3443
|
-
* wrapping key.
|
|
3444
|
-
* @param {string} wrapped_key
|
|
3445
|
-
* @param {Uint8Array} wrapping_key
|
|
3446
|
-
* @returns {Uint8Array}
|
|
3447
|
-
*/
|
|
3448
|
-
static unwrap_encapsulation_key(wrapped_key, wrapping_key) {
|
|
3449
|
-
try {
|
|
3450
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3451
|
-
const ptr0 = passStringToWasm0(wrapped_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3452
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3453
|
-
const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
|
|
3454
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3455
|
-
wasm.purecrypto_unwrap_decapsulation_key(retptr, ptr0, len0, ptr1, len1);
|
|
3456
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3457
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3458
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3459
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3460
|
-
if (r3) {
|
|
3461
|
-
throw takeObject(r2);
|
|
3462
|
-
}
|
|
3463
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3464
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3465
|
-
return v3;
|
|
3466
|
-
} finally {
|
|
3467
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3468
|
-
}
|
|
3469
|
-
}
|
|
3470
|
-
/**
|
|
3471
|
-
* Wraps (encrypts) a PKCS8 DER encoded decapsulation (private) key using a symmetric wrapping
|
|
3472
|
-
* key,
|
|
3473
|
-
* @param {Uint8Array} decapsulation_key
|
|
3474
|
-
* @param {Uint8Array} wrapping_key
|
|
3475
|
-
* @returns {string}
|
|
3476
|
-
*/
|
|
3477
|
-
static wrap_decapsulation_key(decapsulation_key, wrapping_key) {
|
|
3478
|
-
let deferred4_0;
|
|
3479
|
-
let deferred4_1;
|
|
3480
|
-
try {
|
|
3481
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3482
|
-
const ptr0 = passArray8ToWasm0(decapsulation_key, wasm.__wbindgen_malloc);
|
|
3483
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3484
|
-
const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
|
|
3485
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3486
|
-
wasm.purecrypto_wrap_decapsulation_key(retptr, ptr0, len0, ptr1, len1);
|
|
3487
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3488
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3489
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3490
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3491
|
-
var ptr3 = r0;
|
|
3492
|
-
var len3 = r1;
|
|
3493
|
-
if (r3) {
|
|
3494
|
-
ptr3 = 0;
|
|
3495
|
-
len3 = 0;
|
|
3496
|
-
throw takeObject(r2);
|
|
3497
|
-
}
|
|
3498
|
-
deferred4_0 = ptr3;
|
|
3499
|
-
deferred4_1 = len3;
|
|
3500
|
-
return getStringFromWasm0(ptr3, len3);
|
|
3501
|
-
} finally {
|
|
3502
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3503
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3504
|
-
}
|
|
3505
|
-
}
|
|
3506
|
-
/**
|
|
3507
|
-
* Unwraps (decrypts) a wrapped PKCS8 DER encoded decapsulation (private) key using a symmetric
|
|
3508
|
-
* wrapping key.
|
|
3509
|
-
* @param {string} wrapped_key
|
|
3510
|
-
* @param {Uint8Array} wrapping_key
|
|
3511
|
-
* @returns {Uint8Array}
|
|
3512
|
-
*/
|
|
3513
|
-
static unwrap_decapsulation_key(wrapped_key, wrapping_key) {
|
|
3514
|
-
try {
|
|
3515
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3516
|
-
const ptr0 = passStringToWasm0(wrapped_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3517
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3518
|
-
const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
|
|
3519
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3520
|
-
wasm.purecrypto_unwrap_decapsulation_key(retptr, ptr0, len0, ptr1, len1);
|
|
3521
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3522
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3523
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3524
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3525
|
-
if (r3) {
|
|
3526
|
-
throw takeObject(r2);
|
|
3527
|
-
}
|
|
3528
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3529
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3530
|
-
return v3;
|
|
3531
|
-
} finally {
|
|
3532
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3533
|
-
}
|
|
3534
|
-
}
|
|
3535
|
-
/**
|
|
3536
|
-
* Encapsulates (encrypts) a symmetric key using an asymmetric encapsulation key (public key)
|
|
3537
|
-
* in SPKI format, returning the encapsulated key as a string. Note: This is unsigned, so
|
|
3538
|
-
* the sender's authenticity cannot be verified by the recipient.
|
|
3539
|
-
* @param {Uint8Array} shared_key
|
|
3540
|
-
* @param {Uint8Array} encapsulation_key
|
|
3541
|
-
* @returns {string}
|
|
3542
|
-
*/
|
|
3543
|
-
static encapsulate_key_unsigned(shared_key, encapsulation_key) {
|
|
3544
|
-
let deferred4_0;
|
|
3545
|
-
let deferred4_1;
|
|
3546
|
-
try {
|
|
3547
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3548
|
-
const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
|
|
3549
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3550
|
-
const ptr1 = passArray8ToWasm0(encapsulation_key, wasm.__wbindgen_malloc);
|
|
3551
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3552
|
-
wasm.purecrypto_encapsulate_key_unsigned(retptr, ptr0, len0, ptr1, len1);
|
|
3553
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3554
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3555
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3556
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3557
|
-
var ptr3 = r0;
|
|
3558
|
-
var len3 = r1;
|
|
3559
|
-
if (r3) {
|
|
3560
|
-
ptr3 = 0;
|
|
3561
|
-
len3 = 0;
|
|
3562
|
-
throw takeObject(r2);
|
|
3563
|
-
}
|
|
3564
|
-
deferred4_0 = ptr3;
|
|
3565
|
-
deferred4_1 = len3;
|
|
3566
|
-
return getStringFromWasm0(ptr3, len3);
|
|
3567
|
-
} finally {
|
|
3568
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3569
|
-
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3570
|
-
}
|
|
3571
|
-
}
|
|
3572
|
-
/**
|
|
3573
|
-
* Decapsulates (decrypts) a symmetric key using an decapsulation key (private key) in PKCS8
|
|
3574
|
-
* DER format. Note: This is unsigned, so the sender's authenticity cannot be verified by the
|
|
3575
|
-
* recipient.
|
|
3576
|
-
* @param {string} encapsulated_key
|
|
3577
|
-
* @param {Uint8Array} decapsulation_key
|
|
3578
|
-
* @returns {Uint8Array}
|
|
3579
|
-
*/
|
|
3580
|
-
static decapsulate_key_unsigned(encapsulated_key, decapsulation_key) {
|
|
3581
|
-
try {
|
|
3582
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3583
|
-
const ptr0 = passStringToWasm0(
|
|
3584
|
-
encapsulated_key,
|
|
3585
|
-
wasm.__wbindgen_malloc,
|
|
3586
|
-
wasm.__wbindgen_realloc,
|
|
3587
|
-
);
|
|
3588
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3589
|
-
const ptr1 = passArray8ToWasm0(decapsulation_key, wasm.__wbindgen_malloc);
|
|
3590
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3591
|
-
wasm.purecrypto_decapsulate_key_unsigned(retptr, ptr0, len0, ptr1, len1);
|
|
3592
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3593
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3594
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3595
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3596
|
-
if (r3) {
|
|
3597
|
-
throw takeObject(r2);
|
|
3598
|
-
}
|
|
3599
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3600
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3601
|
-
return v3;
|
|
3602
|
-
} finally {
|
|
3603
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3604
|
-
}
|
|
3605
|
-
}
|
|
3606
|
-
/**
|
|
3607
|
-
* Given a wrapped signing key and the symmetric key it is wrapped with, this returns
|
|
3608
|
-
* the corresponding verifying key.
|
|
3609
|
-
* @param {string} signing_key
|
|
3610
|
-
* @param {Uint8Array} wrapping_key
|
|
3611
|
-
* @returns {Uint8Array}
|
|
3612
|
-
*/
|
|
3613
|
-
static verifying_key_for_signing_key(signing_key, wrapping_key) {
|
|
3614
|
-
try {
|
|
3615
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3616
|
-
const ptr0 = passStringToWasm0(signing_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3617
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3618
|
-
const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
|
|
3619
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3620
|
-
wasm.purecrypto_verifying_key_for_signing_key(retptr, ptr0, len0, ptr1, len1);
|
|
3621
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3622
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3623
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3624
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3625
|
-
if (r3) {
|
|
3626
|
-
throw takeObject(r2);
|
|
3627
|
-
}
|
|
3628
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3629
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3630
|
-
return v3;
|
|
3631
|
-
} finally {
|
|
3632
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3633
|
-
}
|
|
3634
|
-
}
|
|
3635
|
-
/**
|
|
3636
|
-
* Returns the algorithm used for the given verifying key.
|
|
3637
|
-
* @param {Uint8Array} verifying_key
|
|
3638
|
-
* @returns {SignatureAlgorithm}
|
|
3639
|
-
*/
|
|
3640
|
-
static key_algorithm_for_verifying_key(verifying_key) {
|
|
3641
|
-
try {
|
|
3642
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3643
|
-
const ptr0 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
|
|
3644
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3645
|
-
wasm.purecrypto_key_algorithm_for_verifying_key(retptr, ptr0, len0);
|
|
3646
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3647
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3648
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3649
|
-
if (r2) {
|
|
3650
|
-
throw takeObject(r1);
|
|
3651
|
-
}
|
|
3652
|
-
return takeObject(r0);
|
|
3653
|
-
} finally {
|
|
3654
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3655
|
-
}
|
|
3656
|
-
}
|
|
3657
|
-
/**
|
|
3658
|
-
* For a given signing identity (verifying key), this function verifies that the signing
|
|
3659
|
-
* identity claimed ownership of the public key. This is a one-sided claim and merely shows
|
|
3660
|
-
* that the signing identity has the intent to receive messages encrypted to the public
|
|
3661
|
-
* key.
|
|
3662
|
-
* @param {Uint8Array} signed_public_key
|
|
3663
|
-
* @param {Uint8Array} verifying_key
|
|
3664
|
-
* @returns {Uint8Array}
|
|
3665
|
-
*/
|
|
3666
|
-
static verify_and_unwrap_signed_public_key(signed_public_key, verifying_key) {
|
|
3667
|
-
try {
|
|
3668
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3669
|
-
const ptr0 = passArray8ToWasm0(signed_public_key, wasm.__wbindgen_malloc);
|
|
3670
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3671
|
-
const ptr1 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
|
|
3672
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3673
|
-
wasm.purecrypto_verify_and_unwrap_signed_public_key(retptr, ptr0, len0, ptr1, len1);
|
|
3674
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3675
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3676
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3677
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3678
|
-
if (r3) {
|
|
3679
|
-
throw takeObject(r2);
|
|
3680
|
-
}
|
|
3681
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3682
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3683
|
-
return v3;
|
|
3684
|
-
} finally {
|
|
3685
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3686
|
-
}
|
|
3687
|
-
}
|
|
3688
|
-
/**
|
|
3689
|
-
* Derive output of the KDF for a [bitwarden_crypto::Kdf] configuration.
|
|
3690
|
-
* @param {Uint8Array} password
|
|
3691
|
-
* @param {Uint8Array} salt
|
|
3692
|
-
* @param {Kdf} kdf
|
|
3693
|
-
* @returns {Uint8Array}
|
|
3694
|
-
*/
|
|
3695
|
-
static derive_kdf_material(password, salt, kdf) {
|
|
3696
|
-
try {
|
|
3697
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3698
|
-
const ptr0 = passArray8ToWasm0(password, wasm.__wbindgen_malloc);
|
|
3699
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3700
|
-
const ptr1 = passArray8ToWasm0(salt, wasm.__wbindgen_malloc);
|
|
3701
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3702
|
-
wasm.purecrypto_derive_kdf_material(retptr, ptr0, len0, ptr1, len1, addHeapObject(kdf));
|
|
3703
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3704
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3705
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3706
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3707
|
-
if (r3) {
|
|
3708
|
-
throw takeObject(r2);
|
|
3709
|
-
}
|
|
3710
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3711
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3712
|
-
return v3;
|
|
3713
|
-
} finally {
|
|
3714
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3715
|
-
}
|
|
3716
|
-
}
|
|
3717
|
-
/**
|
|
3718
|
-
* @param {string} encrypted_user_key
|
|
3719
|
-
* @param {Uint8Array} master_key
|
|
3720
|
-
* @returns {Uint8Array}
|
|
3721
|
-
*/
|
|
3722
|
-
static decrypt_user_key_with_master_key(encrypted_user_key, master_key) {
|
|
3723
|
-
try {
|
|
3724
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3725
|
-
const ptr0 = passStringToWasm0(
|
|
3726
|
-
encrypted_user_key,
|
|
3727
|
-
wasm.__wbindgen_malloc,
|
|
3728
|
-
wasm.__wbindgen_realloc,
|
|
3729
|
-
);
|
|
3730
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3731
|
-
const ptr1 = passArray8ToWasm0(master_key, wasm.__wbindgen_malloc);
|
|
3732
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3733
|
-
wasm.purecrypto_decrypt_user_key_with_master_key(retptr, ptr0, len0, ptr1, len1);
|
|
3734
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3735
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3736
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3737
|
-
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
3738
|
-
if (r3) {
|
|
3739
|
-
throw takeObject(r2);
|
|
3740
|
-
}
|
|
3741
|
-
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
3742
|
-
wasm.__wbindgen_free(r0, r1 * 1, 1);
|
|
3743
|
-
return v3;
|
|
3744
|
-
} finally {
|
|
3745
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3746
|
-
}
|
|
3747
|
-
}
|
|
3748
|
-
}
|
|
3749
|
-
module.exports.PureCrypto = PureCrypto;
|
|
3750
|
-
|
|
3751
|
-
const SendAccessClientFinalization =
|
|
3752
|
-
typeof FinalizationRegistry === "undefined"
|
|
3753
|
-
? { register: () => {}, unregister: () => {} }
|
|
3754
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_sendaccessclient_free(ptr >>> 0, 1));
|
|
3755
|
-
/**
|
|
3756
|
-
* The `SendAccessClient` is used to interact with the Bitwarden API to get send access tokens.
|
|
3757
|
-
*/
|
|
3758
|
-
class SendAccessClient {
|
|
3759
|
-
static __wrap(ptr) {
|
|
3760
|
-
ptr = ptr >>> 0;
|
|
3761
|
-
const obj = Object.create(SendAccessClient.prototype);
|
|
3762
|
-
obj.__wbg_ptr = ptr;
|
|
3763
|
-
SendAccessClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
3764
|
-
return obj;
|
|
3765
|
-
}
|
|
3766
|
-
|
|
3767
|
-
__destroy_into_raw() {
|
|
3768
|
-
const ptr = this.__wbg_ptr;
|
|
3769
|
-
this.__wbg_ptr = 0;
|
|
3770
|
-
SendAccessClientFinalization.unregister(this);
|
|
3771
|
-
return ptr;
|
|
3772
|
-
}
|
|
3773
|
-
|
|
3774
|
-
free() {
|
|
3775
|
-
const ptr = this.__destroy_into_raw();
|
|
3776
|
-
wasm.__wbg_sendaccessclient_free(ptr, 0);
|
|
3777
|
-
}
|
|
3778
|
-
/**
|
|
3779
|
-
* Requests a new send access token.
|
|
3780
|
-
* @param {SendAccessTokenRequest} request
|
|
3781
|
-
* @returns {Promise<SendAccessTokenResponse>}
|
|
3782
|
-
*/
|
|
3783
|
-
request_send_access_token(request) {
|
|
3784
|
-
const ret = wasm.sendaccessclient_request_send_access_token(
|
|
3785
|
-
this.__wbg_ptr,
|
|
3786
|
-
addHeapObject(request),
|
|
3787
|
-
);
|
|
3788
|
-
return takeObject(ret);
|
|
3789
|
-
}
|
|
3790
|
-
}
|
|
3791
|
-
module.exports.SendAccessClient = SendAccessClient;
|
|
3792
|
-
|
|
3793
|
-
const StateClientFinalization =
|
|
3794
|
-
typeof FinalizationRegistry === "undefined"
|
|
3795
|
-
? { register: () => {}, unregister: () => {} }
|
|
3796
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_stateclient_free(ptr >>> 0, 1));
|
|
3797
|
-
|
|
3798
|
-
class StateClient {
|
|
3799
|
-
static __wrap(ptr) {
|
|
3800
|
-
ptr = ptr >>> 0;
|
|
3801
|
-
const obj = Object.create(StateClient.prototype);
|
|
3802
|
-
obj.__wbg_ptr = ptr;
|
|
3803
|
-
StateClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
3804
|
-
return obj;
|
|
3805
|
-
}
|
|
3806
|
-
|
|
3807
|
-
__destroy_into_raw() {
|
|
3808
|
-
const ptr = this.__wbg_ptr;
|
|
3809
|
-
this.__wbg_ptr = 0;
|
|
3810
|
-
StateClientFinalization.unregister(this);
|
|
3811
|
-
return ptr;
|
|
3812
|
-
}
|
|
3813
|
-
|
|
3814
|
-
free() {
|
|
3815
|
-
const ptr = this.__destroy_into_raw();
|
|
3816
|
-
wasm.__wbg_stateclient_free(ptr, 0);
|
|
3817
|
-
}
|
|
3818
|
-
/**
|
|
3819
|
-
* @param {any} cipher_repository
|
|
3820
|
-
*/
|
|
3821
|
-
register_cipher_repository(cipher_repository) {
|
|
3822
|
-
wasm.stateclient_register_cipher_repository(this.__wbg_ptr, addHeapObject(cipher_repository));
|
|
3823
|
-
}
|
|
3824
|
-
/**
|
|
3825
|
-
* @param {any} store
|
|
3826
|
-
*/
|
|
3827
|
-
register_folder_repository(store) {
|
|
3828
|
-
wasm.stateclient_register_folder_repository(this.__wbg_ptr, addHeapObject(store));
|
|
3829
|
-
}
|
|
3830
|
-
/**
|
|
3831
|
-
* @param {Repositories} repositories
|
|
3832
|
-
*/
|
|
3833
|
-
register_client_managed_repositories(repositories) {
|
|
3834
|
-
wasm.stateclient_register_client_managed_repositories(
|
|
3835
|
-
this.__wbg_ptr,
|
|
3836
|
-
addHeapObject(repositories),
|
|
3837
|
-
);
|
|
3838
|
-
}
|
|
3839
|
-
/**
|
|
3840
|
-
* Initialize the database for SDK managed repositories.
|
|
3841
|
-
* @param {IndexedDbConfiguration} configuration
|
|
3842
|
-
* @returns {Promise<void>}
|
|
3843
|
-
*/
|
|
3844
|
-
initialize_state(configuration) {
|
|
3845
|
-
const ret = wasm.stateclient_initialize_state(this.__wbg_ptr, addHeapObject(configuration));
|
|
3846
|
-
return takeObject(ret);
|
|
3847
|
-
}
|
|
3848
|
-
}
|
|
3849
|
-
module.exports.StateClient = StateClient;
|
|
3850
|
-
|
|
3851
|
-
const TotpClientFinalization =
|
|
3852
|
-
typeof FinalizationRegistry === "undefined"
|
|
3853
|
-
? { register: () => {}, unregister: () => {} }
|
|
3854
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_totpclient_free(ptr >>> 0, 1));
|
|
3855
|
-
|
|
3856
|
-
class TotpClient {
|
|
3857
|
-
static __wrap(ptr) {
|
|
3858
|
-
ptr = ptr >>> 0;
|
|
3859
|
-
const obj = Object.create(TotpClient.prototype);
|
|
3860
|
-
obj.__wbg_ptr = ptr;
|
|
3861
|
-
TotpClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
3862
|
-
return obj;
|
|
3863
|
-
}
|
|
3864
|
-
|
|
3865
|
-
__destroy_into_raw() {
|
|
3866
|
-
const ptr = this.__wbg_ptr;
|
|
3867
|
-
this.__wbg_ptr = 0;
|
|
3868
|
-
TotpClientFinalization.unregister(this);
|
|
3869
|
-
return ptr;
|
|
3870
|
-
}
|
|
3871
|
-
|
|
3872
|
-
free() {
|
|
3873
|
-
const ptr = this.__destroy_into_raw();
|
|
3874
|
-
wasm.__wbg_totpclient_free(ptr, 0);
|
|
3875
|
-
}
|
|
3876
|
-
/**
|
|
3877
|
-
* Generates a TOTP code from a provided key
|
|
3878
|
-
*
|
|
3879
|
-
* # Arguments
|
|
3880
|
-
* - `key` - Can be:
|
|
3881
|
-
* - A base32 encoded string
|
|
3882
|
-
* - OTP Auth URI
|
|
3883
|
-
* - Steam URI
|
|
3884
|
-
* - `time_ms` - Optional timestamp in milliseconds
|
|
3885
|
-
* @param {string} key
|
|
3886
|
-
* @param {number | null} [time_ms]
|
|
3887
|
-
* @returns {TotpResponse}
|
|
3888
|
-
*/
|
|
3889
|
-
generate_totp(key, time_ms) {
|
|
3890
|
-
try {
|
|
3891
|
-
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
3892
|
-
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3893
|
-
const len0 = WASM_VECTOR_LEN;
|
|
3894
|
-
wasm.totpclient_generate_totp(
|
|
3895
|
-
retptr,
|
|
3896
|
-
this.__wbg_ptr,
|
|
3897
|
-
ptr0,
|
|
3898
|
-
len0,
|
|
3899
|
-
!isLikeNone(time_ms),
|
|
3900
|
-
isLikeNone(time_ms) ? 0 : time_ms,
|
|
3901
|
-
);
|
|
3902
|
-
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
3903
|
-
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
3904
|
-
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
3905
|
-
if (r2) {
|
|
3906
|
-
throw takeObject(r1);
|
|
3907
|
-
}
|
|
3908
|
-
return takeObject(r0);
|
|
3909
|
-
} finally {
|
|
3910
|
-
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
3911
|
-
}
|
|
3912
|
-
}
|
|
3913
|
-
}
|
|
3914
|
-
module.exports.TotpClient = TotpClient;
|
|
3915
|
-
|
|
3916
|
-
const VaultClientFinalization =
|
|
3917
|
-
typeof FinalizationRegistry === "undefined"
|
|
3918
|
-
? { register: () => {}, unregister: () => {} }
|
|
3919
|
-
: new FinalizationRegistry((ptr) => wasm.__wbg_vaultclient_free(ptr >>> 0, 1));
|
|
3920
|
-
|
|
3921
|
-
class VaultClient {
|
|
3922
|
-
static __wrap(ptr) {
|
|
3923
|
-
ptr = ptr >>> 0;
|
|
3924
|
-
const obj = Object.create(VaultClient.prototype);
|
|
3925
|
-
obj.__wbg_ptr = ptr;
|
|
3926
|
-
VaultClientFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
3927
|
-
return obj;
|
|
3928
|
-
}
|
|
3929
|
-
|
|
3930
|
-
__destroy_into_raw() {
|
|
3931
|
-
const ptr = this.__wbg_ptr;
|
|
3932
|
-
this.__wbg_ptr = 0;
|
|
3933
|
-
VaultClientFinalization.unregister(this);
|
|
3934
|
-
return ptr;
|
|
3935
|
-
}
|
|
3936
|
-
|
|
3937
|
-
free() {
|
|
3938
|
-
const ptr = this.__destroy_into_raw();
|
|
3939
|
-
wasm.__wbg_vaultclient_free(ptr, 0);
|
|
3940
|
-
}
|
|
3941
|
-
/**
|
|
3942
|
-
* Attachment related operations.
|
|
3943
|
-
* @returns {AttachmentsClient}
|
|
3944
|
-
*/
|
|
3945
|
-
attachments() {
|
|
3946
|
-
const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
|
|
3947
|
-
return AttachmentsClient.__wrap(ret);
|
|
3948
|
-
}
|
|
3949
|
-
/**
|
|
3950
|
-
* Cipher related operations.
|
|
3951
|
-
* @returns {CiphersClient}
|
|
3952
|
-
*/
|
|
3953
|
-
ciphers() {
|
|
3954
|
-
const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
|
|
3955
|
-
return CiphersClient.__wrap(ret);
|
|
3956
|
-
}
|
|
3957
|
-
/**
|
|
3958
|
-
* Folder related operations.
|
|
3959
|
-
* @returns {FoldersClient}
|
|
3960
|
-
*/
|
|
3961
|
-
folders() {
|
|
3962
|
-
const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
|
|
3963
|
-
return FoldersClient.__wrap(ret);
|
|
3964
|
-
}
|
|
3965
|
-
/**
|
|
3966
|
-
* TOTP related operations.
|
|
3967
|
-
* @returns {TotpClient}
|
|
3968
|
-
*/
|
|
3969
|
-
totp() {
|
|
3970
|
-
const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
|
|
3971
|
-
return TotpClient.__wrap(ret);
|
|
3972
|
-
}
|
|
3973
|
-
/**
|
|
3974
|
-
* Collection related operations.
|
|
3975
|
-
* @returns {CollectionsClient}
|
|
3976
|
-
*/
|
|
3977
|
-
collections() {
|
|
3978
|
-
const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
|
|
3979
|
-
return CollectionsClient.__wrap(ret);
|
|
3980
|
-
}
|
|
3981
|
-
}
|
|
3982
|
-
module.exports.VaultClient = VaultClient;
|
|
3983
|
-
|
|
3984
|
-
module.exports.__wbg_String_8f0eb39a4a4c2f66 = function (arg0, arg1) {
|
|
3985
|
-
const ret = String(getObject(arg1));
|
|
3986
|
-
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3987
|
-
const len1 = WASM_VECTOR_LEN;
|
|
3988
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3989
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3990
|
-
};
|
|
3991
|
-
|
|
3992
|
-
module.exports.__wbg_abort_410ec47a64ac6117 = function (arg0, arg1) {
|
|
3993
|
-
getObject(arg0).abort(getObject(arg1));
|
|
3994
|
-
};
|
|
3995
|
-
|
|
3996
|
-
module.exports.__wbg_abort_775ef1d17fc65868 = function (arg0) {
|
|
3997
|
-
getObject(arg0).abort();
|
|
3998
|
-
};
|
|
3999
|
-
|
|
4000
|
-
module.exports.__wbg_abort_99fc644e2c79c9fb = function () {
|
|
4001
|
-
return handleError(function (arg0) {
|
|
4002
|
-
getObject(arg0).abort();
|
|
4003
|
-
}, arguments);
|
|
4004
|
-
};
|
|
4005
|
-
|
|
4006
|
-
module.exports.__wbg_addEventListener_dc3da056b615f634 = function (arg0, arg1, arg2, arg3) {
|
|
4007
|
-
getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
|
|
4008
|
-
};
|
|
4009
|
-
|
|
4010
|
-
module.exports.__wbg_append_299d5d48292c0495 = function () {
|
|
4011
|
-
return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
4012
|
-
getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
|
|
4013
|
-
}, arguments);
|
|
4014
|
-
};
|
|
4015
|
-
|
|
4016
|
-
module.exports.__wbg_append_8c7dd8d641a5f01b = function () {
|
|
4017
|
-
return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
4018
|
-
getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
|
|
4019
|
-
}, arguments);
|
|
4020
|
-
};
|
|
4021
|
-
|
|
4022
|
-
module.exports.__wbg_append_b2d1fc16de2a0e81 = function () {
|
|
4023
|
-
return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
4024
|
-
getObject(arg0).append(
|
|
4025
|
-
getStringFromWasm0(arg1, arg2),
|
|
4026
|
-
getObject(arg3),
|
|
4027
|
-
getStringFromWasm0(arg4, arg5),
|
|
4028
|
-
);
|
|
4029
|
-
}, arguments);
|
|
4030
|
-
};
|
|
4031
|
-
|
|
4032
|
-
module.exports.__wbg_append_b44785ebeb668479 = function () {
|
|
4033
|
-
return handleError(function (arg0, arg1, arg2, arg3) {
|
|
4034
|
-
getObject(arg0).append(getStringFromWasm0(arg1, arg2), getObject(arg3));
|
|
4035
|
-
}, arguments);
|
|
4036
|
-
};
|
|
4037
|
-
|
|
4038
|
-
module.exports.__wbg_arrayBuffer_d1b44c4390db422f = function () {
|
|
4039
|
-
return handleError(function (arg0) {
|
|
4040
|
-
const ret = getObject(arg0).arrayBuffer();
|
|
4041
|
-
return addHeapObject(ret);
|
|
4042
|
-
}, arguments);
|
|
4043
|
-
};
|
|
4044
|
-
|
|
4045
|
-
module.exports.__wbg_buffer_609cc3eee51ed158 = function (arg0) {
|
|
4046
|
-
const ret = getObject(arg0).buffer;
|
|
4047
|
-
return addHeapObject(ret);
|
|
4048
|
-
};
|
|
4049
|
-
|
|
4050
|
-
module.exports.__wbg_call_672a4d21634d4a24 = function () {
|
|
4051
|
-
return handleError(function (arg0, arg1) {
|
|
4052
|
-
const ret = getObject(arg0).call(getObject(arg1));
|
|
4053
|
-
return addHeapObject(ret);
|
|
4054
|
-
}, arguments);
|
|
4055
|
-
};
|
|
4056
|
-
|
|
4057
|
-
module.exports.__wbg_call_7cccdd69e0791ae2 = function () {
|
|
4058
|
-
return handleError(function (arg0, arg1, arg2) {
|
|
4059
|
-
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
|
|
4060
|
-
return addHeapObject(ret);
|
|
4061
|
-
}, arguments);
|
|
4062
|
-
};
|
|
4063
|
-
|
|
4064
|
-
module.exports.__wbg_cipher_ed6d217c5217cde5 = function (arg0) {
|
|
4065
|
-
const ret = getObject(arg0).cipher;
|
|
4066
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4067
|
-
};
|
|
4068
|
-
|
|
4069
|
-
module.exports.__wbg_clearTimeout_b1115618e821c3b2 = function (arg0) {
|
|
4070
|
-
const ret = clearTimeout(takeObject(arg0));
|
|
4071
|
-
return addHeapObject(ret);
|
|
4072
|
-
};
|
|
4073
|
-
|
|
4074
|
-
module.exports.__wbg_collectionviewnodeitem_new = function (arg0) {
|
|
4075
|
-
const ret = CollectionViewNodeItem.__wrap(arg0);
|
|
4076
|
-
return addHeapObject(ret);
|
|
4077
|
-
};
|
|
4078
|
-
|
|
4079
|
-
module.exports.__wbg_createObjectStore_d2f9e1016f4d81b9 = function () {
|
|
4080
|
-
return handleError(function (arg0, arg1, arg2, arg3) {
|
|
4081
|
-
const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2), getObject(arg3));
|
|
4082
|
-
return addHeapObject(ret);
|
|
4083
|
-
}, arguments);
|
|
4084
|
-
};
|
|
4085
|
-
|
|
4086
|
-
module.exports.__wbg_crypto_574e78ad8b13b65f = function (arg0) {
|
|
4087
|
-
const ret = getObject(arg0).crypto;
|
|
4088
|
-
return addHeapObject(ret);
|
|
4089
|
-
};
|
|
4090
|
-
|
|
4091
|
-
module.exports.__wbg_debug_e17b51583ca6a632 = function (arg0, arg1, arg2, arg3) {
|
|
4092
|
-
console.debug(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
|
|
4093
|
-
};
|
|
4094
|
-
|
|
4095
|
-
module.exports.__wbg_deleteObjectStore_3f08ae00cd288224 = function () {
|
|
4096
|
-
return handleError(function (arg0, arg1, arg2) {
|
|
4097
|
-
getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
|
|
4098
|
-
}, arguments);
|
|
4099
|
-
};
|
|
4100
|
-
|
|
4101
|
-
module.exports.__wbg_done_769e5ede4b31c67b = function (arg0) {
|
|
4102
|
-
const ret = getObject(arg0).done;
|
|
4103
|
-
return ret;
|
|
4104
|
-
};
|
|
4105
|
-
|
|
4106
|
-
module.exports.__wbg_entries_3265d4158b33e5dc = function (arg0) {
|
|
4107
|
-
const ret = Object.entries(getObject(arg0));
|
|
4108
|
-
return addHeapObject(ret);
|
|
4109
|
-
};
|
|
4110
|
-
|
|
4111
|
-
module.exports.__wbg_error_7534b8e9a36f1ab4 = function (arg0, arg1) {
|
|
4112
|
-
let deferred0_0;
|
|
4113
|
-
let deferred0_1;
|
|
4114
|
-
try {
|
|
4115
|
-
deferred0_0 = arg0;
|
|
4116
|
-
deferred0_1 = arg1;
|
|
4117
|
-
console.error(getStringFromWasm0(arg0, arg1));
|
|
4118
|
-
} finally {
|
|
4119
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4120
|
-
}
|
|
4121
|
-
};
|
|
4122
|
-
|
|
4123
|
-
module.exports.__wbg_error_80de38b3f7cc3c3c = function (arg0, arg1, arg2, arg3) {
|
|
4124
|
-
console.error(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
|
|
4125
|
-
};
|
|
4126
|
-
|
|
4127
|
-
module.exports.__wbg_error_ff4ddaabdfc5dbb3 = function () {
|
|
4128
|
-
return handleError(function (arg0) {
|
|
4129
|
-
const ret = getObject(arg0).error;
|
|
4130
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4131
|
-
}, arguments);
|
|
4132
|
-
};
|
|
4133
|
-
|
|
4134
|
-
module.exports.__wbg_fetch_3afbdcc7ddbf16fe = function (arg0) {
|
|
4135
|
-
const ret = fetch(getObject(arg0));
|
|
4136
|
-
return addHeapObject(ret);
|
|
4137
|
-
};
|
|
4138
|
-
|
|
4139
|
-
module.exports.__wbg_fetch_509096533071c657 = function (arg0, arg1) {
|
|
4140
|
-
const ret = getObject(arg0).fetch(getObject(arg1));
|
|
4141
|
-
return addHeapObject(ret);
|
|
4142
|
-
};
|
|
4143
|
-
|
|
4144
|
-
module.exports.__wbg_folder_d98a89688062cb0b = function (arg0) {
|
|
4145
|
-
const ret = getObject(arg0).folder;
|
|
4146
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4147
|
-
};
|
|
4148
|
-
|
|
4149
|
-
module.exports.__wbg_getRandomValues_38097e921c2494c3 = function () {
|
|
4150
|
-
return handleError(function (arg0, arg1) {
|
|
4151
|
-
globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
|
|
4152
|
-
}, arguments);
|
|
4153
|
-
};
|
|
4154
|
-
|
|
4155
|
-
module.exports.__wbg_getRandomValues_b8f5dbd5f3995a9e = function () {
|
|
4156
|
-
return handleError(function (arg0, arg1) {
|
|
4157
|
-
getObject(arg0).getRandomValues(getObject(arg1));
|
|
4158
|
-
}, arguments);
|
|
4159
|
-
};
|
|
4160
|
-
|
|
4161
|
-
module.exports.__wbg_getTime_46267b1c24877e30 = function (arg0) {
|
|
4162
|
-
const ret = getObject(arg0).getTime();
|
|
4163
|
-
return ret;
|
|
4164
|
-
};
|
|
4165
|
-
|
|
4166
|
-
module.exports.__wbg_get_67b2ba62fc30de12 = function () {
|
|
4167
|
-
return handleError(function (arg0, arg1) {
|
|
4168
|
-
const ret = Reflect.get(getObject(arg0), getObject(arg1));
|
|
4169
|
-
return addHeapObject(ret);
|
|
4170
|
-
}, arguments);
|
|
4171
|
-
};
|
|
4172
|
-
|
|
4173
|
-
module.exports.__wbg_get_6f0daea655a24395 = function () {
|
|
4174
|
-
return handleError(function (arg0, arg1, arg2) {
|
|
4175
|
-
let deferred0_0;
|
|
4176
|
-
let deferred0_1;
|
|
4177
|
-
try {
|
|
4178
|
-
deferred0_0 = arg1;
|
|
4179
|
-
deferred0_1 = arg2;
|
|
4180
|
-
const ret = getObject(arg0).get(getStringFromWasm0(arg1, arg2));
|
|
4181
|
-
return addHeapObject(ret);
|
|
4182
|
-
} finally {
|
|
4183
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4184
|
-
}
|
|
4185
|
-
}, arguments);
|
|
4186
|
-
};
|
|
4187
|
-
|
|
4188
|
-
module.exports.__wbg_get_a71e217c74ea9113 = function () {
|
|
4189
|
-
return handleError(function (arg0, arg1, arg2) {
|
|
4190
|
-
let deferred0_0;
|
|
4191
|
-
let deferred0_1;
|
|
4192
|
-
try {
|
|
4193
|
-
deferred0_0 = arg1;
|
|
4194
|
-
deferred0_1 = arg2;
|
|
4195
|
-
const ret = getObject(arg0).get(getStringFromWasm0(arg1, arg2));
|
|
4196
|
-
return addHeapObject(ret);
|
|
4197
|
-
} finally {
|
|
4198
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4199
|
-
}
|
|
4200
|
-
}, arguments);
|
|
4201
|
-
};
|
|
4202
|
-
|
|
4203
|
-
module.exports.__wbg_get_b9b93047fe3cf45b = function (arg0, arg1) {
|
|
4204
|
-
const ret = getObject(arg0)[arg1 >>> 0];
|
|
4205
|
-
return addHeapObject(ret);
|
|
4206
|
-
};
|
|
4207
|
-
|
|
4208
|
-
module.exports.__wbg_getaccesstoken_d53298c397ded35a = function (arg0) {
|
|
4209
|
-
const ret = getObject(arg0).get_access_token();
|
|
4210
|
-
return addHeapObject(ret);
|
|
4211
|
-
};
|
|
4212
|
-
|
|
4213
|
-
module.exports.__wbg_getwithrefkey_1dc361bd10053bfe = function (arg0, arg1) {
|
|
4214
|
-
const ret = getObject(arg0)[getObject(arg1)];
|
|
4215
|
-
return addHeapObject(ret);
|
|
4216
|
-
};
|
|
4217
|
-
|
|
4218
|
-
module.exports.__wbg_has_a5ea9117f258a0ec = function () {
|
|
4219
|
-
return handleError(function (arg0, arg1) {
|
|
4220
|
-
const ret = Reflect.has(getObject(arg0), getObject(arg1));
|
|
4221
|
-
return ret;
|
|
4222
|
-
}, arguments);
|
|
4223
|
-
};
|
|
4224
|
-
|
|
4225
|
-
module.exports.__wbg_headers_9cb51cfd2ac780a4 = function (arg0) {
|
|
4226
|
-
const ret = getObject(arg0).headers;
|
|
4227
|
-
return addHeapObject(ret);
|
|
4228
|
-
};
|
|
4229
|
-
|
|
4230
|
-
module.exports.__wbg_incomingmessage_new = function (arg0) {
|
|
4231
|
-
const ret = IncomingMessage.__wrap(arg0);
|
|
4232
|
-
return addHeapObject(ret);
|
|
4233
|
-
};
|
|
4234
|
-
|
|
4235
|
-
module.exports.__wbg_indexedDB_b1f49280282046f8 = function () {
|
|
4236
|
-
return handleError(function (arg0) {
|
|
4237
|
-
const ret = getObject(arg0).indexedDB;
|
|
4238
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4239
|
-
}, arguments);
|
|
4240
|
-
};
|
|
4241
|
-
|
|
4242
|
-
module.exports.__wbg_indexedDB_f6b47b0dc333fd2f = function () {
|
|
4243
|
-
return handleError(function (arg0) {
|
|
4244
|
-
const ret = getObject(arg0).indexedDB;
|
|
4245
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4246
|
-
}, arguments);
|
|
4247
|
-
};
|
|
4248
|
-
|
|
4249
|
-
module.exports.__wbg_info_033d8b8a0838f1d3 = function (arg0, arg1, arg2, arg3) {
|
|
4250
|
-
console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
|
|
4251
|
-
};
|
|
4252
|
-
|
|
4253
|
-
module.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function (arg0) {
|
|
4254
|
-
let result;
|
|
4255
|
-
try {
|
|
4256
|
-
result = getObject(arg0) instanceof ArrayBuffer;
|
|
4257
|
-
} catch (_) {
|
|
4258
|
-
result = false;
|
|
4259
|
-
}
|
|
4260
|
-
const ret = result;
|
|
4261
|
-
return ret;
|
|
4262
|
-
};
|
|
4263
|
-
|
|
4264
|
-
module.exports.__wbg_instanceof_DomException_ed1ccb7aaf39034c = function (arg0) {
|
|
4265
|
-
let result;
|
|
4266
|
-
try {
|
|
4267
|
-
result = getObject(arg0) instanceof DOMException;
|
|
4268
|
-
} catch (_) {
|
|
4269
|
-
result = false;
|
|
4270
|
-
}
|
|
4271
|
-
const ret = result;
|
|
4272
|
-
return ret;
|
|
4273
|
-
};
|
|
4274
|
-
|
|
4275
|
-
module.exports.__wbg_instanceof_IdbDatabase_a3ef009ca00059f9 = function (arg0) {
|
|
4276
|
-
let result;
|
|
4277
|
-
try {
|
|
4278
|
-
result = getObject(arg0) instanceof IDBDatabase;
|
|
4279
|
-
} catch (_) {
|
|
4280
|
-
result = false;
|
|
4281
|
-
}
|
|
4282
|
-
const ret = result;
|
|
4283
|
-
return ret;
|
|
4284
|
-
};
|
|
4285
|
-
|
|
4286
|
-
module.exports.__wbg_instanceof_IdbOpenDbRequest_a3416e156c9db893 = function (arg0) {
|
|
4287
|
-
let result;
|
|
4288
|
-
try {
|
|
4289
|
-
result = getObject(arg0) instanceof IDBOpenDBRequest;
|
|
4290
|
-
} catch (_) {
|
|
4291
|
-
result = false;
|
|
4292
|
-
}
|
|
4293
|
-
const ret = result;
|
|
4294
|
-
return ret;
|
|
4295
|
-
};
|
|
4296
|
-
|
|
4297
|
-
module.exports.__wbg_instanceof_IdbRequest_4813c3f207666aa4 = function (arg0) {
|
|
4298
|
-
let result;
|
|
4299
|
-
try {
|
|
4300
|
-
result = getObject(arg0) instanceof IDBRequest;
|
|
4301
|
-
} catch (_) {
|
|
4302
|
-
result = false;
|
|
4303
|
-
}
|
|
4304
|
-
const ret = result;
|
|
4305
|
-
return ret;
|
|
4306
|
-
};
|
|
4307
|
-
|
|
4308
|
-
module.exports.__wbg_instanceof_Map_f3469ce2244d2430 = function (arg0) {
|
|
4309
|
-
let result;
|
|
4310
|
-
try {
|
|
4311
|
-
result = getObject(arg0) instanceof Map;
|
|
4312
|
-
} catch (_) {
|
|
4313
|
-
result = false;
|
|
4314
|
-
}
|
|
4315
|
-
const ret = result;
|
|
4316
|
-
return ret;
|
|
4317
|
-
};
|
|
4318
|
-
|
|
4319
|
-
module.exports.__wbg_instanceof_Response_f2cc20d9f7dfd644 = function (arg0) {
|
|
4320
|
-
let result;
|
|
4321
|
-
try {
|
|
4322
|
-
result = getObject(arg0) instanceof Response;
|
|
4323
|
-
} catch (_) {
|
|
4324
|
-
result = false;
|
|
4325
|
-
}
|
|
4326
|
-
const ret = result;
|
|
4327
|
-
return ret;
|
|
4328
|
-
};
|
|
4329
|
-
|
|
4330
|
-
module.exports.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function (arg0) {
|
|
4331
|
-
let result;
|
|
4332
|
-
try {
|
|
4333
|
-
result = getObject(arg0) instanceof Uint8Array;
|
|
4334
|
-
} catch (_) {
|
|
4335
|
-
result = false;
|
|
4336
|
-
}
|
|
4337
|
-
const ret = result;
|
|
4338
|
-
return ret;
|
|
4339
|
-
};
|
|
4340
|
-
|
|
4341
|
-
module.exports.__wbg_instanceof_Window_def73ea0955fc569 = function (arg0) {
|
|
4342
|
-
let result;
|
|
4343
|
-
try {
|
|
4344
|
-
result = getObject(arg0) instanceof Window;
|
|
4345
|
-
} catch (_) {
|
|
4346
|
-
result = false;
|
|
4347
|
-
}
|
|
4348
|
-
const ret = result;
|
|
4349
|
-
return ret;
|
|
4350
|
-
};
|
|
4351
|
-
|
|
4352
|
-
module.exports.__wbg_instanceof_WorkerGlobalScope_dbdbdea7e3b56493 = function (arg0) {
|
|
4353
|
-
let result;
|
|
4354
|
-
try {
|
|
4355
|
-
result = getObject(arg0) instanceof WorkerGlobalScope;
|
|
4356
|
-
} catch (_) {
|
|
4357
|
-
result = false;
|
|
4358
|
-
}
|
|
4359
|
-
const ret = result;
|
|
4360
|
-
return ret;
|
|
4361
|
-
};
|
|
4362
|
-
|
|
4363
|
-
module.exports.__wbg_ipcclientsubscription_new = function (arg0) {
|
|
4364
|
-
const ret = IpcClientSubscription.__wrap(arg0);
|
|
4365
|
-
return addHeapObject(ret);
|
|
4366
|
-
};
|
|
4367
|
-
|
|
4368
|
-
module.exports.__wbg_isArray_a1eab7e0d067391b = function (arg0) {
|
|
4369
|
-
const ret = Array.isArray(getObject(arg0));
|
|
4370
|
-
return ret;
|
|
4371
|
-
};
|
|
4372
|
-
|
|
4373
|
-
module.exports.__wbg_isSafeInteger_343e2beeeece1bb0 = function (arg0) {
|
|
4374
|
-
const ret = Number.isSafeInteger(getObject(arg0));
|
|
4375
|
-
return ret;
|
|
4376
|
-
};
|
|
4377
|
-
|
|
4378
|
-
module.exports.__wbg_iterator_9a24c88df860dc65 = function () {
|
|
4379
|
-
const ret = Symbol.iterator;
|
|
4380
|
-
return addHeapObject(ret);
|
|
4381
|
-
};
|
|
4382
|
-
|
|
4383
|
-
module.exports.__wbg_length_a446193dc22c12f8 = function (arg0) {
|
|
4384
|
-
const ret = getObject(arg0).length;
|
|
4385
|
-
return ret;
|
|
4386
|
-
};
|
|
4387
|
-
|
|
4388
|
-
module.exports.__wbg_length_e2d2a49132c1b256 = function (arg0) {
|
|
4389
|
-
const ret = getObject(arg0).length;
|
|
4390
|
-
return ret;
|
|
4391
|
-
};
|
|
4392
|
-
|
|
4393
|
-
module.exports.__wbg_list_801a2e0e1c2ec487 = function () {
|
|
4394
|
-
return handleError(function (arg0) {
|
|
4395
|
-
const ret = getObject(arg0).list();
|
|
4396
|
-
return addHeapObject(ret);
|
|
4397
|
-
}, arguments);
|
|
4398
|
-
};
|
|
4399
|
-
|
|
4400
|
-
module.exports.__wbg_list_f6ee4a0aae8ae24f = function () {
|
|
4401
|
-
return handleError(function (arg0) {
|
|
4402
|
-
const ret = getObject(arg0).list();
|
|
4403
|
-
return addHeapObject(ret);
|
|
4404
|
-
}, arguments);
|
|
4405
|
-
};
|
|
4406
|
-
|
|
4407
|
-
module.exports.__wbg_log_cad59bb680daec67 = function (arg0, arg1, arg2, arg3) {
|
|
4408
|
-
console.log(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
|
|
4409
|
-
};
|
|
4410
|
-
|
|
4411
|
-
module.exports.__wbg_msCrypto_a61aeb35a24c1329 = function (arg0) {
|
|
4412
|
-
const ret = getObject(arg0).msCrypto;
|
|
4413
|
-
return addHeapObject(ret);
|
|
4414
|
-
};
|
|
4415
|
-
|
|
4416
|
-
module.exports.__wbg_name_f2d27098bfd843e7 = function (arg0, arg1) {
|
|
4417
|
-
const ret = getObject(arg1).name;
|
|
4418
|
-
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4419
|
-
const len1 = WASM_VECTOR_LEN;
|
|
4420
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4421
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4422
|
-
};
|
|
4423
|
-
|
|
4424
|
-
module.exports.__wbg_new0_f788a2397c7ca929 = function () {
|
|
4425
|
-
const ret = new Date();
|
|
4426
|
-
return addHeapObject(ret);
|
|
4427
|
-
};
|
|
4428
|
-
|
|
4429
|
-
module.exports.__wbg_new_018dcc2d6c8c2f6a = function () {
|
|
4430
|
-
return handleError(function () {
|
|
4431
|
-
const ret = new Headers();
|
|
4432
|
-
return addHeapObject(ret);
|
|
4433
|
-
}, arguments);
|
|
4434
|
-
};
|
|
4435
|
-
|
|
4436
|
-
module.exports.__wbg_new_23a2665fac83c611 = function (arg0, arg1) {
|
|
4437
|
-
try {
|
|
4438
|
-
var state0 = { a: arg0, b: arg1 };
|
|
4439
|
-
var cb0 = (arg0, arg1) => {
|
|
4440
|
-
const a = state0.a;
|
|
4441
|
-
state0.a = 0;
|
|
4442
|
-
try {
|
|
4443
|
-
return __wbg_adapter_341(a, state0.b, arg0, arg1);
|
|
4444
|
-
} finally {
|
|
4445
|
-
state0.a = a;
|
|
4446
|
-
}
|
|
4447
|
-
};
|
|
4448
|
-
const ret = new Promise(cb0);
|
|
4449
|
-
return addHeapObject(ret);
|
|
4450
|
-
} finally {
|
|
4451
|
-
state0.a = state0.b = 0;
|
|
4452
|
-
}
|
|
4453
|
-
};
|
|
4454
|
-
|
|
4455
|
-
module.exports.__wbg_new_405e22f390576ce2 = function () {
|
|
4456
|
-
const ret = new Object();
|
|
4457
|
-
return addHeapObject(ret);
|
|
4458
|
-
};
|
|
4459
|
-
|
|
4460
|
-
module.exports.__wbg_new_5e0be73521bc8c17 = function () {
|
|
4461
|
-
const ret = new Map();
|
|
4462
|
-
return addHeapObject(ret);
|
|
4463
|
-
};
|
|
4464
|
-
|
|
4465
|
-
module.exports.__wbg_new_78feb108b6472713 = function () {
|
|
4466
|
-
const ret = new Array();
|
|
4467
|
-
return addHeapObject(ret);
|
|
4468
|
-
};
|
|
4469
|
-
|
|
4470
|
-
module.exports.__wbg_new_8a6f238a6ece86ea = function () {
|
|
4471
|
-
const ret = new Error();
|
|
4472
|
-
return addHeapObject(ret);
|
|
4473
|
-
};
|
|
4474
|
-
|
|
4475
|
-
module.exports.__wbg_new_9fd39a253424609a = function () {
|
|
4476
|
-
return handleError(function () {
|
|
4477
|
-
const ret = new FormData();
|
|
4478
|
-
return addHeapObject(ret);
|
|
4479
|
-
}, arguments);
|
|
4480
|
-
};
|
|
4481
|
-
|
|
4482
|
-
module.exports.__wbg_new_a12002a7f91c75be = function (arg0) {
|
|
4483
|
-
const ret = new Uint8Array(getObject(arg0));
|
|
4484
|
-
return addHeapObject(ret);
|
|
4485
|
-
};
|
|
4486
|
-
|
|
4487
|
-
module.exports.__wbg_new_c68d7209be747379 = function (arg0, arg1) {
|
|
4488
|
-
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
4489
|
-
return addHeapObject(ret);
|
|
4490
|
-
};
|
|
4491
|
-
|
|
4492
|
-
module.exports.__wbg_new_e25e5aab09ff45db = function () {
|
|
4493
|
-
return handleError(function () {
|
|
4494
|
-
const ret = new AbortController();
|
|
4495
|
-
return addHeapObject(ret);
|
|
4496
|
-
}, arguments);
|
|
4497
|
-
};
|
|
4498
|
-
|
|
4499
|
-
module.exports.__wbg_new_f24b6d53abe5bc82 = function (arg0, arg1) {
|
|
4500
|
-
let deferred0_0;
|
|
4501
|
-
let deferred0_1;
|
|
4502
|
-
try {
|
|
4503
|
-
deferred0_0 = arg0;
|
|
4504
|
-
deferred0_1 = arg1;
|
|
4505
|
-
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
4506
|
-
return addHeapObject(ret);
|
|
4507
|
-
} finally {
|
|
4508
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4509
|
-
}
|
|
4510
|
-
};
|
|
4511
|
-
|
|
4512
|
-
module.exports.__wbg_newnoargs_105ed471475aaf50 = function (arg0, arg1) {
|
|
4513
|
-
const ret = new Function(getStringFromWasm0(arg0, arg1));
|
|
4514
|
-
return addHeapObject(ret);
|
|
4515
|
-
};
|
|
4516
|
-
|
|
4517
|
-
module.exports.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function (arg0, arg1, arg2) {
|
|
4518
|
-
const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
|
|
4519
|
-
return addHeapObject(ret);
|
|
4520
|
-
};
|
|
4521
|
-
|
|
4522
|
-
module.exports.__wbg_newwithlength_a381634e90c276d4 = function (arg0) {
|
|
4523
|
-
const ret = new Uint8Array(arg0 >>> 0);
|
|
4524
|
-
return addHeapObject(ret);
|
|
4525
|
-
};
|
|
4526
|
-
|
|
4527
|
-
module.exports.__wbg_newwithstrandinit_06c535e0a867c635 = function () {
|
|
4528
|
-
return handleError(function (arg0, arg1, arg2) {
|
|
4529
|
-
const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
|
|
4530
|
-
return addHeapObject(ret);
|
|
4531
|
-
}, arguments);
|
|
4532
|
-
};
|
|
4533
|
-
|
|
4534
|
-
module.exports.__wbg_newwithu8arraysequenceandoptions_068570c487f69127 = function () {
|
|
4535
|
-
return handleError(function (arg0, arg1) {
|
|
4536
|
-
const ret = new Blob(getObject(arg0), getObject(arg1));
|
|
4537
|
-
return addHeapObject(ret);
|
|
4538
|
-
}, arguments);
|
|
4539
|
-
};
|
|
4540
|
-
|
|
4541
|
-
module.exports.__wbg_next_25feadfc0913fea9 = function (arg0) {
|
|
4542
|
-
const ret = getObject(arg0).next;
|
|
4543
|
-
return addHeapObject(ret);
|
|
4544
|
-
};
|
|
4545
|
-
|
|
4546
|
-
module.exports.__wbg_next_6574e1a8a62d1055 = function () {
|
|
4547
|
-
return handleError(function (arg0) {
|
|
4548
|
-
const ret = getObject(arg0).next();
|
|
4549
|
-
return addHeapObject(ret);
|
|
4550
|
-
}, arguments);
|
|
4551
|
-
};
|
|
4552
|
-
|
|
4553
|
-
module.exports.__wbg_node_905d3e251edff8a2 = function (arg0) {
|
|
4554
|
-
const ret = getObject(arg0).node;
|
|
4555
|
-
return addHeapObject(ret);
|
|
4556
|
-
};
|
|
4557
|
-
|
|
4558
|
-
module.exports.__wbg_open_e0c0b2993eb596e1 = function () {
|
|
4559
|
-
return handleError(function (arg0, arg1, arg2, arg3) {
|
|
4560
|
-
const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
|
|
4561
|
-
return addHeapObject(ret);
|
|
4562
|
-
}, arguments);
|
|
4563
|
-
};
|
|
4564
|
-
|
|
4565
|
-
module.exports.__wbg_parse_def2e24ef1252aff = function () {
|
|
4566
|
-
return handleError(function (arg0, arg1) {
|
|
4567
|
-
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
|
|
4568
|
-
return addHeapObject(ret);
|
|
4569
|
-
}, arguments);
|
|
4570
|
-
};
|
|
4571
|
-
|
|
4572
|
-
module.exports.__wbg_preventDefault_c2314fd813c02b3c = function (arg0) {
|
|
4573
|
-
getObject(arg0).preventDefault();
|
|
4574
|
-
};
|
|
4575
|
-
|
|
4576
|
-
module.exports.__wbg_process_dc0fbacc7c1c06f7 = function (arg0) {
|
|
4577
|
-
const ret = getObject(arg0).process;
|
|
4578
|
-
return addHeapObject(ret);
|
|
4579
|
-
};
|
|
4580
|
-
|
|
4581
|
-
module.exports.__wbg_push_737cfc8c1432c2c6 = function (arg0, arg1) {
|
|
4582
|
-
const ret = getObject(arg0).push(getObject(arg1));
|
|
4583
|
-
return ret;
|
|
4584
|
-
};
|
|
4585
|
-
|
|
4586
|
-
module.exports.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function (arg0) {
|
|
4587
|
-
queueMicrotask(getObject(arg0));
|
|
4588
|
-
};
|
|
4589
|
-
|
|
4590
|
-
module.exports.__wbg_queueMicrotask_d3219def82552485 = function (arg0) {
|
|
4591
|
-
const ret = getObject(arg0).queueMicrotask;
|
|
4592
|
-
return addHeapObject(ret);
|
|
4593
|
-
};
|
|
4594
|
-
|
|
4595
|
-
module.exports.__wbg_randomFillSync_ac0988aba3254290 = function () {
|
|
4596
|
-
return handleError(function (arg0, arg1) {
|
|
4597
|
-
getObject(arg0).randomFillSync(takeObject(arg1));
|
|
4598
|
-
}, arguments);
|
|
4599
|
-
};
|
|
4600
|
-
|
|
4601
|
-
module.exports.__wbg_remove_1c1b50b9bf38bc51 = function () {
|
|
4602
|
-
return handleError(function (arg0, arg1, arg2) {
|
|
4603
|
-
let deferred0_0;
|
|
4604
|
-
let deferred0_1;
|
|
4605
|
-
try {
|
|
4606
|
-
deferred0_0 = arg1;
|
|
4607
|
-
deferred0_1 = arg2;
|
|
4608
|
-
const ret = getObject(arg0).remove(getStringFromWasm0(arg1, arg2));
|
|
4609
|
-
return addHeapObject(ret);
|
|
4610
|
-
} finally {
|
|
4611
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4612
|
-
}
|
|
4613
|
-
}, arguments);
|
|
4614
|
-
};
|
|
4615
|
-
|
|
4616
|
-
module.exports.__wbg_remove_4b3cf4f7afe73576 = function () {
|
|
4617
|
-
return handleError(function (arg0, arg1, arg2) {
|
|
4618
|
-
let deferred0_0;
|
|
4619
|
-
let deferred0_1;
|
|
4620
|
-
try {
|
|
4621
|
-
deferred0_0 = arg1;
|
|
4622
|
-
deferred0_1 = arg2;
|
|
4623
|
-
const ret = getObject(arg0).remove(getStringFromWasm0(arg1, arg2));
|
|
4624
|
-
return addHeapObject(ret);
|
|
4625
|
-
} finally {
|
|
4626
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4627
|
-
}
|
|
4628
|
-
}, arguments);
|
|
4629
|
-
};
|
|
4630
|
-
|
|
4631
|
-
module.exports.__wbg_require_60cc747a6bc5215a = function () {
|
|
4632
|
-
return handleError(function () {
|
|
4633
|
-
const ret = module.require;
|
|
4634
|
-
return addHeapObject(ret);
|
|
4635
|
-
}, arguments);
|
|
4636
|
-
};
|
|
4637
|
-
|
|
4638
|
-
module.exports.__wbg_resolve_4851785c9c5f573d = function (arg0) {
|
|
4639
|
-
const ret = Promise.resolve(getObject(arg0));
|
|
4640
|
-
return addHeapObject(ret);
|
|
4641
|
-
};
|
|
4642
|
-
|
|
4643
|
-
module.exports.__wbg_result_f29afabdf2c05826 = function () {
|
|
4644
|
-
return handleError(function (arg0) {
|
|
4645
|
-
const ret = getObject(arg0).result;
|
|
4646
|
-
return addHeapObject(ret);
|
|
4647
|
-
}, arguments);
|
|
4648
|
-
};
|
|
4649
|
-
|
|
4650
|
-
module.exports.__wbg_send_9b8fc6bb517867dd = function () {
|
|
4651
|
-
return handleError(function (arg0, arg1) {
|
|
4652
|
-
const ret = getObject(arg0).send(OutgoingMessage.__wrap(arg1));
|
|
4653
|
-
return addHeapObject(ret);
|
|
4654
|
-
}, arguments);
|
|
4655
|
-
};
|
|
4656
|
-
|
|
4657
|
-
module.exports.__wbg_setTimeout_ca12ead8b48245e2 = function (arg0, arg1) {
|
|
4658
|
-
const ret = setTimeout(getObject(arg0), arg1);
|
|
4659
|
-
return addHeapObject(ret);
|
|
4660
|
-
};
|
|
4661
|
-
|
|
4662
|
-
module.exports.__wbg_set_2e60c99bdc750300 = function () {
|
|
4663
|
-
return handleError(function (arg0, arg1, arg2, arg3) {
|
|
4664
|
-
let deferred0_0;
|
|
4665
|
-
let deferred0_1;
|
|
4666
|
-
try {
|
|
4667
|
-
deferred0_0 = arg1;
|
|
4668
|
-
deferred0_1 = arg2;
|
|
4669
|
-
const ret = getObject(arg0).set(getStringFromWasm0(arg1, arg2), takeObject(arg3));
|
|
4670
|
-
return addHeapObject(ret);
|
|
4671
|
-
} finally {
|
|
4672
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4673
|
-
}
|
|
4674
|
-
}, arguments);
|
|
4675
|
-
};
|
|
4676
|
-
|
|
4677
|
-
module.exports.__wbg_set_37837023f3d740e8 = function (arg0, arg1, arg2) {
|
|
4678
|
-
getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
|
|
4679
|
-
};
|
|
4680
|
-
|
|
4681
|
-
module.exports.__wbg_set_3f1d0b984ed272ed = function (arg0, arg1, arg2) {
|
|
4682
|
-
getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
|
|
4683
|
-
};
|
|
4684
|
-
|
|
4685
|
-
module.exports.__wbg_set_65595bdd868b3009 = function (arg0, arg1, arg2) {
|
|
4686
|
-
getObject(arg0).set(getObject(arg1), arg2 >>> 0);
|
|
4687
|
-
};
|
|
4688
|
-
|
|
4689
|
-
module.exports.__wbg_set_8fc6bf8a5b1071d1 = function (arg0, arg1, arg2) {
|
|
4690
|
-
const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
|
|
4691
|
-
return addHeapObject(ret);
|
|
4692
|
-
};
|
|
4693
|
-
|
|
4694
|
-
module.exports.__wbg_set_9456d5eb5e2f74d0 = function () {
|
|
4695
|
-
return handleError(function (arg0, arg1, arg2, arg3) {
|
|
4696
|
-
let deferred0_0;
|
|
4697
|
-
let deferred0_1;
|
|
4698
|
-
try {
|
|
4699
|
-
deferred0_0 = arg1;
|
|
4700
|
-
deferred0_1 = arg2;
|
|
4701
|
-
const ret = getObject(arg0).set(getStringFromWasm0(arg1, arg2), takeObject(arg3));
|
|
4702
|
-
return addHeapObject(ret);
|
|
4703
|
-
} finally {
|
|
4704
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4705
|
-
}
|
|
4706
|
-
}, arguments);
|
|
4707
|
-
};
|
|
4708
|
-
|
|
4709
|
-
module.exports.__wbg_setbody_5923b78a95eedf29 = function (arg0, arg1) {
|
|
4710
|
-
getObject(arg0).body = getObject(arg1);
|
|
4711
|
-
};
|
|
4712
|
-
|
|
4713
|
-
module.exports.__wbg_setcredentials_c3a22f1cd105a2c6 = function (arg0, arg1) {
|
|
4714
|
-
getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
|
|
4715
|
-
};
|
|
4716
|
-
|
|
4717
|
-
module.exports.__wbg_setheaders_834c0bdb6a8949ad = function (arg0, arg1) {
|
|
4718
|
-
getObject(arg0).headers = getObject(arg1);
|
|
4719
|
-
};
|
|
4720
|
-
|
|
4721
|
-
module.exports.__wbg_setmethod_3c5280fe5d890842 = function (arg0, arg1, arg2) {
|
|
4722
|
-
getObject(arg0).method = getStringFromWasm0(arg1, arg2);
|
|
4723
|
-
};
|
|
4724
|
-
|
|
4725
|
-
module.exports.__wbg_setmode_5dc300b865044b65 = function (arg0, arg1) {
|
|
4726
|
-
getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
|
|
4727
|
-
};
|
|
4728
|
-
|
|
4729
|
-
module.exports.__wbg_setname_c0e2d6f348c746f4 = function (arg0, arg1, arg2) {
|
|
4730
|
-
let deferred0_0;
|
|
4731
|
-
let deferred0_1;
|
|
4732
|
-
try {
|
|
4733
|
-
deferred0_0 = arg1;
|
|
4734
|
-
deferred0_1 = arg2;
|
|
4735
|
-
getObject(arg0).name = getStringFromWasm0(arg1, arg2);
|
|
4736
|
-
} finally {
|
|
4737
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4738
|
-
}
|
|
4739
|
-
};
|
|
4740
|
-
|
|
4741
|
-
module.exports.__wbg_setonerror_d7e3056cc6e56085 = function (arg0, arg1) {
|
|
4742
|
-
getObject(arg0).onerror = getObject(arg1);
|
|
4743
|
-
};
|
|
4744
|
-
|
|
4745
|
-
module.exports.__wbg_setonsuccess_afa464ee777a396d = function (arg0, arg1) {
|
|
4746
|
-
getObject(arg0).onsuccess = getObject(arg1);
|
|
4747
|
-
};
|
|
4748
|
-
|
|
4749
|
-
module.exports.__wbg_setonupgradeneeded_fcf7ce4f2eb0cb5f = function (arg0, arg1) {
|
|
4750
|
-
getObject(arg0).onupgradeneeded = getObject(arg1);
|
|
4751
|
-
};
|
|
4752
|
-
|
|
4753
|
-
module.exports.__wbg_setsignal_75b21ef3a81de905 = function (arg0, arg1) {
|
|
4754
|
-
getObject(arg0).signal = getObject(arg1);
|
|
4755
|
-
};
|
|
4756
|
-
|
|
4757
|
-
module.exports.__wbg_settype_39ed370d3edd403c = function (arg0, arg1, arg2) {
|
|
4758
|
-
getObject(arg0).type = getStringFromWasm0(arg1, arg2);
|
|
4759
|
-
};
|
|
4760
|
-
|
|
4761
|
-
module.exports.__wbg_setvariant_d1d41b778dfe9c17 = function (arg0, arg1, arg2) {
|
|
4762
|
-
let deferred0_0;
|
|
4763
|
-
let deferred0_1;
|
|
4764
|
-
try {
|
|
4765
|
-
deferred0_0 = arg1;
|
|
4766
|
-
deferred0_1 = arg2;
|
|
4767
|
-
getObject(arg0).variant = getStringFromWasm0(arg1, arg2);
|
|
4768
|
-
} finally {
|
|
4769
|
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
4770
|
-
}
|
|
4771
|
-
};
|
|
4772
|
-
|
|
4773
|
-
module.exports.__wbg_signal_aaf9ad74119f20a4 = function (arg0) {
|
|
4774
|
-
const ret = getObject(arg0).signal;
|
|
4775
|
-
return addHeapObject(ret);
|
|
4776
|
-
};
|
|
4777
|
-
|
|
4778
|
-
module.exports.__wbg_stack_0ed75d68575b0f3c = function (arg0, arg1) {
|
|
4779
|
-
const ret = getObject(arg1).stack;
|
|
4780
|
-
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4781
|
-
const len1 = WASM_VECTOR_LEN;
|
|
4782
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4783
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4784
|
-
};
|
|
4785
|
-
|
|
4786
|
-
module.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function () {
|
|
4787
|
-
const ret = typeof global === "undefined" ? null : global;
|
|
4788
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4789
|
-
};
|
|
4790
|
-
|
|
4791
|
-
module.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function () {
|
|
4792
|
-
const ret = typeof globalThis === "undefined" ? null : globalThis;
|
|
4793
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4794
|
-
};
|
|
4795
|
-
|
|
4796
|
-
module.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function () {
|
|
4797
|
-
const ret = typeof self === "undefined" ? null : self;
|
|
4798
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4799
|
-
};
|
|
4800
|
-
|
|
4801
|
-
module.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function () {
|
|
4802
|
-
const ret = typeof window === "undefined" ? null : window;
|
|
4803
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4804
|
-
};
|
|
4805
|
-
|
|
4806
|
-
module.exports.__wbg_status_f6360336ca686bf0 = function (arg0) {
|
|
4807
|
-
const ret = getObject(arg0).status;
|
|
4808
|
-
return ret;
|
|
4809
|
-
};
|
|
4810
|
-
|
|
4811
|
-
module.exports.__wbg_stringify_f7ed6987935b4a24 = function () {
|
|
4812
|
-
return handleError(function (arg0) {
|
|
4813
|
-
const ret = JSON.stringify(getObject(arg0));
|
|
4814
|
-
return addHeapObject(ret);
|
|
4815
|
-
}, arguments);
|
|
4816
|
-
};
|
|
4817
|
-
|
|
4818
|
-
module.exports.__wbg_subarray_aa9065fa9dc5df96 = function (arg0, arg1, arg2) {
|
|
4819
|
-
const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
|
|
4820
|
-
return addHeapObject(ret);
|
|
4821
|
-
};
|
|
4822
|
-
|
|
4823
|
-
module.exports.__wbg_target_0a62d9d79a2a1ede = function (arg0) {
|
|
4824
|
-
const ret = getObject(arg0).target;
|
|
4825
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4826
|
-
};
|
|
4827
|
-
|
|
4828
|
-
module.exports.__wbg_text_7805bea50de2af49 = function () {
|
|
4829
|
-
return handleError(function (arg0) {
|
|
4830
|
-
const ret = getObject(arg0).text();
|
|
4831
|
-
return addHeapObject(ret);
|
|
4832
|
-
}, arguments);
|
|
4833
|
-
};
|
|
4834
|
-
|
|
4835
|
-
module.exports.__wbg_then_44b73946d2fb3e7d = function (arg0, arg1) {
|
|
4836
|
-
const ret = getObject(arg0).then(getObject(arg1));
|
|
4837
|
-
return addHeapObject(ret);
|
|
4838
|
-
};
|
|
4839
|
-
|
|
4840
|
-
module.exports.__wbg_then_48b406749878a531 = function (arg0, arg1, arg2) {
|
|
4841
|
-
const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
|
|
4842
|
-
return addHeapObject(ret);
|
|
4843
|
-
};
|
|
4844
|
-
|
|
4845
|
-
module.exports.__wbg_transaction_e713aa7b07ccaedd = function (arg0) {
|
|
4846
|
-
const ret = getObject(arg0).transaction;
|
|
4847
|
-
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
4848
|
-
};
|
|
4849
|
-
|
|
4850
|
-
module.exports.__wbg_url_ae10c34ca209681d = function (arg0, arg1) {
|
|
4851
|
-
const ret = getObject(arg1).url;
|
|
4852
|
-
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4853
|
-
const len1 = WASM_VECTOR_LEN;
|
|
4854
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4855
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4856
|
-
};
|
|
4857
|
-
|
|
4858
|
-
module.exports.__wbg_value_cd1ffa7b1ab794f1 = function (arg0) {
|
|
4859
|
-
const ret = getObject(arg0).value;
|
|
4860
|
-
return addHeapObject(ret);
|
|
4861
|
-
};
|
|
4862
|
-
|
|
4863
|
-
module.exports.__wbg_versions_c01dfd4722a88165 = function (arg0) {
|
|
4864
|
-
const ret = getObject(arg0).versions;
|
|
4865
|
-
return addHeapObject(ret);
|
|
4866
|
-
};
|
|
4867
|
-
|
|
4868
|
-
module.exports.__wbg_warn_aaf1f4664a035bd6 = function (arg0, arg1, arg2, arg3) {
|
|
4869
|
-
console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
|
|
4870
|
-
};
|
|
4871
|
-
|
|
4872
|
-
module.exports.__wbindgen_array_new = function () {
|
|
4873
|
-
const ret = [];
|
|
4874
|
-
return addHeapObject(ret);
|
|
4875
|
-
};
|
|
4876
|
-
|
|
4877
|
-
module.exports.__wbindgen_array_push = function (arg0, arg1) {
|
|
4878
|
-
getObject(arg0).push(takeObject(arg1));
|
|
4879
|
-
};
|
|
4880
|
-
|
|
4881
|
-
module.exports.__wbindgen_as_number = function (arg0) {
|
|
4882
|
-
const ret = +getObject(arg0);
|
|
4883
|
-
return ret;
|
|
4884
|
-
};
|
|
4885
|
-
|
|
4886
|
-
module.exports.__wbindgen_bigint_from_i64 = function (arg0) {
|
|
4887
|
-
const ret = arg0;
|
|
4888
|
-
return addHeapObject(ret);
|
|
4889
|
-
};
|
|
4890
|
-
|
|
4891
|
-
module.exports.__wbindgen_bigint_from_u64 = function (arg0) {
|
|
4892
|
-
const ret = BigInt.asUintN(64, arg0);
|
|
4893
|
-
return addHeapObject(ret);
|
|
4894
|
-
};
|
|
4895
|
-
|
|
4896
|
-
module.exports.__wbindgen_bigint_get_as_i64 = function (arg0, arg1) {
|
|
4897
|
-
const v = getObject(arg1);
|
|
4898
|
-
const ret = typeof v === "bigint" ? v : undefined;
|
|
4899
|
-
getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
|
|
4900
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
4901
|
-
};
|
|
4902
|
-
|
|
4903
|
-
module.exports.__wbindgen_boolean_get = function (arg0) {
|
|
4904
|
-
const v = getObject(arg0);
|
|
4905
|
-
const ret = typeof v === "boolean" ? (v ? 1 : 0) : 2;
|
|
4906
|
-
return ret;
|
|
4907
|
-
};
|
|
4908
|
-
|
|
4909
|
-
module.exports.__wbindgen_cb_drop = function (arg0) {
|
|
4910
|
-
const obj = takeObject(arg0).original;
|
|
4911
|
-
if (obj.cnt-- == 1) {
|
|
4912
|
-
obj.a = 0;
|
|
4913
|
-
return true;
|
|
4914
|
-
}
|
|
4915
|
-
const ret = false;
|
|
4916
|
-
return ret;
|
|
4917
|
-
};
|
|
4918
|
-
|
|
4919
|
-
module.exports.__wbindgen_closure_wrapper193 = function (arg0, arg1, arg2) {
|
|
4920
|
-
const ret = makeMutClosure(arg0, arg1, 7, __wbg_adapter_54);
|
|
4921
|
-
return addHeapObject(ret);
|
|
4922
|
-
};
|
|
4923
|
-
|
|
4924
|
-
module.exports.__wbindgen_closure_wrapper195 = function (arg0, arg1, arg2) {
|
|
4925
|
-
const ret = makeMutClosure(arg0, arg1, 7, __wbg_adapter_57);
|
|
4926
|
-
return addHeapObject(ret);
|
|
4927
|
-
};
|
|
4928
|
-
|
|
4929
|
-
module.exports.__wbindgen_closure_wrapper3848 = function (arg0, arg1, arg2) {
|
|
4930
|
-
const ret = makeMutClosure(arg0, arg1, 294, __wbg_adapter_60);
|
|
4931
|
-
return addHeapObject(ret);
|
|
4932
|
-
};
|
|
4933
|
-
|
|
4934
|
-
module.exports.__wbindgen_closure_wrapper6177 = function (arg0, arg1, arg2) {
|
|
4935
|
-
const ret = makeMutClosure(arg0, arg1, 319, __wbg_adapter_60);
|
|
4936
|
-
return addHeapObject(ret);
|
|
4937
|
-
};
|
|
4938
|
-
|
|
4939
|
-
module.exports.__wbindgen_closure_wrapper6556 = function (arg0, arg1, arg2) {
|
|
4940
|
-
const ret = makeMutClosure(arg0, arg1, 342, __wbg_adapter_54);
|
|
4941
|
-
return addHeapObject(ret);
|
|
4942
|
-
};
|
|
4943
|
-
|
|
4944
|
-
module.exports.__wbindgen_debug_string = function (arg0, arg1) {
|
|
4945
|
-
const ret = debugString(getObject(arg1));
|
|
4946
|
-
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4947
|
-
const len1 = WASM_VECTOR_LEN;
|
|
4948
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4949
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4950
|
-
};
|
|
4951
|
-
|
|
4952
|
-
module.exports.__wbindgen_error_new = function (arg0, arg1) {
|
|
4953
|
-
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
4954
|
-
return addHeapObject(ret);
|
|
4955
|
-
};
|
|
4956
|
-
|
|
4957
|
-
module.exports.__wbindgen_in = function (arg0, arg1) {
|
|
4958
|
-
const ret = getObject(arg0) in getObject(arg1);
|
|
4959
|
-
return ret;
|
|
4960
|
-
};
|
|
4961
|
-
|
|
4962
|
-
module.exports.__wbindgen_is_bigint = function (arg0) {
|
|
4963
|
-
const ret = typeof getObject(arg0) === "bigint";
|
|
4964
|
-
return ret;
|
|
4965
|
-
};
|
|
4966
|
-
|
|
4967
|
-
module.exports.__wbindgen_is_function = function (arg0) {
|
|
4968
|
-
const ret = typeof getObject(arg0) === "function";
|
|
4969
|
-
return ret;
|
|
4970
|
-
};
|
|
4971
|
-
|
|
4972
|
-
module.exports.__wbindgen_is_object = function (arg0) {
|
|
4973
|
-
const val = getObject(arg0);
|
|
4974
|
-
const ret = typeof val === "object" && val !== null;
|
|
4975
|
-
return ret;
|
|
4976
|
-
};
|
|
4977
|
-
|
|
4978
|
-
module.exports.__wbindgen_is_string = function (arg0) {
|
|
4979
|
-
const ret = typeof getObject(arg0) === "string";
|
|
4980
|
-
return ret;
|
|
4981
|
-
};
|
|
4982
|
-
|
|
4983
|
-
module.exports.__wbindgen_is_undefined = function (arg0) {
|
|
4984
|
-
const ret = getObject(arg0) === undefined;
|
|
4985
|
-
return ret;
|
|
4986
|
-
};
|
|
4987
|
-
|
|
4988
|
-
module.exports.__wbindgen_jsval_eq = function (arg0, arg1) {
|
|
4989
|
-
const ret = getObject(arg0) === getObject(arg1);
|
|
4990
|
-
return ret;
|
|
4991
|
-
};
|
|
4992
|
-
|
|
4993
|
-
module.exports.__wbindgen_jsval_loose_eq = function (arg0, arg1) {
|
|
4994
|
-
const ret = getObject(arg0) == getObject(arg1);
|
|
4995
|
-
return ret;
|
|
4996
|
-
};
|
|
4997
|
-
|
|
4998
|
-
module.exports.__wbindgen_memory = function () {
|
|
4999
|
-
const ret = wasm.memory;
|
|
5000
|
-
return addHeapObject(ret);
|
|
5001
|
-
};
|
|
5002
|
-
|
|
5003
|
-
module.exports.__wbindgen_number_get = function (arg0, arg1) {
|
|
5004
|
-
const obj = getObject(arg1);
|
|
5005
|
-
const ret = typeof obj === "number" ? obj : undefined;
|
|
5006
|
-
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
|
|
5007
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
5008
|
-
};
|
|
5009
|
-
|
|
5010
|
-
module.exports.__wbindgen_number_new = function (arg0) {
|
|
5011
|
-
const ret = arg0;
|
|
5012
|
-
return addHeapObject(ret);
|
|
5013
|
-
};
|
|
5014
|
-
|
|
5015
|
-
module.exports.__wbindgen_object_clone_ref = function (arg0) {
|
|
5016
|
-
const ret = getObject(arg0);
|
|
5017
|
-
return addHeapObject(ret);
|
|
5018
|
-
};
|
|
5019
|
-
|
|
5020
|
-
module.exports.__wbindgen_object_drop_ref = function (arg0) {
|
|
5021
|
-
takeObject(arg0);
|
|
5022
|
-
};
|
|
5023
|
-
|
|
5024
|
-
module.exports.__wbindgen_string_get = function (arg0, arg1) {
|
|
5025
|
-
const obj = getObject(arg1);
|
|
5026
|
-
const ret = typeof obj === "string" ? obj : undefined;
|
|
5027
|
-
var ptr1 = isLikeNone(ret)
|
|
5028
|
-
? 0
|
|
5029
|
-
: passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
5030
|
-
var len1 = WASM_VECTOR_LEN;
|
|
5031
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
5032
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
5033
|
-
};
|
|
5034
|
-
|
|
5035
|
-
module.exports.__wbindgen_string_new = function (arg0, arg1) {
|
|
5036
|
-
const ret = getStringFromWasm0(arg0, arg1);
|
|
5037
|
-
return addHeapObject(ret);
|
|
5038
|
-
};
|
|
5039
|
-
|
|
5040
|
-
module.exports.__wbindgen_throw = function (arg0, arg1) {
|
|
5041
|
-
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
5042
|
-
};
|
|
5043
|
-
|
|
5044
|
-
const path = require("path").join(__dirname, "bitwarden_wasm_internal_bg.wasm");
|
|
5045
|
-
const bytes = require("fs").readFileSync(path);
|
|
5046
|
-
|
|
5047
|
-
const wasmModule = new WebAssembly.Module(bytes);
|
|
5048
|
-
const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
|
|
5049
|
-
wasm = wasmInstance.exports;
|
|
5050
|
-
module.exports.__wasm = wasm;
|