phirepass-channel 0.1.342 → 0.1.343

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 CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "phirepass-channel",
3
3
  "type": "module",
4
- "version": "0.1.342",
4
+ "version": "0.1.343",
5
5
  "license": "SEE LICENSE IN ../LICENCE",
6
6
  "repository": {
7
7
  "type": "git",
@@ -32,6 +32,10 @@ export class Channel {
32
32
  open_rdp_tunnel(node_id: string, service_id: string, username?: string | null, password?: string | null, msg_id?: number | null): void;
33
33
  open_sftp_tunnel(node_id: string, service_id: string, username?: string | null, password?: string | null, msg_id?: number | null): void;
34
34
  open_ssh_tunnel(node_id: string, service_id: string, username?: string | null, password?: string | null, msg_id?: number | null): void;
35
+ /**
36
+ * Set permission bits. The agent masks these to `0o7777`.
37
+ */
38
+ send_sftp_chmod(node_id: string, sid: number, path: string, permissions: number, msg_id?: number | null): void;
35
39
  send_sftp_delete(node_id: string, sid: number, path: string, filename: string, msg_id?: number | null): void;
36
40
  /**
37
41
  * Send a pipelining ACK to the agent: acknowledges all chunks with index ≤ ack_up_to
@@ -42,8 +46,31 @@ export class Channel {
42
46
  send_sftp_download_chunk(node_id: string, sid: number, download_id: number, chunk_index: number, msg_id?: number | null): void;
43
47
  send_sftp_download_start(node_id: string, sid: number, path: string, filename: string, msg_id?: number | null): void;
44
48
  send_sftp_list_data(node_id: string, sid: number, path: string, msg_id?: number | null): void;
49
+ /**
50
+ * Create one directory. Parents must exist already, as with `mkdir`.
51
+ */
52
+ send_sftp_mkdir(node_id: string, sid: number, path: string, msg_id?: number | null): void;
53
+ /**
54
+ * Read a whole file for the in-page editor. Answered with an
55
+ * `SFTPOpResult` carrying `FileContents`, or an `Error` if the file is
56
+ * above the agent's editor size limit.
57
+ */
58
+ send_sftp_read_file(node_id: string, sid: number, path: string, msg_id?: number | null): void;
59
+ /**
60
+ * Remove a file, a symlink, or a directory. Without `recursive` the remote
61
+ * refuses a directory that still has anything in it.
62
+ */
63
+ send_sftp_remove(node_id: string, sid: number, path: string, recursive: boolean, msg_id?: number | null): void;
64
+ /**
65
+ * Rename or move. `to` is a full path, so one call covers both.
66
+ */
67
+ send_sftp_rename(node_id: string, sid: number, from: string, to: string, msg_id?: number | null): void;
45
68
  send_sftp_upload_chunk(node_id: string, sid: number, upload_id: number, chunk_index: number, chunk_size: number, data: Uint8Array, msg_id?: number | null): void;
46
69
  send_sftp_upload_start(node_id: string, sid: number, filename: string, remote_path: string, total_chunks: number, total_size: bigint, msg_id?: number | null): void;
70
+ /**
71
+ * Write a whole file back, truncating whatever was there.
72
+ */
73
+ send_sftp_write_file(node_id: string, sid: number, path: string, contents: Uint8Array, msg_id?: number | null): void;
47
74
  send_ssh_terminal_resize(node_id: string, sid: number, cols: number, rows: number, px_width: number, px_height: number): void;
48
75
  send_ssh_tunnel_data(node_id: string, sid: number, data: string): void;
49
76
  start_heartbeat(interval_as_millis: number): void;
@@ -89,23 +116,29 @@ export interface InitOutput {
89
116
  readonly channel_open_rdp_tunnel: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
90
117
  readonly channel_open_sftp_tunnel: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
91
118
  readonly channel_open_ssh_tunnel: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
119
+ readonly channel_send_sftp_chmod: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
92
120
  readonly channel_send_sftp_delete: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
93
121
  readonly channel_send_sftp_download_ack: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
94
122
  readonly channel_send_sftp_download_chunk: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
95
123
  readonly channel_send_sftp_download_start: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
96
124
  readonly channel_send_sftp_list_data: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
125
+ readonly channel_send_sftp_mkdir: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
126
+ readonly channel_send_sftp_read_file: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
127
+ readonly channel_send_sftp_remove: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
128
+ readonly channel_send_sftp_rename: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
97
129
  readonly channel_send_sftp_upload_chunk: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
98
130
  readonly channel_send_sftp_upload_start: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: bigint, k: number) => void;
131
+ readonly channel_send_sftp_write_file: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
99
132
  readonly channel_send_ssh_terminal_resize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
100
133
  readonly channel_send_ssh_tunnel_data: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
101
134
  readonly channel_start_heartbeat: (a: number, b: number) => void;
102
135
  readonly channel_stop_heartbeat: (a: number) => void;
103
136
  readonly channel_update_service: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number) => void;
104
137
  readonly version: (a: number) => void;
105
- readonly __wasm_bindgen_func_elem_59: (a: number, b: number, c: number) => void;
106
- readonly __wasm_bindgen_func_elem_59_1: (a: number, b: number, c: number) => void;
107
- readonly __wasm_bindgen_func_elem_59_2: (a: number, b: number, c: number) => void;
108
- readonly __wasm_bindgen_func_elem_63: (a: number, b: number) => void;
138
+ readonly __wasm_bindgen_func_elem_60: (a: number, b: number, c: number) => void;
139
+ readonly __wasm_bindgen_func_elem_60_37: (a: number, b: number, c: number) => void;
140
+ readonly __wasm_bindgen_func_elem_60_38: (a: number, b: number, c: number) => void;
141
+ readonly __wasm_bindgen_func_elem_64: (a: number, b: number) => void;
109
142
  readonly __wbindgen_export: (a: number, b: number) => number;
110
143
  readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
111
144
  readonly __wbindgen_export3: (a: number) => void;
@@ -202,6 +202,21 @@ export class Channel {
202
202
  var len3 = WASM_VECTOR_LEN;
203
203
  wasm.channel_open_ssh_tunnel(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
204
204
  }
205
+ /**
206
+ * Set permission bits. The agent masks these to `0o7777`.
207
+ * @param {string} node_id
208
+ * @param {number} sid
209
+ * @param {string} path
210
+ * @param {number} permissions
211
+ * @param {number | null} [msg_id]
212
+ */
213
+ send_sftp_chmod(node_id, sid, path, permissions, msg_id) {
214
+ const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
215
+ const len0 = WASM_VECTOR_LEN;
216
+ const ptr1 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
217
+ const len1 = WASM_VECTOR_LEN;
218
+ wasm.channel_send_sftp_chmod(this.__wbg_ptr, ptr0, len0, sid, ptr1, len1, permissions, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
219
+ }
205
220
  /**
206
221
  * @param {string} node_id
207
222
  * @param {number} sid
@@ -273,6 +288,69 @@ export class Channel {
273
288
  const len1 = WASM_VECTOR_LEN;
274
289
  wasm.channel_send_sftp_list_data(this.__wbg_ptr, ptr0, len0, sid, ptr1, len1, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
275
290
  }
291
+ /**
292
+ * Create one directory. Parents must exist already, as with `mkdir`.
293
+ * @param {string} node_id
294
+ * @param {number} sid
295
+ * @param {string} path
296
+ * @param {number | null} [msg_id]
297
+ */
298
+ send_sftp_mkdir(node_id, sid, path, msg_id) {
299
+ const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
300
+ const len0 = WASM_VECTOR_LEN;
301
+ const ptr1 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
302
+ const len1 = WASM_VECTOR_LEN;
303
+ wasm.channel_send_sftp_mkdir(this.__wbg_ptr, ptr0, len0, sid, ptr1, len1, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
304
+ }
305
+ /**
306
+ * Read a whole file for the in-page editor. Answered with an
307
+ * `SFTPOpResult` carrying `FileContents`, or an `Error` if the file is
308
+ * above the agent's editor size limit.
309
+ * @param {string} node_id
310
+ * @param {number} sid
311
+ * @param {string} path
312
+ * @param {number | null} [msg_id]
313
+ */
314
+ send_sftp_read_file(node_id, sid, path, msg_id) {
315
+ const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
316
+ const len0 = WASM_VECTOR_LEN;
317
+ const ptr1 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
318
+ const len1 = WASM_VECTOR_LEN;
319
+ wasm.channel_send_sftp_read_file(this.__wbg_ptr, ptr0, len0, sid, ptr1, len1, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
320
+ }
321
+ /**
322
+ * Remove a file, a symlink, or a directory. Without `recursive` the remote
323
+ * refuses a directory that still has anything in it.
324
+ * @param {string} node_id
325
+ * @param {number} sid
326
+ * @param {string} path
327
+ * @param {boolean} recursive
328
+ * @param {number | null} [msg_id]
329
+ */
330
+ send_sftp_remove(node_id, sid, path, recursive, msg_id) {
331
+ const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
332
+ const len0 = WASM_VECTOR_LEN;
333
+ const ptr1 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
334
+ const len1 = WASM_VECTOR_LEN;
335
+ wasm.channel_send_sftp_remove(this.__wbg_ptr, ptr0, len0, sid, ptr1, len1, recursive, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
336
+ }
337
+ /**
338
+ * Rename or move. `to` is a full path, so one call covers both.
339
+ * @param {string} node_id
340
+ * @param {number} sid
341
+ * @param {string} from
342
+ * @param {string} to
343
+ * @param {number | null} [msg_id]
344
+ */
345
+ send_sftp_rename(node_id, sid, from, to, msg_id) {
346
+ const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
347
+ const len0 = WASM_VECTOR_LEN;
348
+ const ptr1 = passStringToWasm0(from, wasm.__wbindgen_export, wasm.__wbindgen_export2);
349
+ const len1 = WASM_VECTOR_LEN;
350
+ const ptr2 = passStringToWasm0(to, wasm.__wbindgen_export, wasm.__wbindgen_export2);
351
+ const len2 = WASM_VECTOR_LEN;
352
+ wasm.channel_send_sftp_rename(this.__wbg_ptr, ptr0, len0, sid, ptr1, len1, ptr2, len2, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
353
+ }
276
354
  /**
277
355
  * @param {string} node_id
278
356
  * @param {number} sid
@@ -307,6 +385,23 @@ export class Channel {
307
385
  const len2 = WASM_VECTOR_LEN;
308
386
  wasm.channel_send_sftp_upload_start(this.__wbg_ptr, ptr0, len0, sid, ptr1, len1, ptr2, len2, total_chunks, total_size, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
309
387
  }
388
+ /**
389
+ * Write a whole file back, truncating whatever was there.
390
+ * @param {string} node_id
391
+ * @param {number} sid
392
+ * @param {string} path
393
+ * @param {Uint8Array} contents
394
+ * @param {number | null} [msg_id]
395
+ */
396
+ send_sftp_write_file(node_id, sid, path, contents, msg_id) {
397
+ const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
398
+ const len0 = WASM_VECTOR_LEN;
399
+ const ptr1 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
400
+ const len1 = WASM_VECTOR_LEN;
401
+ const ptr2 = passArray8ToWasm0(contents, wasm.__wbindgen_export);
402
+ const len2 = WASM_VECTOR_LEN;
403
+ wasm.channel_send_sftp_write_file(this.__wbg_ptr, ptr0, len0, sid, ptr1, len1, ptr2, len2, isLikeNone(msg_id) ? Number.MAX_SAFE_INTEGER : (msg_id) >>> 0);
404
+ }
310
405
  /**
311
406
  * @param {string} node_id
312
407
  * @param {number} sid
@@ -417,7 +512,7 @@ export function version() {
417
512
  function __wbg_get_imports() {
418
513
  const import0 = {
419
514
  __proto__: null,
420
- __wbg_Error_408e67f47ca7b58b: function(arg0, arg1) {
515
+ __wbg_Error_67e7344beaa85059: function(arg0, arg1) {
421
516
  const ret = Error(getStringFromWasm0(arg0, arg1));
422
517
  return addHeapObject(ret);
423
518
  },
@@ -428,14 +523,14 @@ function __wbg_get_imports() {
428
523
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
429
524
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
430
525
  },
431
- __wbg___wbindgen_debug_string_a57024b9c6e4a48b: function(arg0, arg1) {
526
+ __wbg___wbindgen_debug_string_0e68cf47c9cbd9b0: function(arg0, arg1) {
432
527
  const ret = debugString(getObject(arg1));
433
528
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
434
529
  const len1 = WASM_VECTOR_LEN;
435
530
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
436
531
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
437
532
  },
438
- __wbg___wbindgen_string_get_d154f1e671052120: function(arg0, arg1) {
533
+ __wbg___wbindgen_string_get_92ab86bb19cbc12f: function(arg0, arg1) {
439
534
  const obj = getObject(arg1);
440
535
  const ret = typeof(obj) === 'string' ? obj : undefined;
441
536
  var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -443,50 +538,50 @@ function __wbg_get_imports() {
443
538
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
444
539
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
445
540
  },
446
- __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
541
+ __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
447
542
  throw new Error(getStringFromWasm0(arg0, arg1));
448
543
  },
449
- __wbg__wbg_cb_unref_be22cc64ae6946a0: function(arg0) {
544
+ __wbg__wbg_cb_unref_997e73d32238e655: function(arg0) {
450
545
  getObject(arg0)._wbg_cb_unref();
451
546
  },
452
- __wbg_call_0f2a9af232c18fd2: function() { return handleError(function (arg0, arg1, arg2, arg3) {
453
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
454
- return addHeapObject(ret);
455
- }, arguments); },
456
- __wbg_call_1c5886ab9c57d1c7: function() { return handleError(function (arg0, arg1) {
547
+ __wbg_call_269c5566fbede3eb: function() { return handleError(function (arg0, arg1) {
457
548
  const ret = getObject(arg0).call(getObject(arg1));
458
549
  return addHeapObject(ret);
459
550
  }, arguments); },
460
- __wbg_call_35dba3c747ad7521: function() { return handleError(function (arg0, arg1, arg2) {
551
+ __wbg_call_6bcf8d3e20937e46: function() { return handleError(function (arg0, arg1, arg2) {
461
552
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
462
553
  return addHeapObject(ret);
463
554
  }, arguments); },
555
+ __wbg_call_7bbd9cceba9949ad: function() { return handleError(function (arg0, arg1, arg2, arg3) {
556
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
557
+ return addHeapObject(ret);
558
+ }, arguments); },
464
559
  __wbg_clearInterval_26ba580547547579: function(arg0) {
465
560
  const ret = clearInterval(takeObject(arg0));
466
561
  return addHeapObject(ret);
467
562
  },
468
- __wbg_close_b857478a8d4c1a16: function() { return handleError(function (arg0) {
563
+ __wbg_close_a009f540ff811039: function() { return handleError(function (arg0) {
469
564
  getObject(arg0).close();
470
565
  }, arguments); },
471
- __wbg_data_57d8ce4eb5f0a433: function(arg0) {
566
+ __wbg_data_aa7ba49b34c0d883: function(arg0) {
472
567
  const ret = getObject(arg0).data;
473
568
  return addHeapObject(ret);
474
569
  },
475
- __wbg_from_74f3d90e0ff11240: function(arg0) {
570
+ __wbg_from_a39669ce566077da: function(arg0) {
476
571
  const ret = Array.from(getObject(arg0));
477
572
  return addHeapObject(ret);
478
573
  },
479
574
  __wbg_getRandomValues_a608c4436c19407a: function() { return handleError(function (arg0, arg1) {
480
575
  globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
481
576
  }, arguments); },
482
- __wbg_get_971a0c45d172643f: function() { return handleError(function (arg0, arg1) {
577
+ __wbg_get_989d0a1309644f2b: function() { return handleError(function (arg0, arg1) {
483
578
  const ret = Reflect.get(getObject(arg0), getObject(arg1));
484
579
  return addHeapObject(ret);
485
580
  }, arguments); },
486
- __wbg_info_6523fb53a6d13c24: function(arg0, arg1) {
581
+ __wbg_info_2e056059f76306ee: function(arg0, arg1) {
487
582
  console.info(getStringFromWasm0(arg0, arg1));
488
583
  },
489
- __wbg_instanceof_ArrayBuffer_993d02d2d254cad1: function(arg0) {
584
+ __wbg_instanceof_ArrayBuffer_d4ff01f8247925ae: function(arg0) {
490
585
  let result;
491
586
  try {
492
587
  result = getObject(arg0) instanceof ArrayBuffer;
@@ -496,104 +591,104 @@ function __wbg_get_imports() {
496
591
  const ret = result;
497
592
  return ret;
498
593
  },
499
- __wbg_length_36bd29c6848c2144: function(arg0) {
594
+ __wbg_length_31bdaf014f5fbde2: function(arg0) {
500
595
  const ret = getObject(arg0).length;
501
596
  return ret;
502
597
  },
503
- __wbg_new_116be93542d39019: function() {
504
- const ret = new Array();
505
- return addHeapObject(ret);
506
- },
507
- __wbg_new_77cc4f4f472aeb81: function(arg0) {
598
+ __wbg_new_1da3429bc3c4541c: function(arg0) {
508
599
  const ret = new Uint8Array(getObject(arg0));
509
600
  return addHeapObject(ret);
510
601
  },
511
- __wbg_new_ebe3e0f6837f0879: function() {
602
+ __wbg_new_bebc3f4757acf305: function() {
512
603
  const ret = new Object();
513
604
  return addHeapObject(ret);
514
605
  },
515
- __wbg_new_with_str_sequence_d8aa2988e9c191ed: function() { return handleError(function (arg0, arg1, arg2) {
606
+ __wbg_new_ffa92086ea89f79c: function() {
607
+ const ret = new Array();
608
+ return addHeapObject(ret);
609
+ },
610
+ __wbg_new_with_str_sequence_9ab4875494df9d99: function() { return handleError(function (arg0, arg1, arg2) {
516
611
  const ret = new WebSocket(getStringFromWasm0(arg0, arg1), getObject(arg2));
517
612
  return addHeapObject(ret);
518
613
  }, arguments); },
519
- __wbg_prototypesetcall_de8e0d9553586985: function(arg0, arg1, arg2) {
614
+ __wbg_prototypesetcall_ae9f5e7459250748: function(arg0, arg1, arg2) {
520
615
  Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
521
616
  },
522
- __wbg_push_adb0107829f02d75: function(arg0, arg1) {
617
+ __wbg_push_bfdf956ba476f65b: function(arg0, arg1) {
523
618
  const ret = getObject(arg0).push(getObject(arg1));
524
619
  return ret;
525
620
  },
526
- __wbg_readyState_fe79161592fd15ce: function(arg0) {
621
+ __wbg_readyState_83df235b27cf257f: function(arg0) {
527
622
  const ret = getObject(arg0).readyState;
528
623
  return ret;
529
624
  },
530
- __wbg_send_76be66dda8ee844c: function() { return handleError(function (arg0, arg1, arg2) {
625
+ __wbg_send_af811d92e7aea5c4: function() { return handleError(function (arg0, arg1, arg2) {
531
626
  getObject(arg0).send(getArrayU8FromWasm0(arg1, arg2));
532
627
  }, arguments); },
533
628
  __wbg_setInterval_cbf1c35c6a692d37: function() { return handleError(function (arg0, arg1) {
534
629
  const ret = setInterval(getObject(arg0), arg1);
535
630
  return addHeapObject(ret);
536
631
  }, arguments); },
632
+ __wbg_set_13d25b81ab403f5e: function(arg0, arg1, arg2) {
633
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
634
+ },
537
635
  __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
538
636
  getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
539
637
  },
540
- __wbg_set_a80955eb93b145c6: function(arg0, arg1, arg2) {
541
- getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
542
- },
543
- __wbg_set_binaryType_b701908a03166a9f: function(arg0, arg1) {
638
+ __wbg_set_binaryType_f88804219cea0f9e: function(arg0, arg1) {
544
639
  getObject(arg0).binaryType = __wbindgen_enum_BinaryType[arg1];
545
640
  },
546
- __wbg_set_onclose_cb71fea4ad9056fc: function(arg0, arg1) {
641
+ __wbg_set_onclose_97aab74a1c2662f7: function(arg0, arg1) {
547
642
  getObject(arg0).onclose = getObject(arg1);
548
643
  },
549
- __wbg_set_onerror_f1491b13f0fea022: function(arg0, arg1) {
644
+ __wbg_set_onerror_88cb2134dca3aba2: function(arg0, arg1) {
550
645
  getObject(arg0).onerror = getObject(arg1);
551
646
  },
552
- __wbg_set_onmessage_065a797dafa9c437: function(arg0, arg1) {
647
+ __wbg_set_onmessage_0f0d391465909a45: function(arg0, arg1) {
553
648
  getObject(arg0).onmessage = getObject(arg1);
554
649
  },
555
- __wbg_set_onopen_b28699f3431204cf: function(arg0, arg1) {
650
+ __wbg_set_onopen_e91e64af99b7966d: function(arg0, arg1) {
556
651
  getObject(arg0).onopen = getObject(arg1);
557
652
  },
558
- __wbg_warn_d37b8b80308e18bf: function(arg0, arg1) {
653
+ __wbg_warn_96e906f1333ed2d6: function(arg0, arg1) {
559
654
  console.warn(getStringFromWasm0(arg0, arg1));
560
655
  },
561
- __wbindgen_cast_0000000000000001: function(arg0, arg1) {
656
+ __wbindgen_generic_0000000000000001: function(arg0, arg1) {
562
657
  // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
563
- const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_59);
658
+ const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_60);
564
659
  return addHeapObject(ret);
565
660
  },
566
- __wbindgen_cast_0000000000000002: function(arg0, arg1) {
661
+ __wbindgen_generic_0000000000000002: function(arg0, arg1) {
567
662
  // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 1, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
568
- const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_59_1);
663
+ const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_60_37);
569
664
  return addHeapObject(ret);
570
665
  },
571
- __wbindgen_cast_0000000000000003: function(arg0, arg1) {
666
+ __wbindgen_generic_0000000000000003: function(arg0, arg1) {
572
667
  // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
573
- const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_59_2);
668
+ const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_60_38);
574
669
  return addHeapObject(ret);
575
670
  },
576
- __wbindgen_cast_0000000000000004: function(arg0, arg1) {
671
+ __wbindgen_generic_0000000000000004: function(arg0, arg1) {
577
672
  // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 5, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
578
- const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_63);
673
+ const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_64);
579
674
  return addHeapObject(ret);
580
675
  },
581
- __wbindgen_cast_0000000000000005: function(arg0) {
676
+ __wbindgen_generic_0000000000000005: function(arg0) {
582
677
  // Cast intrinsic for `F64 -> Externref`.
583
678
  const ret = arg0;
584
679
  return addHeapObject(ret);
585
680
  },
586
- __wbindgen_cast_0000000000000006: function(arg0, arg1) {
681
+ __wbindgen_generic_0000000000000006: function(arg0, arg1) {
587
682
  // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
588
683
  const ret = getArrayU8FromWasm0(arg0, arg1);
589
684
  return addHeapObject(ret);
590
685
  },
591
- __wbindgen_cast_0000000000000007: function(arg0, arg1) {
686
+ __wbindgen_generic_0000000000000007: function(arg0, arg1) {
592
687
  // Cast intrinsic for `Ref(String) -> Externref`.
593
688
  const ret = getStringFromWasm0(arg0, arg1);
594
689
  return addHeapObject(ret);
595
690
  },
596
- __wbindgen_cast_0000000000000008: function(arg0) {
691
+ __wbindgen_generic_0000000000000008: function(arg0) {
597
692
  // Cast intrinsic for `U64 -> Externref`.
598
693
  const ret = BigInt.asUintN(64, arg0);
599
694
  return addHeapObject(ret);
@@ -612,20 +707,20 @@ function __wbg_get_imports() {
612
707
  };
613
708
  }
614
709
 
615
- function __wasm_bindgen_func_elem_63(arg0, arg1) {
616
- wasm.__wasm_bindgen_func_elem_63(arg0, arg1);
710
+ function __wasm_bindgen_func_elem_64(arg0, arg1) {
711
+ wasm.__wasm_bindgen_func_elem_64(arg0, arg1);
617
712
  }
618
713
 
619
- function __wasm_bindgen_func_elem_59(arg0, arg1, arg2) {
620
- wasm.__wasm_bindgen_func_elem_59(arg0, arg1, addHeapObject(arg2));
714
+ function __wasm_bindgen_func_elem_60(arg0, arg1, arg2) {
715
+ wasm.__wasm_bindgen_func_elem_60(arg0, arg1, addHeapObject(arg2));
621
716
  }
622
717
 
623
- function __wasm_bindgen_func_elem_59_1(arg0, arg1, arg2) {
624
- wasm.__wasm_bindgen_func_elem_59_1(arg0, arg1, addHeapObject(arg2));
718
+ function __wasm_bindgen_func_elem_60_37(arg0, arg1, arg2) {
719
+ wasm.__wasm_bindgen_func_elem_60_37(arg0, arg1, addHeapObject(arg2));
625
720
  }
626
721
 
627
- function __wasm_bindgen_func_elem_59_2(arg0, arg1, arg2) {
628
- wasm.__wasm_bindgen_func_elem_59_2(arg0, arg1, addHeapObject(arg2));
722
+ function __wasm_bindgen_func_elem_60_38(arg0, arg1, arg2) {
723
+ wasm.__wasm_bindgen_func_elem_60_38(arg0, arg1, addHeapObject(arg2));
629
724
  }
630
725
 
631
726
 
Binary file