fleethub-core 1.11.3 → 1.11.5

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.
Files changed (9) hide show
  1. package/node/fleethub_core.d.ts +73 -73
  2. package/node/fleethub_core.js +471 -419
  3. package/node/fleethub_core_bg.wasm +0 -0
  4. package/node/fleethub_core_bg.wasm.d.ts +13 -13
  5. package/package.json +1 -1
  6. package/pkg/fleethub_core.d.ts +73 -73
  7. package/pkg/fleethub_core_bg.js +471 -419
  8. package/pkg/fleethub_core_bg.wasm +0 -0
  9. package/pkg/fleethub_core_bg.wasm.d.ts +13 -13
package/pkg/fleethub_core_bg.js CHANGED
@@ -23,6 +23,18 @@ function addHeapObject(obj) {
23
23
  return idx;
24
24
  }
25
25
 
26
+ function dropObject(idx) {
27
+ if (idx < 132) return;
28
+ heap[idx] = heap_next;
29
+ heap_next = idx;
30
+ }
31
+
32
+ function takeObject(idx) {
33
+ const ret = getObject(idx);
34
+ dropObject(idx);
35
+ return ret;
36
+ }
37
+
26
38
  const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
27
39
 
28
40
  let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -39,21 +51,10 @@ function getUint8Memory0() {
39
51
  }
40
52
 
41
53
  function getStringFromWasm0(ptr, len) {
54
+ ptr = ptr >>> 0;
42
55
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
43
56
  }
44
57
 
45
- function dropObject(idx) {
46
- if (idx < 132) return;
47
- heap[idx] = heap_next;
48
- heap_next = idx;
49
- }
50
-
51
- function takeObject(idx) {
52
- const ret = getObject(idx);
53
- dropObject(idx);
54
- return ret;
55
- }
56
-
57
58
  let WASM_VECTOR_LEN = 0;
58
59
 
59
60
  const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
@@ -77,14 +78,14 @@ function passStringToWasm0(arg, malloc, realloc) {
77
78
 
78
79
  if (realloc === undefined) {
79
80
  const buf = cachedTextEncoder.encode(arg);
80
- const ptr = malloc(buf.length);
81
+ const ptr = malloc(buf.length) >>> 0;
81
82
  getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
82
83
  WASM_VECTOR_LEN = buf.length;
83
84
  return ptr;
84
85
  }
85
86
 
86
87
  let len = arg.length;
87
- let ptr = malloc(len);
88
+ let ptr = malloc(len) >>> 0;
88
89
 
89
90
  const mem = getUint8Memory0();
90
91
 
@@ -100,7 +101,7 @@ function passStringToWasm0(arg, malloc, realloc) {
100
101
  if (offset !== 0) {
101
102
  arg = arg.slice(offset);
102
103
  }
103
- ptr = realloc(ptr, len, len = offset + arg.length * 3);
104
+ ptr = realloc(ptr, len, len = offset + arg.length * 3) >>> 0;
104
105
  const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
105
106
  const ret = encodeString(arg, view);
106
107
 
@@ -124,22 +125,6 @@ function getInt32Memory0() {
124
125
  return cachedInt32Memory0;
125
126
  }
126
127
 
127
- let cachedUint16Memory0 = null;
128
-
129
- function getUint16Memory0() {
130
- if (cachedUint16Memory0 === null || cachedUint16Memory0.byteLength === 0) {
131
- cachedUint16Memory0 = new Uint16Array(wasm.memory.buffer);
132
- }
133
- return cachedUint16Memory0;
134
- }
135
-
136
- function passArray16ToWasm0(arg, malloc) {
137
- const ptr = malloc(arg.length * 2);
138
- getUint16Memory0().set(arg, ptr / 2);
139
- WASM_VECTOR_LEN = arg.length;
140
- return ptr;
141
- }
142
-
143
128
  function _assertClass(instance, klass) {
144
129
  if (!(instance instanceof klass)) {
145
130
  throw new Error(`expected instance of ${klass.name}`);
@@ -156,6 +141,22 @@ function getFloat64Memory0() {
156
141
  return cachedFloat64Memory0;
157
142
  }
158
143
 
144
+ let cachedUint16Memory0 = null;
145
+
146
+ function getUint16Memory0() {
147
+ if (cachedUint16Memory0 === null || cachedUint16Memory0.byteLength === 0) {
148
+ cachedUint16Memory0 = new Uint16Array(wasm.memory.buffer);
149
+ }
150
+ return cachedUint16Memory0;
151
+ }
152
+
153
+ function passArray16ToWasm0(arg, malloc) {
154
+ const ptr = malloc(arg.length * 2) >>> 0;
155
+ getUint16Memory0().set(arg, ptr / 2);
156
+ WASM_VECTOR_LEN = arg.length;
157
+ return ptr;
158
+ }
159
+
159
160
  let cachedUint32Memory0 = null;
160
161
 
161
162
  function getUint32Memory0() {
@@ -166,6 +167,7 @@ function getUint32Memory0() {
166
167
  }
167
168
 
168
169
  function getArrayJsValueFromWasm0(ptr, len) {
170
+ ptr = ptr >>> 0;
169
171
  const mem = getUint32Memory0();
170
172
  const slice = mem.subarray(ptr / 4, ptr / 4 + len);
171
173
  const result = [];
@@ -176,6 +178,7 @@ function getArrayJsValueFromWasm0(ptr, len) {
176
178
  }
177
179
 
178
180
  function getArrayU16FromWasm0(ptr, len) {
181
+ ptr = ptr >>> 0;
179
182
  return getUint16Memory0().subarray(ptr / 2, ptr / 2 + len);
180
183
  }
181
184
  /**
@@ -194,11 +197,12 @@ export function set_panic_hook() {
194
197
  }
195
198
 
196
199
  function getArrayU8FromWasm0(ptr, len) {
200
+ ptr = ptr >>> 0;
197
201
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
198
202
  }
199
203
 
200
204
  function passArray8ToWasm0(arg, malloc) {
201
- const ptr = malloc(arg.length * 1);
205
+ const ptr = malloc(arg.length * 1) >>> 0;
202
206
  getUint8Memory0().set(arg, ptr / 1);
203
207
  WASM_VECTOR_LEN = arg.length;
204
208
  return ptr;
@@ -212,21 +216,22 @@ function handleError(f, args) {
212
216
  }
213
217
  }
214
218
 
215
- const AirSquadronFinalization = new FinalizationRegistry(ptr => wasm.__wbg_airsquadron_free(ptr));
219
+ const AirSquadronFinalization = new FinalizationRegistry(ptr => wasm.__wbg_airsquadron_free(ptr >>> 0));
216
220
  /**
217
221
  */
218
222
  export class AirSquadron {
219
223
 
220
224
  static __wrap(ptr) {
225
+ ptr = ptr >>> 0;
221
226
  const obj = Object.create(AirSquadron.prototype);
222
- obj.ptr = ptr;
223
- AirSquadronFinalization.register(obj, obj.ptr, obj);
227
+ obj.__wbg_ptr = ptr;
228
+ AirSquadronFinalization.register(obj, obj.__wbg_ptr, obj);
224
229
  return obj;
225
230
  }
226
231
 
227
232
  __destroy_into_raw() {
228
- const ptr = this.ptr;
229
- this.ptr = 0;
233
+ const ptr = this.__wbg_ptr;
234
+ this.__wbg_ptr = 0;
230
235
  AirSquadronFinalization.unregister(this);
231
236
  return ptr;
232
237
  }
@@ -239,15 +244,19 @@ export class AirSquadron {
239
244
  * @returns {string}
240
245
  */
241
246
  get id() {
247
+ let deferred1_0;
248
+ let deferred1_1;
242
249
  try {
243
250
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
244
- wasm.__wbg_get_airsquadron_id(retptr, this.ptr);
251
+ wasm.__wbg_get_airsquadron_id(retptr, this.__wbg_ptr);
245
252
  var r0 = getInt32Memory0()[retptr / 4 + 0];
246
253
  var r1 = getInt32Memory0()[retptr / 4 + 1];
254
+ deferred1_0 = r0;
255
+ deferred1_1 = r1;
247
256
  return getStringFromWasm0(r0, r1);
248
257
  } finally {
249
258
  wasm.__wbindgen_add_to_stack_pointer(16);
250
- wasm.__wbindgen_free(r0, r1);
259
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
251
260
  }
252
261
  }
253
262
  /**
@@ -256,33 +265,33 @@ export class AirSquadron {
256
265
  set id(arg0) {
257
266
  const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
258
267
  const len0 = WASM_VECTOR_LEN;
259
- wasm.__wbg_set_airsquadron_id(this.ptr, ptr0, len0);
268
+ wasm.__wbg_set_airsquadron_id(this.__wbg_ptr, ptr0, len0);
260
269
  }
261
270
  /**
262
271
  * @returns {bigint}
263
272
  */
264
273
  get hash() {
265
- const ret = wasm.__wbg_get_airsquadron_hash(this.ptr);
274
+ const ret = wasm.__wbg_get_airsquadron_hash(this.__wbg_ptr);
266
275
  return BigInt.asUintN(64, ret);
267
276
  }
268
277
  /**
269
278
  * @param {bigint} arg0
270
279
  */
271
280
  set hash(arg0) {
272
- wasm.__wbg_set_airsquadron_hash(this.ptr, arg0);
281
+ wasm.__wbg_set_airsquadron_hash(this.__wbg_ptr, arg0);
273
282
  }
274
283
  /**
275
284
  * @returns {AirSquadronMode}
276
285
  */
277
286
  get mode() {
278
- const ret = wasm.__wbg_get_airsquadron_mode(this.ptr);
287
+ const ret = wasm.__wbg_get_airsquadron_mode(this.__wbg_ptr);
279
288
  return takeObject(ret);
280
289
  }
281
290
  /**
282
291
  * @param {AirSquadronMode} arg0
283
292
  */
284
293
  set mode(arg0) {
285
- wasm.__wbg_set_airsquadron_mode(this.ptr, addHeapObject(arg0));
294
+ wasm.__wbg_set_airsquadron_mode(this.__wbg_ptr, addHeapObject(arg0));
286
295
  }
287
296
  /**
288
297
  * @param {string} key
@@ -291,7 +300,7 @@ export class AirSquadron {
291
300
  get_gear(key) {
292
301
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
293
302
  const len0 = WASM_VECTOR_LEN;
294
- const ret = wasm.airsquadron_get_gear(this.ptr, ptr0, len0);
303
+ const ret = wasm.airsquadron_get_gear(this.__wbg_ptr, ptr0, len0);
295
304
  return ret === 0 ? undefined : Gear.__wrap(ret);
296
305
  }
297
306
  /**
@@ -301,7 +310,7 @@ export class AirSquadron {
301
310
  get_slot_size(index) {
302
311
  try {
303
312
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
304
- wasm.airsquadron_get_slot_size(retptr, this.ptr, index);
313
+ wasm.airsquadron_get_slot_size(retptr, this.__wbg_ptr, index);
305
314
  var r0 = getInt32Memory0()[retptr / 4 + 0];
306
315
  var r1 = getInt32Memory0()[retptr / 4 + 1];
307
316
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -320,7 +329,7 @@ export class AirSquadron {
320
329
  get_max_slot_size(index) {
321
330
  try {
322
331
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
323
- wasm.airsquadron_get_max_slot_size(retptr, this.ptr, index);
332
+ wasm.airsquadron_get_max_slot_size(retptr, this.__wbg_ptr, index);
324
333
  var r0 = getInt32Memory0()[retptr / 4 + 0];
325
334
  var r1 = getInt32Memory0()[retptr / 4 + 1];
326
335
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -336,14 +345,14 @@ export class AirSquadron {
336
345
  * @returns {number}
337
346
  */
338
347
  fighter_power() {
339
- const ret = wasm.airsquadron_fighter_power(this.ptr);
348
+ const ret = wasm.airsquadron_fighter_power(this.__wbg_ptr);
340
349
  return ret;
341
350
  }
342
351
  /**
343
352
  * @returns {number}
344
353
  */
345
354
  interception_power() {
346
- const ret = wasm.airsquadron_interception_power(this.ptr);
355
+ const ret = wasm.airsquadron_interception_power(this.__wbg_ptr);
347
356
  return ret;
348
357
  }
349
358
  /**
@@ -351,26 +360,27 @@ export class AirSquadron {
351
360
  * @returns {number}
352
361
  */
353
362
  radius() {
354
- const ret = wasm.airsquadron_radius(this.ptr);
363
+ const ret = wasm.airsquadron_radius(this.__wbg_ptr);
355
364
  return ret;
356
365
  }
357
366
  }
358
367
 
359
- const AnalyzerFinalization = new FinalizationRegistry(ptr => wasm.__wbg_analyzer_free(ptr));
368
+ const AnalyzerFinalization = new FinalizationRegistry(ptr => wasm.__wbg_analyzer_free(ptr >>> 0));
360
369
  /**
361
370
  */
362
371
  export class Analyzer {
363
372
 
364
373
  static __wrap(ptr) {
374
+ ptr = ptr >>> 0;
365
375
  const obj = Object.create(Analyzer.prototype);
366
- obj.ptr = ptr;
367
- AnalyzerFinalization.register(obj, obj.ptr, obj);
376
+ obj.__wbg_ptr = ptr;
377
+ AnalyzerFinalization.register(obj, obj.__wbg_ptr, obj);
368
378
  return obj;
369
379
  }
370
380
 
371
381
  __destroy_into_raw() {
372
- const ptr = this.ptr;
373
- this.ptr = 0;
382
+ const ptr = this.__wbg_ptr;
383
+ this.__wbg_ptr = 0;
374
384
  AnalyzerFinalization.unregister(this);
375
385
  return ptr;
376
386
  }
@@ -389,7 +399,7 @@ export class Analyzer {
389
399
  analyze_ship_attack(config, left, right, attacker_is_left) {
390
400
  _assertClass(left, Ship);
391
401
  _assertClass(right, Ship);
392
- const ret = wasm.analyzer_analyze_ship_attack(this.ptr, addHeapObject(config), left.ptr, right.ptr, attacker_is_left);
402
+ const ret = wasm.analyzer_analyze_ship_attack(this.__wbg_ptr, addHeapObject(config), left.__wbg_ptr, right.__wbg_ptr, attacker_is_left);
393
403
  return takeObject(ret);
394
404
  }
395
405
  /**
@@ -405,7 +415,7 @@ export class Analyzer {
405
415
  _assertClass(left_ship, Ship);
406
416
  _assertClass(right_comp, Comp);
407
417
  _assertClass(right_ship, Ship);
408
- const ret = wasm.analyzer_analyze_node_attack(this.ptr, addHeapObject(config), left_comp.ptr, left_ship.ptr, right_comp.ptr, right_ship.ptr);
418
+ const ret = wasm.analyzer_analyze_node_attack(this.__wbg_ptr, addHeapObject(config), left_comp.__wbg_ptr, left_ship.__wbg_ptr, right_comp.__wbg_ptr, right_ship.__wbg_ptr);
409
419
  return takeObject(ret);
410
420
  }
411
421
  /**
@@ -415,7 +425,7 @@ export class Analyzer {
415
425
  */
416
426
  analyze_comp(comp, config) {
417
427
  _assertClass(comp, Comp);
418
- const ret = wasm.analyzer_analyze_comp(this.ptr, comp.ptr, addHeapObject(config));
428
+ const ret = wasm.analyzer_analyze_comp(this.__wbg_ptr, comp.__wbg_ptr, addHeapObject(config));
419
429
  return takeObject(ret);
420
430
  }
421
431
  /**
@@ -430,7 +440,7 @@ export class Analyzer {
430
440
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
431
441
  _assertClass(player_comp, Comp);
432
442
  _assertClass(enemy_comp, Comp);
433
- wasm.analyzer_simulate_support_shelling(retptr, this.ptr, player_comp.ptr, enemy_comp.ptr, addHeapObject(config), times);
443
+ wasm.analyzer_simulate_support_shelling(retptr, this.__wbg_ptr, player_comp.__wbg_ptr, enemy_comp.__wbg_ptr, addHeapObject(config), times);
434
444
  var r0 = getInt32Memory0()[retptr / 4 + 0];
435
445
  var r1 = getInt32Memory0()[retptr / 4 + 1];
436
446
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -444,21 +454,22 @@ export class Analyzer {
444
454
  }
445
455
  }
446
456
 
447
- const CompFinalization = new FinalizationRegistry(ptr => wasm.__wbg_comp_free(ptr));
457
+ const CompFinalization = new FinalizationRegistry(ptr => wasm.__wbg_comp_free(ptr >>> 0));
448
458
  /**
449
459
  */
450
460
  export class Comp {
451
461
 
452
462
  static __wrap(ptr) {
463
+ ptr = ptr >>> 0;
453
464
  const obj = Object.create(Comp.prototype);
454
- obj.ptr = ptr;
455
- CompFinalization.register(obj, obj.ptr, obj);
465
+ obj.__wbg_ptr = ptr;
466
+ CompFinalization.register(obj, obj.__wbg_ptr, obj);
456
467
  return obj;
457
468
  }
458
469
 
459
470
  __destroy_into_raw() {
460
- const ptr = this.ptr;
461
- this.ptr = 0;
471
+ const ptr = this.__wbg_ptr;
472
+ this.__wbg_ptr = 0;
462
473
  CompFinalization.unregister(this);
463
474
  return ptr;
464
475
  }
@@ -471,21 +482,21 @@ export class Comp {
471
482
  * @returns {OrgType}
472
483
  */
473
484
  get org_type() {
474
- const ret = wasm.__wbg_get_comp_org_type(this.ptr);
485
+ const ret = wasm.__wbg_get_comp_org_type(this.__wbg_ptr);
475
486
  return takeObject(ret);
476
487
  }
477
488
  /**
478
489
  * @returns {number}
479
490
  */
480
491
  get hq_level() {
481
- const ret = wasm.__wbg_get_comp_hq_level(this.ptr);
492
+ const ret = wasm.__wbg_get_comp_hq_level(this.__wbg_ptr);
482
493
  return ret;
483
494
  }
484
495
  /**
485
496
  * @returns {Fleet}
486
497
  */
487
498
  get main() {
488
- const ret = wasm.__wbg_get_comp_main(this.ptr);
499
+ const ret = wasm.__wbg_get_comp_main(this.__wbg_ptr);
489
500
  return Fleet.__wrap(ret);
490
501
  }
491
502
  /**
@@ -494,13 +505,13 @@ export class Comp {
494
505
  set main(arg0) {
495
506
  _assertClass(arg0, Fleet);
496
507
  var ptr0 = arg0.__destroy_into_raw();
497
- wasm.__wbg_set_comp_main(this.ptr, ptr0);
508
+ wasm.__wbg_set_comp_main(this.__wbg_ptr, ptr0);
498
509
  }
499
510
  /**
500
511
  * @returns {Fleet | undefined}
501
512
  */
502
513
  get escort() {
503
- const ret = wasm.__wbg_get_comp_escort(this.ptr);
514
+ const ret = wasm.__wbg_get_comp_escort(this.__wbg_ptr);
504
515
  return ret === 0 ? undefined : Fleet.__wrap(ret);
505
516
  }
506
517
  /**
@@ -512,13 +523,13 @@ export class Comp {
512
523
  _assertClass(arg0, Fleet);
513
524
  ptr0 = arg0.__destroy_into_raw();
514
525
  }
515
- wasm.__wbg_set_comp_escort(this.ptr, ptr0);
526
+ wasm.__wbg_set_comp_escort(this.__wbg_ptr, ptr0);
516
527
  }
517
528
  /**
518
529
  * @returns {Fleet | undefined}
519
530
  */
520
531
  get route_sup() {
521
- const ret = wasm.__wbg_get_comp_route_sup(this.ptr);
532
+ const ret = wasm.__wbg_get_comp_route_sup(this.__wbg_ptr);
522
533
  return ret === 0 ? undefined : Fleet.__wrap(ret);
523
534
  }
524
535
  /**
@@ -530,13 +541,13 @@ export class Comp {
530
541
  _assertClass(arg0, Fleet);
531
542
  ptr0 = arg0.__destroy_into_raw();
532
543
  }
533
- wasm.__wbg_set_comp_route_sup(this.ptr, ptr0);
544
+ wasm.__wbg_set_comp_route_sup(this.__wbg_ptr, ptr0);
534
545
  }
535
546
  /**
536
547
  * @returns {Fleet | undefined}
537
548
  */
538
549
  get boss_sup() {
539
- const ret = wasm.__wbg_get_comp_boss_sup(this.ptr);
550
+ const ret = wasm.__wbg_get_comp_boss_sup(this.__wbg_ptr);
540
551
  return ret === 0 ? undefined : Fleet.__wrap(ret);
541
552
  }
542
553
  /**
@@ -548,34 +559,34 @@ export class Comp {
548
559
  _assertClass(arg0, Fleet);
549
560
  ptr0 = arg0.__destroy_into_raw();
550
561
  }
551
- wasm.__wbg_set_comp_boss_sup(this.ptr, ptr0);
562
+ wasm.__wbg_set_comp_boss_sup(this.__wbg_ptr, ptr0);
552
563
  }
553
564
  /**
554
565
  * @returns {Side}
555
566
  */
556
567
  side() {
557
- const ret = wasm.comp_side(this.ptr);
568
+ const ret = wasm.comp_side(this.__wbg_ptr);
558
569
  return takeObject(ret);
559
570
  }
560
571
  /**
561
572
  * @returns {boolean}
562
573
  */
563
574
  is_combined() {
564
- const ret = wasm.comp_is_combined(this.ptr);
575
+ const ret = wasm.comp_is_combined(this.__wbg_ptr);
565
576
  return ret !== 0;
566
577
  }
567
578
  /**
568
579
  * @returns {boolean}
569
580
  */
570
581
  is_player() {
571
- const ret = wasm.comp_is_player(this.ptr);
582
+ const ret = wasm.comp_is_player(this.__wbg_ptr);
572
583
  return ret !== 0;
573
584
  }
574
585
  /**
575
586
  * @returns {boolean}
576
587
  */
577
588
  is_enemy() {
578
- const ret = wasm.comp_is_enemy(this.ptr);
589
+ const ret = wasm.comp_is_enemy(this.__wbg_ptr);
579
590
  return ret !== 0;
580
591
  }
581
592
  /**
@@ -585,7 +596,7 @@ export class Comp {
585
596
  has_ship_eid(id) {
586
597
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
587
598
  const len0 = WASM_VECTOR_LEN;
588
- const ret = wasm.comp_has_ship_eid(this.ptr, ptr0, len0);
599
+ const ret = wasm.comp_has_ship_eid(this.__wbg_ptr, ptr0, len0);
589
600
  return ret !== 0;
590
601
  }
591
602
  /**
@@ -594,15 +605,15 @@ export class Comp {
594
605
  first_ship_id() {
595
606
  try {
596
607
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
597
- wasm.comp_first_ship_id(retptr, this.ptr);
608
+ wasm.comp_first_ship_id(retptr, this.__wbg_ptr);
598
609
  var r0 = getInt32Memory0()[retptr / 4 + 0];
599
610
  var r1 = getInt32Memory0()[retptr / 4 + 1];
600
- let v0;
611
+ let v1;
601
612
  if (r0 !== 0) {
602
- v0 = getStringFromWasm0(r0, r1).slice();
613
+ v1 = getStringFromWasm0(r0, r1).slice();
603
614
  wasm.__wbindgen_free(r0, r1 * 1);
604
615
  }
605
- return v0;
616
+ return v1;
606
617
  } finally {
607
618
  wasm.__wbindgen_add_to_stack_pointer(16);
608
619
  }
@@ -611,14 +622,14 @@ export class Comp {
611
622
  * @returns {boolean}
612
623
  */
613
624
  has_route_sup() {
614
- const ret = wasm.comp_has_route_sup(this.ptr);
625
+ const ret = wasm.comp_has_route_sup(this.__wbg_ptr);
615
626
  return ret !== 0;
616
627
  }
617
628
  /**
618
629
  * @returns {CompMeta}
619
630
  */
620
631
  meta() {
621
- const ret = wasm.comp_meta(this.ptr);
632
+ const ret = wasm.comp_meta(this.__wbg_ptr);
622
633
  return takeObject(ret);
623
634
  }
624
635
  /**
@@ -628,15 +639,15 @@ export class Comp {
628
639
  get_fleet_id(ft) {
629
640
  try {
630
641
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
631
- wasm.comp_get_fleet_id(retptr, this.ptr, addHeapObject(ft));
642
+ wasm.comp_get_fleet_id(retptr, this.__wbg_ptr, addHeapObject(ft));
632
643
  var r0 = getInt32Memory0()[retptr / 4 + 0];
633
644
  var r1 = getInt32Memory0()[retptr / 4 + 1];
634
- let v0;
645
+ let v1;
635
646
  if (r0 !== 0) {
636
- v0 = getStringFromWasm0(r0, r1).slice();
647
+ v1 = getStringFromWasm0(r0, r1).slice();
637
648
  wasm.__wbindgen_free(r0, r1 * 1);
638
649
  }
639
- return v0;
650
+ return v1;
640
651
  } finally {
641
652
  wasm.__wbindgen_add_to_stack_pointer(16);
642
653
  }
@@ -647,7 +658,7 @@ export class Comp {
647
658
  * @returns {Ship | undefined}
648
659
  */
649
660
  get_ship_with_clone(ft, key) {
650
- const ret = wasm.comp_get_ship_with_clone(this.ptr, addHeapObject(ft), addHeapObject(key));
661
+ const ret = wasm.comp_get_ship_with_clone(this.__wbg_ptr, addHeapObject(ft), addHeapObject(key));
651
662
  return ret === 0 ? undefined : Ship.__wrap(ret);
652
663
  }
653
664
  /**
@@ -658,15 +669,15 @@ export class Comp {
658
669
  get_ship_entity_id(ft, key) {
659
670
  try {
660
671
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
661
- wasm.comp_get_ship_entity_id(retptr, this.ptr, addHeapObject(ft), addHeapObject(key));
672
+ wasm.comp_get_ship_entity_id(retptr, this.__wbg_ptr, addHeapObject(ft), addHeapObject(key));
662
673
  var r0 = getInt32Memory0()[retptr / 4 + 0];
663
674
  var r1 = getInt32Memory0()[retptr / 4 + 1];
664
- let v0;
675
+ let v1;
665
676
  if (r0 !== 0) {
666
- v0 = getStringFromWasm0(r0, r1).slice();
677
+ v1 = getStringFromWasm0(r0, r1).slice();
667
678
  wasm.__wbindgen_free(r0, r1 * 1);
668
679
  }
669
- return v0;
680
+ return v1;
670
681
  } finally {
671
682
  wasm.__wbindgen_add_to_stack_pointer(16);
672
683
  }
@@ -678,14 +689,14 @@ export class Comp {
678
689
  get_ship_by_eid_with_clone(id) {
679
690
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
680
691
  const len0 = WASM_VECTOR_LEN;
681
- const ret = wasm.comp_get_ship_by_eid_with_clone(this.ptr, ptr0, len0);
692
+ const ret = wasm.comp_get_ship_by_eid_with_clone(this.__wbg_ptr, ptr0, len0);
682
693
  return ret === 0 ? undefined : Ship.__wrap(ret);
683
694
  }
684
695
  /**
685
696
  * @returns {Formation}
686
697
  */
687
698
  default_formation() {
688
- const ret = wasm.comp_default_formation(this.ptr);
699
+ const ret = wasm.comp_default_formation(this.__wbg_ptr);
689
700
  return takeObject(ret);
690
701
  }
691
702
  /**
@@ -694,7 +705,7 @@ export class Comp {
694
705
  * @returns {number}
695
706
  */
696
707
  adjusted_anti_air(formation_mod) {
697
- const ret = wasm.comp_adjusted_anti_air(this.ptr, formation_mod);
708
+ const ret = wasm.comp_adjusted_anti_air(this.__wbg_ptr, formation_mod);
698
709
  return ret;
699
710
  }
700
711
  /**
@@ -706,7 +717,7 @@ export class Comp {
706
717
  fighter_power(escort_participates, air_type) {
707
718
  try {
708
719
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
709
- wasm.comp_fighter_power(retptr, this.ptr, escort_participates, addHeapObject(air_type));
720
+ wasm.comp_fighter_power(retptr, this.__wbg_ptr, escort_participates, addHeapObject(air_type));
710
721
  var r0 = getInt32Memory0()[retptr / 4 + 0];
711
722
  var r1 = getInt32Memory0()[retptr / 4 + 1];
712
723
  return r0 === 0 ? undefined : r1;
@@ -722,7 +733,7 @@ export class Comp {
722
733
  elos(node_divaricated_factor) {
723
734
  try {
724
735
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
725
- wasm.comp_elos(retptr, this.ptr, node_divaricated_factor);
736
+ wasm.comp_elos(retptr, this.__wbg_ptr, node_divaricated_factor);
726
737
  var r0 = getInt32Memory0()[retptr / 4 + 0];
727
738
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
728
739
  return r0 === 0 ? undefined : r2;
@@ -735,7 +746,7 @@ export class Comp {
735
746
  * @returns {number}
736
747
  */
737
748
  transport_point() {
738
- const ret = wasm.comp_transport_point(this.ptr);
749
+ const ret = wasm.comp_transport_point(this.__wbg_ptr);
739
750
  return ret;
740
751
  }
741
752
  /**
@@ -745,7 +756,7 @@ export class Comp {
745
756
  */
746
757
  get_ship_conditions(ship, formation) {
747
758
  _assertClass(ship, Ship);
748
- const ret = wasm.comp_get_ship_conditions(this.ptr, ship.ptr, isLikeNone(formation) ? 0 : addHeapObject(formation));
759
+ const ret = wasm.comp_get_ship_conditions(this.__wbg_ptr, ship.__wbg_ptr, isLikeNone(formation) ? 0 : addHeapObject(formation));
749
760
  return takeObject(ret);
750
761
  }
751
762
  /**
@@ -755,7 +766,7 @@ export class Comp {
755
766
  fleet_los_mod(fleet_type) {
756
767
  try {
757
768
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
758
- wasm.comp_fleet_los_mod(retptr, this.ptr, addHeapObject(fleet_type));
769
+ wasm.comp_fleet_los_mod(retptr, this.__wbg_ptr, addHeapObject(fleet_type));
759
770
  var r0 = getInt32Memory0()[retptr / 4 + 0];
760
771
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
761
772
  return r0 === 0 ? undefined : r2;
@@ -765,21 +776,22 @@ export class Comp {
765
776
  }
766
777
  }
767
778
 
768
- const FhCoreFinalization = new FinalizationRegistry(ptr => wasm.__wbg_fhcore_free(ptr));
779
+ const FhCoreFinalization = new FinalizationRegistry(ptr => wasm.__wbg_fhcore_free(ptr >>> 0));
769
780
  /**
770
781
  */
771
782
  export class FhCore {
772
783
 
773
784
  static __wrap(ptr) {
785
+ ptr = ptr >>> 0;
774
786
  const obj = Object.create(FhCore.prototype);
775
- obj.ptr = ptr;
776
- FhCoreFinalization.register(obj, obj.ptr, obj);
787
+ obj.__wbg_ptr = ptr;
788
+ FhCoreFinalization.register(obj, obj.__wbg_ptr, obj);
777
789
  return obj;
778
790
  }
779
791
 
780
792
  __destroy_into_raw() {
781
- const ptr = this.ptr;
782
- this.ptr = 0;
793
+ const ptr = this.__wbg_ptr;
794
+ this.__wbg_ptr = 0;
783
795
  FhCoreFinalization.unregister(this);
784
796
  return ptr;
785
797
  }
@@ -811,7 +823,7 @@ export class FhCore {
811
823
  * @returns {Gear | undefined}
812
824
  */
813
825
  create_gear(input) {
814
- const ret = wasm.fhcore_create_gear(this.ptr, isLikeNone(input) ? 0 : addHeapObject(input));
826
+ const ret = wasm.fhcore_create_gear(this.__wbg_ptr, isLikeNone(input) ? 0 : addHeapObject(input));
815
827
  return ret === 0 ? undefined : Gear.__wrap(ret);
816
828
  }
817
829
  /**
@@ -819,7 +831,7 @@ export class FhCore {
819
831
  * @returns {Ship | undefined}
820
832
  */
821
833
  create_ship(input) {
822
- const ret = wasm.fhcore_create_ship(this.ptr, isLikeNone(input) ? 0 : addHeapObject(input));
834
+ const ret = wasm.fhcore_create_ship(this.__wbg_ptr, isLikeNone(input) ? 0 : addHeapObject(input));
823
835
  return ret === 0 ? undefined : Ship.__wrap(ret);
824
836
  }
825
837
  /**
@@ -827,7 +839,7 @@ export class FhCore {
827
839
  * @returns {AirSquadron}
828
840
  */
829
841
  create_air_squadron(input) {
830
- const ret = wasm.fhcore_create_air_squadron(this.ptr, isLikeNone(input) ? 0 : addHeapObject(input));
842
+ const ret = wasm.fhcore_create_air_squadron(this.__wbg_ptr, isLikeNone(input) ? 0 : addHeapObject(input));
831
843
  return AirSquadron.__wrap(ret);
832
844
  }
833
845
  /**
@@ -835,7 +847,7 @@ export class FhCore {
835
847
  * @returns {Fleet}
836
848
  */
837
849
  create_fleet(input) {
838
- const ret = wasm.fhcore_create_fleet(this.ptr, isLikeNone(input) ? 0 : addHeapObject(input));
850
+ const ret = wasm.fhcore_create_fleet(this.__wbg_ptr, isLikeNone(input) ? 0 : addHeapObject(input));
839
851
  return Fleet.__wrap(ret);
840
852
  }
841
853
  /**
@@ -843,7 +855,7 @@ export class FhCore {
843
855
  * @returns {Org | undefined}
844
856
  */
845
857
  create_org(input) {
846
- const ret = wasm.fhcore_create_org(this.ptr, isLikeNone(input) ? 0 : addHeapObject(input));
858
+ const ret = wasm.fhcore_create_org(this.__wbg_ptr, isLikeNone(input) ? 0 : addHeapObject(input));
847
859
  return ret === 0 ? undefined : Org.__wrap(ret);
848
860
  }
849
861
  /**
@@ -851,14 +863,14 @@ export class FhCore {
851
863
  * @returns {Ship | undefined}
852
864
  */
853
865
  create_ship_by_id(ship_id) {
854
- const ret = wasm.fhcore_create_ship_by_id(this.ptr, ship_id);
866
+ const ret = wasm.fhcore_create_ship_by_id(this.__wbg_ptr, ship_id);
855
867
  return ret === 0 ? undefined : Ship.__wrap(ret);
856
868
  }
857
869
  /**
858
870
  * @returns {Ship[]}
859
871
  */
860
872
  create_all_ships() {
861
- const ret = wasm.fhcore_create_all_ships(this.ptr);
873
+ const ret = wasm.fhcore_create_all_ships(this.__wbg_ptr);
862
874
  return takeObject(ret);
863
875
  }
864
876
  /**
@@ -871,40 +883,41 @@ export class FhCore {
871
883
  const len0 = WASM_VECTOR_LEN;
872
884
  var ptr1 = isLikeNone(escort) ? 0 : passArray16ToWasm0(escort, wasm.__wbindgen_malloc);
873
885
  var len1 = WASM_VECTOR_LEN;
874
- const ret = wasm.fhcore_create_comp_by_map_enemy(this.ptr, ptr0, len0, ptr1, len1);
886
+ const ret = wasm.fhcore_create_comp_by_map_enemy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
875
887
  return Comp.__wrap(ret);
876
888
  }
877
889
  /**
878
890
  * @returns {Ship}
879
891
  */
880
892
  create_default_ship() {
881
- const ret = wasm.fhcore_create_default_ship(this.ptr);
893
+ const ret = wasm.fhcore_create_default_ship(this.__wbg_ptr);
882
894
  return Ship.__wrap(ret);
883
895
  }
884
896
  /**
885
897
  * @returns {Analyzer}
886
898
  */
887
899
  create_analyzer() {
888
- const ret = wasm.fhcore_create_analyzer(this.ptr);
900
+ const ret = wasm.fhcore_create_analyzer(this.__wbg_ptr);
889
901
  return Analyzer.__wrap(ret);
890
902
  }
891
903
  }
892
904
 
893
- const FleetFinalization = new FinalizationRegistry(ptr => wasm.__wbg_fleet_free(ptr));
905
+ const FleetFinalization = new FinalizationRegistry(ptr => wasm.__wbg_fleet_free(ptr >>> 0));
894
906
  /**
895
907
  */
896
908
  export class Fleet {
897
909
 
898
910
  static __wrap(ptr) {
911
+ ptr = ptr >>> 0;
899
912
  const obj = Object.create(Fleet.prototype);
900
- obj.ptr = ptr;
901
- FleetFinalization.register(obj, obj.ptr, obj);
913
+ obj.__wbg_ptr = ptr;
914
+ FleetFinalization.register(obj, obj.__wbg_ptr, obj);
902
915
  return obj;
903
916
  }
904
917
 
905
918
  __destroy_into_raw() {
906
- const ptr = this.ptr;
907
- this.ptr = 0;
919
+ const ptr = this.__wbg_ptr;
920
+ this.__wbg_ptr = 0;
908
921
  FleetFinalization.unregister(this);
909
922
  return ptr;
910
923
  }
@@ -917,15 +930,19 @@ export class Fleet {
917
930
  * @returns {string}
918
931
  */
919
932
  get id() {
933
+ let deferred1_0;
934
+ let deferred1_1;
920
935
  try {
921
936
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
922
- wasm.__wbg_get_fleet_id(retptr, this.ptr);
937
+ wasm.__wbg_get_fleet_id(retptr, this.__wbg_ptr);
923
938
  var r0 = getInt32Memory0()[retptr / 4 + 0];
924
939
  var r1 = getInt32Memory0()[retptr / 4 + 1];
940
+ deferred1_0 = r0;
941
+ deferred1_1 = r1;
925
942
  return getStringFromWasm0(r0, r1);
926
943
  } finally {
927
944
  wasm.__wbindgen_add_to_stack_pointer(16);
928
- wasm.__wbindgen_free(r0, r1);
945
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
929
946
  }
930
947
  }
931
948
  /**
@@ -934,27 +951,27 @@ export class Fleet {
934
951
  set id(arg0) {
935
952
  const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
936
953
  const len0 = WASM_VECTOR_LEN;
937
- wasm.__wbg_set_fleet_id(this.ptr, ptr0, len0);
954
+ wasm.__wbg_set_fleet_id(this.__wbg_ptr, ptr0, len0);
938
955
  }
939
956
  /**
940
957
  * @returns {bigint}
941
958
  */
942
959
  get hash() {
943
- const ret = wasm.__wbg_get_fleet_hash(this.ptr);
960
+ const ret = wasm.__wbg_get_fleet_hash(this.__wbg_ptr);
944
961
  return BigInt.asUintN(64, ret);
945
962
  }
946
963
  /**
947
964
  * @returns {number}
948
965
  */
949
966
  get len() {
950
- const ret = wasm.__wbg_get_fleet_len(this.ptr);
967
+ const ret = wasm.__wbg_get_fleet_len(this.__wbg_ptr);
951
968
  return ret >>> 0;
952
969
  }
953
970
  /**
954
971
  * @returns {FleetMeta}
955
972
  */
956
973
  meta() {
957
- const ret = wasm.fleet_meta(this.ptr);
974
+ const ret = wasm.fleet_meta(this.__wbg_ptr);
958
975
  return takeObject(ret);
959
976
  }
960
977
  /**
@@ -963,12 +980,12 @@ export class Fleet {
963
980
  ship_keys() {
964
981
  try {
965
982
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
966
- wasm.fleet_ship_keys(retptr, this.ptr);
983
+ wasm.fleet_ship_keys(retptr, this.__wbg_ptr);
967
984
  var r0 = getInt32Memory0()[retptr / 4 + 0];
968
985
  var r1 = getInt32Memory0()[retptr / 4 + 1];
969
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
986
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
970
987
  wasm.__wbindgen_free(r0, r1 * 4);
971
- return v0;
988
+ return v1;
972
989
  } finally {
973
990
  wasm.__wbindgen_add_to_stack_pointer(16);
974
991
  }
@@ -979,12 +996,12 @@ export class Fleet {
979
996
  ship_ids() {
980
997
  try {
981
998
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
982
- wasm.fleet_ship_ids(retptr, this.ptr);
999
+ wasm.fleet_ship_ids(retptr, this.__wbg_ptr);
983
1000
  var r0 = getInt32Memory0()[retptr / 4 + 0];
984
1001
  var r1 = getInt32Memory0()[retptr / 4 + 1];
985
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1002
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
986
1003
  wasm.__wbindgen_free(r0, r1 * 4);
987
- return v0;
1004
+ return v1;
988
1005
  } finally {
989
1006
  wasm.__wbindgen_add_to_stack_pointer(16);
990
1007
  }
@@ -995,12 +1012,12 @@ export class Fleet {
995
1012
  get_gear_ids_by_improvable() {
996
1013
  try {
997
1014
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
998
- wasm.fleet_get_gear_ids_by_improvable(retptr, this.ptr);
1015
+ wasm.fleet_get_gear_ids_by_improvable(retptr, this.__wbg_ptr);
999
1016
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1000
1017
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1001
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1018
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1002
1019
  wasm.__wbindgen_free(r0, r1 * 4);
1003
- return v0;
1020
+ return v1;
1004
1021
  } finally {
1005
1022
  wasm.__wbindgen_add_to_stack_pointer(16);
1006
1023
  }
@@ -1011,12 +1028,12 @@ export class Fleet {
1011
1028
  get_gear_ids_by_proficiency() {
1012
1029
  try {
1013
1030
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1014
- wasm.fleet_get_gear_ids_by_proficiency(retptr, this.ptr);
1031
+ wasm.fleet_get_gear_ids_by_proficiency(retptr, this.__wbg_ptr);
1015
1032
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1016
1033
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1017
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1034
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1018
1035
  wasm.__wbindgen_free(r0, r1 * 4);
1019
- return v0;
1036
+ return v1;
1020
1037
  } finally {
1021
1038
  wasm.__wbindgen_add_to_stack_pointer(16);
1022
1039
  }
@@ -1029,7 +1046,7 @@ export class Fleet {
1029
1046
  get_damage_bound(id, state) {
1030
1047
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1031
1048
  const len0 = WASM_VECTOR_LEN;
1032
- const ret = wasm.fleet_get_damage_bound(this.ptr, ptr0, len0, addHeapObject(state));
1049
+ const ret = wasm.fleet_get_damage_bound(this.__wbg_ptr, ptr0, len0, addHeapObject(state));
1033
1050
  return ret === 0xFFFFFF ? undefined : ret;
1034
1051
  }
1035
1052
  /**
@@ -1041,7 +1058,7 @@ export class Fleet {
1041
1058
  get_remaining_fuel(id, rate, ceil) {
1042
1059
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1043
1060
  const len0 = WASM_VECTOR_LEN;
1044
- const ret = wasm.fleet_get_remaining_fuel(this.ptr, ptr0, len0, rate, ceil);
1061
+ const ret = wasm.fleet_get_remaining_fuel(this.__wbg_ptr, ptr0, len0, rate, ceil);
1045
1062
  return ret === 0xFFFFFF ? undefined : ret;
1046
1063
  }
1047
1064
  /**
@@ -1053,14 +1070,14 @@ export class Fleet {
1053
1070
  get_remaining_ammo(id, rate, ceil) {
1054
1071
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1055
1072
  const len0 = WASM_VECTOR_LEN;
1056
- const ret = wasm.fleet_get_remaining_ammo(this.ptr, ptr0, len0, rate, ceil);
1073
+ const ret = wasm.fleet_get_remaining_ammo(this.__wbg_ptr, ptr0, len0, rate, ceil);
1057
1074
  return ret === 0xFFFFFF ? undefined : ret;
1058
1075
  }
1059
1076
  /**
1060
1077
  * @returns {number}
1061
1078
  */
1062
1079
  count_ships() {
1063
- const ret = wasm.fleet_count_ships(this.ptr);
1080
+ const ret = wasm.fleet_count_ships(this.__wbg_ptr);
1064
1081
  return ret >>> 0;
1065
1082
  }
1066
1083
  /**
@@ -1068,7 +1085,7 @@ export class Fleet {
1068
1085
  * @returns {Ship | undefined}
1069
1086
  */
1070
1087
  get_ship(key) {
1071
- const ret = wasm.fleet_get_ship(this.ptr, addHeapObject(key));
1088
+ const ret = wasm.fleet_get_ship(this.__wbg_ptr, addHeapObject(key));
1072
1089
  return ret === 0 ? undefined : Ship.__wrap(ret);
1073
1090
  }
1074
1091
  /**
@@ -1077,7 +1094,7 @@ export class Fleet {
1077
1094
  get fleet_los_mod() {
1078
1095
  try {
1079
1096
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1080
- wasm.fleet_fleet_los_mod(retptr, this.ptr);
1097
+ wasm.fleet_fleet_los_mod(retptr, this.__wbg_ptr);
1081
1098
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1082
1099
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
1083
1100
  return r0 === 0 ? undefined : r2;
@@ -1092,7 +1109,7 @@ export class Fleet {
1092
1109
  fighter_power(air_type) {
1093
1110
  try {
1094
1111
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1095
- wasm.fleet_fighter_power(retptr, this.ptr, addHeapObject(air_type));
1112
+ wasm.fleet_fighter_power(retptr, this.__wbg_ptr, addHeapObject(air_type));
1096
1113
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1097
1114
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1098
1115
  return r0 === 0 ? undefined : r1;
@@ -1109,7 +1126,7 @@ export class Fleet {
1109
1126
  elos(hq_level, node_divaricated_factor) {
1110
1127
  try {
1111
1128
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1112
- wasm.fleet_elos(retptr, this.ptr, hq_level, node_divaricated_factor);
1129
+ wasm.fleet_elos(retptr, this.__wbg_ptr, hq_level, node_divaricated_factor);
1113
1130
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1114
1131
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
1115
1132
  return r0 === 0 ? undefined : r2;
@@ -1124,7 +1141,7 @@ export class Fleet {
1124
1141
  aviation_detection_score() {
1125
1142
  try {
1126
1143
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1127
- wasm.fleet_aviation_detection_score(retptr, this.ptr);
1144
+ wasm.fleet_aviation_detection_score(retptr, this.__wbg_ptr);
1128
1145
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1129
1146
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
1130
1147
  return r0 === 0 ? undefined : r2;
@@ -1137,7 +1154,7 @@ export class Fleet {
1137
1154
  * @returns {number}
1138
1155
  */
1139
1156
  expedition_bonus() {
1140
- const ret = wasm.fleet_expedition_bonus(this.ptr);
1157
+ const ret = wasm.fleet_expedition_bonus(this.__wbg_ptr);
1141
1158
  return ret;
1142
1159
  }
1143
1160
  /**
@@ -1149,7 +1166,7 @@ export class Fleet {
1149
1166
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1150
1167
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1151
1168
  const len0 = WASM_VECTOR_LEN;
1152
- wasm.fleet_sum_ship_stat_by(retptr, this.ptr, ptr0, len0);
1169
+ wasm.fleet_sum_ship_stat_by(retptr, this.__wbg_ptr, ptr0, len0);
1153
1170
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1154
1171
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
1155
1172
  return r0 === 0 ? undefined : r2;
@@ -1160,25 +1177,26 @@ export class Fleet {
1160
1177
  /**
1161
1178
  */
1162
1179
  reset_battle_state() {
1163
- wasm.fleet_reset_battle_state(this.ptr);
1180
+ wasm.fleet_reset_battle_state(this.__wbg_ptr);
1164
1181
  }
1165
1182
  }
1166
1183
 
1167
- const GearFinalization = new FinalizationRegistry(ptr => wasm.__wbg_gear_free(ptr));
1184
+ const GearFinalization = new FinalizationRegistry(ptr => wasm.__wbg_gear_free(ptr >>> 0));
1168
1185
  /**
1169
1186
  */
1170
1187
  export class Gear {
1171
1188
 
1172
1189
  static __wrap(ptr) {
1190
+ ptr = ptr >>> 0;
1173
1191
  const obj = Object.create(Gear.prototype);
1174
- obj.ptr = ptr;
1175
- GearFinalization.register(obj, obj.ptr, obj);
1192
+ obj.__wbg_ptr = ptr;
1193
+ GearFinalization.register(obj, obj.__wbg_ptr, obj);
1176
1194
  return obj;
1177
1195
  }
1178
1196
 
1179
1197
  __destroy_into_raw() {
1180
- const ptr = this.ptr;
1181
- this.ptr = 0;
1198
+ const ptr = this.__wbg_ptr;
1199
+ this.__wbg_ptr = 0;
1182
1200
  GearFinalization.unregister(this);
1183
1201
  return ptr;
1184
1202
  }
@@ -1191,15 +1209,19 @@ export class Gear {
1191
1209
  * @returns {string}
1192
1210
  */
1193
1211
  get id() {
1212
+ let deferred1_0;
1213
+ let deferred1_1;
1194
1214
  try {
1195
1215
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1196
- wasm.__wbg_get_gear_id(retptr, this.ptr);
1216
+ wasm.__wbg_get_gear_id(retptr, this.__wbg_ptr);
1197
1217
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1198
1218
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1219
+ deferred1_0 = r0;
1220
+ deferred1_1 = r1;
1199
1221
  return getStringFromWasm0(r0, r1);
1200
1222
  } finally {
1201
1223
  wasm.__wbindgen_add_to_stack_pointer(16);
1202
- wasm.__wbindgen_free(r0, r1);
1224
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
1203
1225
  }
1204
1226
  }
1205
1227
  /**
@@ -1208,56 +1230,60 @@ export class Gear {
1208
1230
  set id(arg0) {
1209
1231
  const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1210
1232
  const len0 = WASM_VECTOR_LEN;
1211
- wasm.__wbg_set_gear_id(this.ptr, ptr0, len0);
1233
+ wasm.__wbg_set_gear_id(this.__wbg_ptr, ptr0, len0);
1212
1234
  }
1213
1235
  /**
1214
1236
  * @returns {bigint}
1215
1237
  */
1216
1238
  get hash() {
1217
- const ret = wasm.__wbg_get_gear_hash(this.ptr);
1239
+ const ret = wasm.__wbg_get_gear_hash(this.__wbg_ptr);
1218
1240
  return BigInt.asUintN(64, ret);
1219
1241
  }
1220
1242
  /**
1221
1243
  * @returns {number}
1222
1244
  */
1223
1245
  get gear_id() {
1224
- const ret = wasm.__wbg_get_gear_gear_id(this.ptr);
1246
+ const ret = wasm.__wbg_get_gear_gear_id(this.__wbg_ptr);
1225
1247
  return ret;
1226
1248
  }
1227
1249
  /**
1228
1250
  * @returns {number}
1229
1251
  */
1230
1252
  get stars() {
1231
- const ret = wasm.__wbg_get_gear_stars(this.ptr);
1253
+ const ret = wasm.__wbg_get_gear_stars(this.__wbg_ptr);
1232
1254
  return ret;
1233
1255
  }
1234
1256
  /**
1235
1257
  * @returns {number}
1236
1258
  */
1237
1259
  get exp() {
1238
- const ret = wasm.__wbg_get_gear_exp(this.ptr);
1260
+ const ret = wasm.__wbg_get_gear_exp(this.__wbg_ptr);
1239
1261
  return ret;
1240
1262
  }
1241
1263
  /**
1242
1264
  * @returns {number}
1243
1265
  */
1244
1266
  get default_exp() {
1245
- const ret = wasm.__wbg_get_gear_default_exp(this.ptr);
1267
+ const ret = wasm.__wbg_get_gear_default_exp(this.__wbg_ptr);
1246
1268
  return ret;
1247
1269
  }
1248
1270
  /**
1249
1271
  * @returns {string}
1250
1272
  */
1251
1273
  get name() {
1274
+ let deferred1_0;
1275
+ let deferred1_1;
1252
1276
  try {
1253
1277
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1254
- wasm.__wbg_get_gear_name(retptr, this.ptr);
1278
+ wasm.__wbg_get_gear_name(retptr, this.__wbg_ptr);
1255
1279
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1256
1280
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1281
+ deferred1_0 = r0;
1282
+ deferred1_1 = r1;
1257
1283
  return getStringFromWasm0(r0, r1);
1258
1284
  } finally {
1259
1285
  wasm.__wbindgen_add_to_stack_pointer(16);
1260
- wasm.__wbindgen_free(r0, r1);
1286
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
1261
1287
  }
1262
1288
  }
1263
1289
  /**
@@ -1266,7 +1292,7 @@ export class Gear {
1266
1292
  set name(arg0) {
1267
1293
  const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1268
1294
  const len0 = WASM_VECTOR_LEN;
1269
- wasm.__wbg_set_gear_name(this.ptr, ptr0, len0);
1295
+ wasm.__wbg_set_gear_name(this.__wbg_ptr, ptr0, len0);
1270
1296
  }
1271
1297
  /**
1272
1298
  * @returns {Uint8Array}
@@ -1274,12 +1300,12 @@ export class Gear {
1274
1300
  get types() {
1275
1301
  try {
1276
1302
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1277
- wasm.__wbg_get_gear_types(retptr, this.ptr);
1303
+ wasm.__wbg_get_gear_types(retptr, this.__wbg_ptr);
1278
1304
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1279
1305
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1280
- var v0 = getArrayU8FromWasm0(r0, r1).slice();
1306
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
1281
1307
  wasm.__wbindgen_free(r0, r1 * 1);
1282
- return v0;
1308
+ return v1;
1283
1309
  } finally {
1284
1310
  wasm.__wbindgen_add_to_stack_pointer(16);
1285
1311
  }
@@ -1290,139 +1316,139 @@ export class Gear {
1290
1316
  set types(arg0) {
1291
1317
  const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
1292
1318
  const len0 = WASM_VECTOR_LEN;
1293
- wasm.__wbg_set_gear_types(this.ptr, ptr0, len0);
1319
+ wasm.__wbg_set_gear_types(this.__wbg_ptr, ptr0, len0);
1294
1320
  }
1295
1321
  /**
1296
1322
  * @returns {GearType}
1297
1323
  */
1298
1324
  get gear_type() {
1299
- const ret = wasm.__wbg_get_gear_gear_type(this.ptr);
1325
+ const ret = wasm.__wbg_get_gear_gear_type(this.__wbg_ptr);
1300
1326
  return takeObject(ret);
1301
1327
  }
1302
1328
  /**
1303
1329
  * @returns {number}
1304
1330
  */
1305
1331
  get max_hp() {
1306
- const ret = wasm.__wbg_get_gear_max_hp(this.ptr);
1332
+ const ret = wasm.__wbg_get_gear_max_hp(this.__wbg_ptr);
1307
1333
  return ret;
1308
1334
  }
1309
1335
  /**
1310
1336
  * @returns {number}
1311
1337
  */
1312
1338
  get firepower() {
1313
- const ret = wasm.__wbg_get_gear_firepower(this.ptr);
1339
+ const ret = wasm.__wbg_get_gear_firepower(this.__wbg_ptr);
1314
1340
  return ret;
1315
1341
  }
1316
1342
  /**
1317
1343
  * @returns {number}
1318
1344
  */
1319
1345
  get armor() {
1320
- const ret = wasm.__wbg_get_gear_armor(this.ptr);
1346
+ const ret = wasm.__wbg_get_gear_armor(this.__wbg_ptr);
1321
1347
  return ret;
1322
1348
  }
1323
1349
  /**
1324
1350
  * @returns {number}
1325
1351
  */
1326
1352
  get torpedo() {
1327
- const ret = wasm.__wbg_get_gear_torpedo(this.ptr);
1353
+ const ret = wasm.__wbg_get_gear_torpedo(this.__wbg_ptr);
1328
1354
  return ret;
1329
1355
  }
1330
1356
  /**
1331
1357
  * @returns {number}
1332
1358
  */
1333
1359
  get anti_air() {
1334
- const ret = wasm.__wbg_get_gear_anti_air(this.ptr);
1360
+ const ret = wasm.__wbg_get_gear_anti_air(this.__wbg_ptr);
1335
1361
  return ret;
1336
1362
  }
1337
1363
  /**
1338
1364
  * @returns {number}
1339
1365
  */
1340
1366
  get speed() {
1341
- const ret = wasm.__wbg_get_gear_speed(this.ptr);
1367
+ const ret = wasm.__wbg_get_gear_speed(this.__wbg_ptr);
1342
1368
  return ret;
1343
1369
  }
1344
1370
  /**
1345
1371
  * @returns {number}
1346
1372
  */
1347
1373
  get bombing() {
1348
- const ret = wasm.__wbg_get_gear_bombing(this.ptr);
1374
+ const ret = wasm.__wbg_get_gear_bombing(this.__wbg_ptr);
1349
1375
  return ret;
1350
1376
  }
1351
1377
  /**
1352
1378
  * @returns {number}
1353
1379
  */
1354
1380
  get asw() {
1355
- const ret = wasm.__wbg_get_gear_asw(this.ptr);
1381
+ const ret = wasm.__wbg_get_gear_asw(this.__wbg_ptr);
1356
1382
  return ret;
1357
1383
  }
1358
1384
  /**
1359
1385
  * @returns {number}
1360
1386
  */
1361
1387
  get los() {
1362
- const ret = wasm.__wbg_get_gear_los(this.ptr);
1388
+ const ret = wasm.__wbg_get_gear_los(this.__wbg_ptr);
1363
1389
  return ret;
1364
1390
  }
1365
1391
  /**
1366
1392
  * @returns {number}
1367
1393
  */
1368
1394
  get luck() {
1369
- const ret = wasm.__wbg_get_gear_luck(this.ptr);
1395
+ const ret = wasm.__wbg_get_gear_luck(this.__wbg_ptr);
1370
1396
  return ret;
1371
1397
  }
1372
1398
  /**
1373
1399
  * @returns {number}
1374
1400
  */
1375
1401
  get accuracy() {
1376
- const ret = wasm.__wbg_get_gear_accuracy(this.ptr);
1402
+ const ret = wasm.__wbg_get_gear_accuracy(this.__wbg_ptr);
1377
1403
  return ret;
1378
1404
  }
1379
1405
  /**
1380
1406
  * @returns {number}
1381
1407
  */
1382
1408
  get evasion() {
1383
- const ret = wasm.__wbg_get_gear_evasion(this.ptr);
1409
+ const ret = wasm.__wbg_get_gear_evasion(this.__wbg_ptr);
1384
1410
  return ret;
1385
1411
  }
1386
1412
  /**
1387
1413
  * @returns {number}
1388
1414
  */
1389
1415
  get range() {
1390
- const ret = wasm.__wbg_get_gear_range(this.ptr);
1416
+ const ret = wasm.__wbg_get_gear_range(this.__wbg_ptr);
1391
1417
  return ret;
1392
1418
  }
1393
1419
  /**
1394
1420
  * @returns {number}
1395
1421
  */
1396
1422
  get radius() {
1397
- const ret = wasm.__wbg_get_gear_radius(this.ptr);
1423
+ const ret = wasm.__wbg_get_gear_radius(this.__wbg_ptr);
1398
1424
  return ret;
1399
1425
  }
1400
1426
  /**
1401
1427
  * @returns {number}
1402
1428
  */
1403
1429
  get cost() {
1404
- const ret = wasm.__wbg_get_gear_cost(this.ptr);
1430
+ const ret = wasm.__wbg_get_gear_cost(this.__wbg_ptr);
1405
1431
  return ret;
1406
1432
  }
1407
1433
  /**
1408
1434
  * @returns {boolean}
1409
1435
  */
1410
1436
  get improvable() {
1411
- const ret = wasm.__wbg_get_gear_improvable(this.ptr);
1437
+ const ret = wasm.__wbg_get_gear_improvable(this.__wbg_ptr);
1412
1438
  return ret !== 0;
1413
1439
  }
1414
1440
  /**
1415
1441
  * @returns {number}
1416
1442
  */
1417
1443
  get ship_anti_air_resist() {
1418
- const ret = wasm.__wbg_get_gear_ship_anti_air_resist(this.ptr);
1444
+ const ret = wasm.__wbg_get_gear_ship_anti_air_resist(this.__wbg_ptr);
1419
1445
  return ret;
1420
1446
  }
1421
1447
  /**
1422
1448
  * @returns {number}
1423
1449
  */
1424
1450
  get fleet_anti_air_resist() {
1425
- const ret = wasm.__wbg_get_gear_fleet_anti_air_resist(this.ptr);
1451
+ const ret = wasm.__wbg_get_gear_fleet_anti_air_resist(this.__wbg_ptr);
1426
1452
  return ret;
1427
1453
  }
1428
1454
  /**
@@ -1436,21 +1462,21 @@ export class Gear {
1436
1462
  * @returns {number}
1437
1463
  */
1438
1464
  get gear_type_id() {
1439
- const ret = wasm.gear_gear_type_id(this.ptr);
1465
+ const ret = wasm.gear_gear_type_id(this.__wbg_ptr);
1440
1466
  return ret;
1441
1467
  }
1442
1468
  /**
1443
1469
  * @returns {number}
1444
1470
  */
1445
1471
  get special_type() {
1446
- const ret = wasm.gear_special_type(this.ptr);
1472
+ const ret = wasm.gear_special_type(this.__wbg_ptr);
1447
1473
  return ret;
1448
1474
  }
1449
1475
  /**
1450
1476
  * @returns {number}
1451
1477
  */
1452
1478
  get icon_id() {
1453
- const ret = wasm.gear_icon_id(this.ptr);
1479
+ const ret = wasm.gear_icon_id(this.__wbg_ptr);
1454
1480
  return ret;
1455
1481
  }
1456
1482
  /**
@@ -1458,63 +1484,63 @@ export class Gear {
1458
1484
  * @returns {boolean}
1459
1485
  */
1460
1486
  has_attr(attr) {
1461
- const ret = wasm.gear_has_attr(this.ptr, addHeapObject(attr));
1487
+ const ret = wasm.gear_has_attr(this.__wbg_ptr, addHeapObject(attr));
1462
1488
  return ret !== 0;
1463
1489
  }
1464
1490
  /**
1465
1491
  * @returns {GearCategory}
1466
1492
  */
1467
1493
  category() {
1468
- const ret = wasm.gear_category(this.ptr);
1494
+ const ret = wasm.gear_category(this.__wbg_ptr);
1469
1495
  return takeObject(ret);
1470
1496
  }
1471
1497
  /**
1472
1498
  * @returns {number}
1473
1499
  */
1474
1500
  get ace() {
1475
- const ret = wasm.gear_ace(this.ptr);
1501
+ const ret = wasm.gear_ace(this.__wbg_ptr);
1476
1502
  return ret;
1477
1503
  }
1478
1504
  /**
1479
1505
  * @returns {number}
1480
1506
  */
1481
1507
  get anti_bomber() {
1482
- const ret = wasm.gear_anti_bomber(this.ptr);
1508
+ const ret = wasm.gear_anti_bomber(this.__wbg_ptr);
1483
1509
  return ret;
1484
1510
  }
1485
1511
  /**
1486
1512
  * @returns {number}
1487
1513
  */
1488
1514
  get interception() {
1489
- const ret = wasm.gear_interception(this.ptr);
1515
+ const ret = wasm.gear_interception(this.__wbg_ptr);
1490
1516
  return ret;
1491
1517
  }
1492
1518
  /**
1493
1519
  * @returns {boolean}
1494
1520
  */
1495
1521
  is_high_angle_mount() {
1496
- const ret = wasm.gear_is_high_angle_mount(this.ptr);
1522
+ const ret = wasm.gear_is_high_angle_mount(this.__wbg_ptr);
1497
1523
  return ret !== 0;
1498
1524
  }
1499
1525
  /**
1500
1526
  * @returns {boolean}
1501
1527
  */
1502
1528
  is_carrier_shelling_plane() {
1503
- const ret = wasm.gear_is_carrier_shelling_plane(this.ptr);
1529
+ const ret = wasm.gear_is_carrier_shelling_plane(this.__wbg_ptr);
1504
1530
  return ret !== 0;
1505
1531
  }
1506
1532
  /**
1507
1533
  * @returns {boolean}
1508
1534
  */
1509
1535
  has_proficiency() {
1510
- const ret = wasm.gear_can_be_deployed_to_land_base(this.ptr);
1536
+ const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
1511
1537
  return ret !== 0;
1512
1538
  }
1513
1539
  /**
1514
1540
  * @returns {boolean}
1515
1541
  */
1516
1542
  max_exp_eq_120() {
1517
- const ret = wasm.gear_max_exp_eq_120(this.ptr);
1543
+ const ret = wasm.gear_max_exp_eq_120(this.__wbg_ptr);
1518
1544
  return ret !== 0;
1519
1545
  }
1520
1546
  /**
@@ -1522,7 +1548,7 @@ export class Gear {
1522
1548
  * @returns {number}
1523
1549
  */
1524
1550
  calc_fighter_power(slot_size) {
1525
- const ret = wasm.gear_calc_fighter_power(this.ptr, slot_size);
1551
+ const ret = wasm.gear_calc_fighter_power(this.__wbg_ptr, slot_size);
1526
1552
  return ret;
1527
1553
  }
1528
1554
  /**
@@ -1530,21 +1556,21 @@ export class Gear {
1530
1556
  * @returns {number}
1531
1557
  */
1532
1558
  calc_interception_power(slot_size) {
1533
- const ret = wasm.gear_calc_interception_power(this.ptr, slot_size);
1559
+ const ret = wasm.gear_calc_interception_power(this.__wbg_ptr, slot_size);
1534
1560
  return ret;
1535
1561
  }
1536
1562
  /**
1537
1563
  * @returns {number}
1538
1564
  */
1539
1565
  fleet_anti_air_mod() {
1540
- const ret = wasm.gear_fleet_anti_air_mod(this.ptr);
1566
+ const ret = wasm.gear_fleet_anti_air_mod(this.__wbg_ptr);
1541
1567
  return ret;
1542
1568
  }
1543
1569
  /**
1544
1570
  * @returns {number}
1545
1571
  */
1546
1572
  ship_anti_air_mod() {
1547
- const ret = wasm.gear_ship_anti_air_mod(this.ptr);
1573
+ const ret = wasm.gear_ship_anti_air_mod(this.__wbg_ptr);
1548
1574
  return ret;
1549
1575
  }
1550
1576
  /**
@@ -1552,7 +1578,7 @@ export class Gear {
1552
1578
  * @returns {number}
1553
1579
  */
1554
1580
  calc_contact_trigger_factor(slot_size) {
1555
- const ret = wasm.gear_calc_contact_trigger_factor(this.ptr, slot_size);
1581
+ const ret = wasm.gear_calc_contact_trigger_factor(this.__wbg_ptr, slot_size);
1556
1582
  return ret;
1557
1583
  }
1558
1584
  /**
@@ -1560,7 +1586,7 @@ export class Gear {
1560
1586
  * @returns {number}
1561
1587
  */
1562
1588
  contact_selection_rate(rank) {
1563
- const ret = wasm.gear_contact_selection_rate(this.ptr, addHeapObject(rank));
1589
+ const ret = wasm.gear_contact_selection_rate(this.__wbg_ptr, addHeapObject(rank));
1564
1590
  return ret;
1565
1591
  }
1566
1592
  /**
@@ -1568,28 +1594,28 @@ export class Gear {
1568
1594
  * @returns {number}
1569
1595
  */
1570
1596
  night_contact_rate(level) {
1571
- const ret = wasm.gear_night_contact_rate(this.ptr, level);
1597
+ const ret = wasm.gear_night_contact_rate(this.__wbg_ptr, level);
1572
1598
  return ret;
1573
1599
  }
1574
1600
  /**
1575
1601
  * @returns {boolean}
1576
1602
  */
1577
1603
  is_night_attacker() {
1578
- const ret = wasm.gear_is_night_attacker(this.ptr);
1604
+ const ret = wasm.gear_is_night_attacker(this.__wbg_ptr);
1579
1605
  return ret !== 0;
1580
1606
  }
1581
1607
  /**
1582
1608
  * @returns {boolean}
1583
1609
  */
1584
1610
  is_night_fighter() {
1585
- const ret = wasm.gear_is_night_fighter(this.ptr);
1611
+ const ret = wasm.gear_is_night_fighter(this.__wbg_ptr);
1586
1612
  return ret !== 0;
1587
1613
  }
1588
1614
  /**
1589
1615
  * @returns {boolean}
1590
1616
  */
1591
1617
  is_night_plane() {
1592
- const ret = wasm.gear_is_night_plane(this.ptr);
1618
+ const ret = wasm.gear_is_night_plane(this.__wbg_ptr);
1593
1619
  return ret !== 0;
1594
1620
  }
1595
1621
  /**
@@ -1598,68 +1624,69 @@ export class Gear {
1598
1624
  * @returns {number}
1599
1625
  */
1600
1626
  night_plane_power(slot_size, anti_inst) {
1601
- const ret = wasm.gear_night_plane_power(this.ptr, slot_size, anti_inst);
1627
+ const ret = wasm.gear_night_plane_power(this.__wbg_ptr, slot_size, anti_inst);
1602
1628
  return ret;
1603
1629
  }
1604
1630
  /**
1605
1631
  * @returns {number}
1606
1632
  */
1607
1633
  elos() {
1608
- const ret = wasm.gear_elos(this.ptr);
1634
+ const ret = wasm.gear_elos(this.__wbg_ptr);
1609
1635
  return ret;
1610
1636
  }
1611
1637
  /**
1612
1638
  * @returns {boolean}
1613
1639
  */
1614
1640
  is_abyssal() {
1615
- const ret = wasm.gear_is_abyssal(this.ptr);
1641
+ const ret = wasm.gear_is_abyssal(this.__wbg_ptr);
1616
1642
  return ret !== 0;
1617
1643
  }
1618
1644
  /**
1619
1645
  * @returns {boolean}
1620
1646
  */
1621
1647
  is_abyssal_cuttlefish_torpedo() {
1622
- const ret = wasm.gear_is_abyssal_cuttlefish_torpedo(this.ptr);
1648
+ const ret = wasm.gear_is_abyssal_cuttlefish_torpedo(this.__wbg_ptr);
1623
1649
  return ret !== 0;
1624
1650
  }
1625
1651
  /**
1626
1652
  * @returns {boolean}
1627
1653
  */
1628
1654
  is_abyssal_patrolling_attack_hawk() {
1629
- const ret = wasm.gear_is_abyssal_patrolling_attack_hawk(this.ptr);
1655
+ const ret = wasm.gear_is_abyssal_patrolling_attack_hawk(this.__wbg_ptr);
1630
1656
  return ret !== 0;
1631
1657
  }
1632
1658
  /**
1633
1659
  * @returns {number}
1634
1660
  */
1635
1661
  expedition_bonus() {
1636
- const ret = wasm.gear_expedition_bonus(this.ptr);
1662
+ const ret = wasm.gear_expedition_bonus(this.__wbg_ptr);
1637
1663
  return ret;
1638
1664
  }
1639
1665
  /**
1640
1666
  * @returns {boolean}
1641
1667
  */
1642
1668
  can_be_deployed_to_land_base() {
1643
- const ret = wasm.gear_can_be_deployed_to_land_base(this.ptr);
1669
+ const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
1644
1670
  return ret !== 0;
1645
1671
  }
1646
1672
  }
1647
1673
 
1648
- const OrgFinalization = new FinalizationRegistry(ptr => wasm.__wbg_org_free(ptr));
1674
+ const OrgFinalization = new FinalizationRegistry(ptr => wasm.__wbg_org_free(ptr >>> 0));
1649
1675
  /**
1650
1676
  */
1651
1677
  export class Org {
1652
1678
 
1653
1679
  static __wrap(ptr) {
1680
+ ptr = ptr >>> 0;
1654
1681
  const obj = Object.create(Org.prototype);
1655
- obj.ptr = ptr;
1656
- OrgFinalization.register(obj, obj.ptr, obj);
1682
+ obj.__wbg_ptr = ptr;
1683
+ OrgFinalization.register(obj, obj.__wbg_ptr, obj);
1657
1684
  return obj;
1658
1685
  }
1659
1686
 
1660
1687
  __destroy_into_raw() {
1661
- const ptr = this.ptr;
1662
- this.ptr = 0;
1688
+ const ptr = this.__wbg_ptr;
1689
+ this.__wbg_ptr = 0;
1663
1690
  OrgFinalization.unregister(this);
1664
1691
  return ptr;
1665
1692
  }
@@ -1672,15 +1699,19 @@ export class Org {
1672
1699
  * @returns {string}
1673
1700
  */
1674
1701
  get id() {
1702
+ let deferred1_0;
1703
+ let deferred1_1;
1675
1704
  try {
1676
1705
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1677
- wasm.__wbg_get_org_id(retptr, this.ptr);
1706
+ wasm.__wbg_get_org_id(retptr, this.__wbg_ptr);
1678
1707
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1679
1708
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1709
+ deferred1_0 = r0;
1710
+ deferred1_1 = r1;
1680
1711
  return getStringFromWasm0(r0, r1);
1681
1712
  } finally {
1682
1713
  wasm.__wbindgen_add_to_stack_pointer(16);
1683
- wasm.__wbindgen_free(r0, r1);
1714
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
1684
1715
  }
1685
1716
  }
1686
1717
  /**
@@ -1689,48 +1720,48 @@ export class Org {
1689
1720
  set id(arg0) {
1690
1721
  const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1691
1722
  const len0 = WASM_VECTOR_LEN;
1692
- wasm.__wbg_set_org_id(this.ptr, ptr0, len0);
1723
+ wasm.__wbg_set_org_id(this.__wbg_ptr, ptr0, len0);
1693
1724
  }
1694
1725
  /**
1695
1726
  * @returns {bigint}
1696
1727
  */
1697
1728
  get hash() {
1698
- const ret = wasm.__wbg_get_org_hash(this.ptr);
1729
+ const ret = wasm.__wbg_get_org_hash(this.__wbg_ptr);
1699
1730
  return BigInt.asUintN(64, ret);
1700
1731
  }
1701
1732
  /**
1702
1733
  * @returns {number}
1703
1734
  */
1704
1735
  get hq_level() {
1705
- const ret = wasm.__wbg_get_org_hq_level(this.ptr);
1736
+ const ret = wasm.__wbg_get_org_hq_level(this.__wbg_ptr);
1706
1737
  return ret;
1707
1738
  }
1708
1739
  /**
1709
1740
  * @returns {OrgType}
1710
1741
  */
1711
1742
  get org_type() {
1712
- const ret = wasm.__wbg_get_org_org_type(this.ptr);
1743
+ const ret = wasm.__wbg_get_org_org_type(this.__wbg_ptr);
1713
1744
  return takeObject(ret);
1714
1745
  }
1715
1746
  /**
1716
1747
  * @returns {FleetKey}
1717
1748
  */
1718
1749
  get sortie() {
1719
- const ret = wasm.__wbg_get_org_sortie(this.ptr);
1750
+ const ret = wasm.__wbg_get_org_sortie(this.__wbg_ptr);
1720
1751
  return takeObject(ret);
1721
1752
  }
1722
1753
  /**
1723
1754
  * @returns {FleetKey | undefined}
1724
1755
  */
1725
1756
  get route_sup() {
1726
- const ret = wasm.__wbg_get_org_route_sup(this.ptr);
1757
+ const ret = wasm.__wbg_get_org_route_sup(this.__wbg_ptr);
1727
1758
  return takeObject(ret);
1728
1759
  }
1729
1760
  /**
1730
1761
  * @returns {FleetKey | undefined}
1731
1762
  */
1732
1763
  get boss_sup() {
1733
- const ret = wasm.__wbg_get_org_boss_sup(this.ptr);
1764
+ const ret = wasm.__wbg_get_org_boss_sup(this.__wbg_ptr);
1734
1765
  return takeObject(ret);
1735
1766
  }
1736
1767
  /**
@@ -1739,15 +1770,15 @@ export class Org {
1739
1770
  first_ship_id() {
1740
1771
  try {
1741
1772
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1742
- wasm.org_first_ship_id(retptr, this.ptr);
1773
+ wasm.org_first_ship_id(retptr, this.__wbg_ptr);
1743
1774
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1744
1775
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1745
- let v0;
1776
+ let v1;
1746
1777
  if (r0 !== 0) {
1747
- v0 = getStringFromWasm0(r0, r1).slice();
1778
+ v1 = getStringFromWasm0(r0, r1).slice();
1748
1779
  wasm.__wbindgen_free(r0, r1 * 1);
1749
1780
  }
1750
- return v0;
1781
+ return v1;
1751
1782
  } finally {
1752
1783
  wasm.__wbindgen_add_to_stack_pointer(16);
1753
1784
  }
@@ -1758,7 +1789,7 @@ export class Org {
1758
1789
  * @returns {number | undefined}
1759
1790
  */
1760
1791
  get_ship_mid(fleet_key, ship_key) {
1761
- const ret = wasm.org_get_ship_mid(this.ptr, addHeapObject(fleet_key), addHeapObject(ship_key));
1792
+ const ret = wasm.org_get_ship_mid(this.__wbg_ptr, addHeapObject(fleet_key), addHeapObject(ship_key));
1762
1793
  return ret === 0xFFFFFF ? undefined : ret;
1763
1794
  }
1764
1795
  /**
@@ -1769,15 +1800,15 @@ export class Org {
1769
1800
  get_ship_eid(fleet_key, ship_key) {
1770
1801
  try {
1771
1802
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1772
- wasm.org_get_ship_eid(retptr, this.ptr, addHeapObject(fleet_key), addHeapObject(ship_key));
1803
+ wasm.org_get_ship_eid(retptr, this.__wbg_ptr, addHeapObject(fleet_key), addHeapObject(ship_key));
1773
1804
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1774
1805
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1775
- let v0;
1806
+ let v1;
1776
1807
  if (r0 !== 0) {
1777
- v0 = getStringFromWasm0(r0, r1).slice();
1808
+ v1 = getStringFromWasm0(r0, r1).slice();
1778
1809
  wasm.__wbindgen_free(r0, r1 * 1);
1779
1810
  }
1780
- return v0;
1811
+ return v1;
1781
1812
  } finally {
1782
1813
  wasm.__wbindgen_add_to_stack_pointer(16);
1783
1814
  }
@@ -1787,15 +1818,19 @@ export class Org {
1787
1818
  * @returns {string}
1788
1819
  */
1789
1820
  get_fleet_id(key) {
1821
+ let deferred1_0;
1822
+ let deferred1_1;
1790
1823
  try {
1791
1824
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1792
- wasm.org_get_fleet_id(retptr, this.ptr, addHeapObject(key));
1825
+ wasm.org_get_fleet_id(retptr, this.__wbg_ptr, addHeapObject(key));
1793
1826
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1794
1827
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1828
+ deferred1_0 = r0;
1829
+ deferred1_1 = r1;
1795
1830
  return getStringFromWasm0(r0, r1);
1796
1831
  } finally {
1797
1832
  wasm.__wbindgen_add_to_stack_pointer(16);
1798
- wasm.__wbindgen_free(r0, r1);
1833
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
1799
1834
  }
1800
1835
  }
1801
1836
  /**
@@ -1804,12 +1839,12 @@ export class Org {
1804
1839
  air_squadron_ids() {
1805
1840
  try {
1806
1841
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1807
- wasm.org_air_squadron_ids(retptr, this.ptr);
1842
+ wasm.org_air_squadron_ids(retptr, this.__wbg_ptr);
1808
1843
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1809
1844
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1810
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1845
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1811
1846
  wasm.__wbindgen_free(r0, r1 * 4);
1812
- return v0;
1847
+ return v1;
1813
1848
  } finally {
1814
1849
  wasm.__wbindgen_add_to_stack_pointer(16);
1815
1850
  }
@@ -1820,12 +1855,12 @@ export class Org {
1820
1855
  main_ship_ids() {
1821
1856
  try {
1822
1857
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1823
- wasm.org_main_ship_ids(retptr, this.ptr);
1858
+ wasm.org_main_ship_ids(retptr, this.__wbg_ptr);
1824
1859
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1825
1860
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1826
- var v0 = getArrayU16FromWasm0(r0, r1).slice();
1861
+ var v1 = getArrayU16FromWasm0(r0, r1).slice();
1827
1862
  wasm.__wbindgen_free(r0, r1 * 2);
1828
- return v0;
1863
+ return v1;
1829
1864
  } finally {
1830
1865
  wasm.__wbindgen_add_to_stack_pointer(16);
1831
1866
  }
@@ -1836,12 +1871,12 @@ export class Org {
1836
1871
  escort_ship_ids() {
1837
1872
  try {
1838
1873
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1839
- wasm.org_escort_ship_ids(retptr, this.ptr);
1874
+ wasm.org_escort_ship_ids(retptr, this.__wbg_ptr);
1840
1875
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1841
1876
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1842
- var v0 = getArrayU16FromWasm0(r0, r1).slice();
1877
+ var v1 = getArrayU16FromWasm0(r0, r1).slice();
1843
1878
  wasm.__wbindgen_free(r0, r1 * 2);
1844
- return v0;
1879
+ return v1;
1845
1880
  } finally {
1846
1881
  wasm.__wbindgen_add_to_stack_pointer(16);
1847
1882
  }
@@ -1851,7 +1886,7 @@ export class Org {
1851
1886
  * @returns {Fleet}
1852
1887
  */
1853
1888
  clone_fleet(key) {
1854
- const ret = wasm.org_clone_fleet(this.ptr, addHeapObject(key));
1889
+ const ret = wasm.org_clone_fleet(this.__wbg_ptr, addHeapObject(key));
1855
1890
  return Fleet.__wrap(ret);
1856
1891
  }
1857
1892
  /**
@@ -1860,7 +1895,7 @@ export class Org {
1860
1895
  * @returns {Ship | undefined}
1861
1896
  */
1862
1897
  clone_ship(fleet_key, ship_key) {
1863
- const ret = wasm.org_clone_ship(this.ptr, addHeapObject(fleet_key), addHeapObject(ship_key));
1898
+ const ret = wasm.org_clone_ship(this.__wbg_ptr, addHeapObject(fleet_key), addHeapObject(ship_key));
1864
1899
  return ret === 0 ? undefined : Ship.__wrap(ret);
1865
1900
  }
1866
1901
  /**
@@ -1870,7 +1905,7 @@ export class Org {
1870
1905
  get_ship_by_id(id) {
1871
1906
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1872
1907
  const len0 = WASM_VECTOR_LEN;
1873
- const ret = wasm.org_get_ship_by_id(this.ptr, ptr0, len0);
1908
+ const ret = wasm.org_get_ship_by_id(this.__wbg_ptr, ptr0, len0);
1874
1909
  return ret === 0 ? undefined : Ship.__wrap(ret);
1875
1910
  }
1876
1911
  /**
@@ -1880,12 +1915,12 @@ export class Org {
1880
1915
  ship_keys(key) {
1881
1916
  try {
1882
1917
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1883
- wasm.org_ship_keys(retptr, this.ptr, addHeapObject(key));
1918
+ wasm.org_ship_keys(retptr, this.__wbg_ptr, addHeapObject(key));
1884
1919
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1885
1920
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1886
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1921
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1887
1922
  wasm.__wbindgen_free(r0, r1 * 4);
1888
- return v0;
1923
+ return v1;
1889
1924
  } finally {
1890
1925
  wasm.__wbindgen_add_to_stack_pointer(16);
1891
1926
  }
@@ -1894,7 +1929,7 @@ export class Org {
1894
1929
  * @returns {Comp}
1895
1930
  */
1896
1931
  create_comp() {
1897
- const ret = wasm.org_create_comp(this.ptr);
1932
+ const ret = wasm.org_create_comp(this.__wbg_ptr);
1898
1933
  return Comp.__wrap(ret);
1899
1934
  }
1900
1935
  /**
@@ -1902,7 +1937,7 @@ export class Org {
1902
1937
  * @returns {Comp}
1903
1938
  */
1904
1939
  create_comp_by_key(key) {
1905
- const ret = wasm.org_create_comp_by_key(this.ptr, addHeapObject(key));
1940
+ const ret = wasm.org_create_comp_by_key(this.__wbg_ptr, addHeapObject(key));
1906
1941
  return Comp.__wrap(ret);
1907
1942
  }
1908
1943
  /**
@@ -1914,7 +1949,7 @@ export class Org {
1914
1949
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1915
1950
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1916
1951
  const len0 = WASM_VECTOR_LEN;
1917
- wasm.org_get_air_squadron(retptr, this.ptr, ptr0, len0);
1952
+ wasm.org_get_air_squadron(retptr, this.__wbg_ptr, ptr0, len0);
1918
1953
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1919
1954
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1920
1955
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1932,12 +1967,12 @@ export class Org {
1932
1967
  get_air_squadron_gear_ids_by_improvable() {
1933
1968
  try {
1934
1969
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1935
- wasm.org_get_air_squadron_gear_ids_by_improvable(retptr, this.ptr);
1970
+ wasm.org_get_air_squadron_gear_ids_by_improvable(retptr, this.__wbg_ptr);
1936
1971
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1937
1972
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1938
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1973
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1939
1974
  wasm.__wbindgen_free(r0, r1 * 4);
1940
- return v0;
1975
+ return v1;
1941
1976
  } finally {
1942
1977
  wasm.__wbindgen_add_to_stack_pointer(16);
1943
1978
  }
@@ -1948,12 +1983,12 @@ export class Org {
1948
1983
  get_air_squadron_gear_ids_by_proficiency() {
1949
1984
  try {
1950
1985
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1951
- wasm.org_get_air_squadron_gear_ids_by_proficiency(retptr, this.ptr);
1986
+ wasm.org_get_air_squadron_gear_ids_by_proficiency(retptr, this.__wbg_ptr);
1952
1987
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1953
1988
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1954
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1989
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1955
1990
  wasm.__wbindgen_free(r0, r1 * 4);
1956
- return v0;
1991
+ return v1;
1957
1992
  } finally {
1958
1993
  wasm.__wbindgen_add_to_stack_pointer(16);
1959
1994
  }
@@ -1962,35 +1997,35 @@ export class Org {
1962
1997
  * @returns {Side}
1963
1998
  */
1964
1999
  side() {
1965
- const ret = wasm.org_side(this.ptr);
2000
+ const ret = wasm.org_side(this.__wbg_ptr);
1966
2001
  return takeObject(ret);
1967
2002
  }
1968
2003
  /**
1969
2004
  * @returns {boolean}
1970
2005
  */
1971
2006
  is_player() {
1972
- const ret = wasm.org_is_player(this.ptr);
2007
+ const ret = wasm.org_is_player(this.__wbg_ptr);
1973
2008
  return ret !== 0;
1974
2009
  }
1975
2010
  /**
1976
2011
  * @returns {boolean}
1977
2012
  */
1978
2013
  is_enemy() {
1979
- const ret = wasm.org_is_enemy(this.ptr);
2014
+ const ret = wasm.org_is_enemy(this.__wbg_ptr);
1980
2015
  return ret !== 0;
1981
2016
  }
1982
2017
  /**
1983
2018
  * @returns {boolean}
1984
2019
  */
1985
2020
  is_single() {
1986
- const ret = wasm.org_is_single(this.ptr);
2021
+ const ret = wasm.org_is_single(this.__wbg_ptr);
1987
2022
  return ret !== 0;
1988
2023
  }
1989
2024
  /**
1990
2025
  * @returns {boolean}
1991
2026
  */
1992
2027
  is_combined() {
1993
- const ret = wasm.org_is_combined(this.ptr);
2028
+ const ret = wasm.org_is_combined(this.__wbg_ptr);
1994
2029
  return ret !== 0;
1995
2030
  }
1996
2031
  /**
@@ -1998,7 +2033,7 @@ export class Org {
1998
2033
  * @returns {number}
1999
2034
  */
2000
2035
  interception_power() {
2001
- const ret = wasm.org_interception_power(this.ptr);
2036
+ const ret = wasm.org_interception_power(this.__wbg_ptr);
2002
2037
  return ret;
2003
2038
  }
2004
2039
  /**
@@ -2006,7 +2041,7 @@ export class Org {
2006
2041
  * @returns {number}
2007
2042
  */
2008
2043
  high_altitude_interception_power() {
2009
- const ret = wasm.org_high_altitude_interception_power(this.ptr);
2044
+ const ret = wasm.org_high_altitude_interception_power(this.__wbg_ptr);
2010
2045
  return ret;
2011
2046
  }
2012
2047
  /**
@@ -2018,7 +2053,7 @@ export class Org {
2018
2053
  create_move_ship_payload(id, x, y) {
2019
2054
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2020
2055
  const len0 = WASM_VECTOR_LEN;
2021
- const ret = wasm.org_create_move_ship_payload(this.ptr, ptr0, len0, x, y);
2056
+ const ret = wasm.org_create_move_ship_payload(this.__wbg_ptr, ptr0, len0, x, y);
2022
2057
  return takeObject(ret);
2023
2058
  }
2024
2059
  /**
@@ -2026,26 +2061,27 @@ export class Org {
2026
2061
  * @returns {FleetType | undefined}
2027
2062
  */
2028
2063
  get_fleet_type(key) {
2029
- const ret = wasm.org_get_fleet_type(this.ptr, addHeapObject(key));
2064
+ const ret = wasm.org_get_fleet_type(this.__wbg_ptr, addHeapObject(key));
2030
2065
  return takeObject(ret);
2031
2066
  }
2032
2067
  }
2033
2068
 
2034
- const ShipFinalization = new FinalizationRegistry(ptr => wasm.__wbg_ship_free(ptr));
2069
+ const ShipFinalization = new FinalizationRegistry(ptr => wasm.__wbg_ship_free(ptr >>> 0));
2035
2070
  /**
2036
2071
  */
2037
2072
  export class Ship {
2038
2073
 
2039
2074
  static __wrap(ptr) {
2075
+ ptr = ptr >>> 0;
2040
2076
  const obj = Object.create(Ship.prototype);
2041
- obj.ptr = ptr;
2042
- ShipFinalization.register(obj, obj.ptr, obj);
2077
+ obj.__wbg_ptr = ptr;
2078
+ ShipFinalization.register(obj, obj.__wbg_ptr, obj);
2043
2079
  return obj;
2044
2080
  }
2045
2081
 
2046
2082
  __destroy_into_raw() {
2047
- const ptr = this.ptr;
2048
- this.ptr = 0;
2083
+ const ptr = this.__wbg_ptr;
2084
+ this.__wbg_ptr = 0;
2049
2085
  ShipFinalization.unregister(this);
2050
2086
  return ptr;
2051
2087
  }
@@ -2058,15 +2094,19 @@ export class Ship {
2058
2094
  * @returns {string}
2059
2095
  */
2060
2096
  get id() {
2097
+ let deferred1_0;
2098
+ let deferred1_1;
2061
2099
  try {
2062
2100
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2063
- wasm.__wbg_get_ship_id(retptr, this.ptr);
2101
+ wasm.__wbg_get_ship_id(retptr, this.__wbg_ptr);
2064
2102
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2065
2103
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2104
+ deferred1_0 = r0;
2105
+ deferred1_1 = r1;
2066
2106
  return getStringFromWasm0(r0, r1);
2067
2107
  } finally {
2068
2108
  wasm.__wbindgen_add_to_stack_pointer(16);
2069
- wasm.__wbindgen_free(r0, r1);
2109
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
2070
2110
  }
2071
2111
  }
2072
2112
  /**
@@ -2075,180 +2115,180 @@ export class Ship {
2075
2115
  set id(arg0) {
2076
2116
  const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2077
2117
  const len0 = WASM_VECTOR_LEN;
2078
- wasm.__wbg_set_ship_id(this.ptr, ptr0, len0);
2118
+ wasm.__wbg_set_ship_id(this.__wbg_ptr, ptr0, len0);
2079
2119
  }
2080
2120
  /**
2081
2121
  * @returns {bigint}
2082
2122
  */
2083
2123
  get hash() {
2084
- const ret = wasm.__wbg_get_ship_hash(this.ptr);
2124
+ const ret = wasm.__wbg_get_ship_hash(this.__wbg_ptr);
2085
2125
  return BigInt.asUintN(64, ret);
2086
2126
  }
2087
2127
  /**
2088
2128
  * @returns {number}
2089
2129
  */
2090
2130
  get ship_id() {
2091
- const ret = wasm.__wbg_get_ship_ship_id(this.ptr);
2131
+ const ret = wasm.__wbg_get_ship_ship_id(this.__wbg_ptr);
2092
2132
  return ret;
2093
2133
  }
2094
2134
  /**
2095
2135
  * @returns {number}
2096
2136
  */
2097
2137
  get level() {
2098
- const ret = wasm.__wbg_get_ship_level(this.ptr);
2138
+ const ret = wasm.__wbg_get_ship_level(this.__wbg_ptr);
2099
2139
  return ret;
2100
2140
  }
2101
2141
  /**
2102
2142
  * @returns {number}
2103
2143
  */
2104
2144
  get current_hp() {
2105
- const ret = wasm.__wbg_get_ship_current_hp(this.ptr);
2145
+ const ret = wasm.__wbg_get_ship_current_hp(this.__wbg_ptr);
2106
2146
  return ret;
2107
2147
  }
2108
2148
  /**
2109
2149
  * @returns {number}
2110
2150
  */
2111
2151
  get morale() {
2112
- const ret = wasm.__wbg_get_ship_morale(this.ptr);
2152
+ const ret = wasm.__wbg_get_ship_morale(this.__wbg_ptr);
2113
2153
  return ret;
2114
2154
  }
2115
2155
  /**
2116
2156
  * @returns {number}
2117
2157
  */
2118
2158
  get ammo() {
2119
- const ret = wasm.__wbg_get_ship_ammo(this.ptr);
2159
+ const ret = wasm.__wbg_get_ship_ammo(this.__wbg_ptr);
2120
2160
  return ret;
2121
2161
  }
2122
2162
  /**
2123
2163
  * @returns {number}
2124
2164
  */
2125
2165
  get fuel() {
2126
- const ret = wasm.__wbg_get_ship_fuel(this.ptr);
2166
+ const ret = wasm.__wbg_get_ship_fuel(this.__wbg_ptr);
2127
2167
  return ret;
2128
2168
  }
2129
2169
  /**
2130
2170
  * @returns {ShipType}
2131
2171
  */
2132
2172
  get ship_type() {
2133
- const ret = wasm.__wbg_get_ship_ship_type(this.ptr);
2173
+ const ret = wasm.__wbg_get_ship_ship_type(this.__wbg_ptr);
2134
2174
  return takeObject(ret);
2135
2175
  }
2136
2176
  /**
2137
2177
  * @returns {number}
2138
2178
  */
2139
2179
  get ctype() {
2140
- const ret = wasm.__wbg_get_ship_ctype(this.ptr);
2180
+ const ret = wasm.__wbg_get_ship_ctype(this.__wbg_ptr);
2141
2181
  return ret;
2142
2182
  }
2143
2183
  /**
2144
2184
  * @returns {SlotSizeVec}
2145
2185
  */
2146
2186
  get slots() {
2147
- const ret = wasm.__wbg_get_ship_slots(this.ptr);
2187
+ const ret = wasm.__wbg_get_ship_slots(this.__wbg_ptr);
2148
2188
  return takeObject(ret);
2149
2189
  }
2150
2190
  /**
2151
2191
  * @param {SlotSizeVec} arg0
2152
2192
  */
2153
2193
  set slots(arg0) {
2154
- wasm.__wbg_set_ship_slots(this.ptr, addHeapObject(arg0));
2194
+ wasm.__wbg_set_ship_slots(this.__wbg_ptr, addHeapObject(arg0));
2155
2195
  }
2156
2196
  /**
2157
2197
  * @returns {number | undefined}
2158
2198
  */
2159
2199
  get naked_firepower() {
2160
- const ret = wasm.ship_naked_firepower(this.ptr);
2200
+ const ret = wasm.ship_naked_firepower(this.__wbg_ptr);
2161
2201
  return ret === 0xFFFFFF ? undefined : ret;
2162
2202
  }
2163
2203
  /**
2164
2204
  * @returns {number | undefined}
2165
2205
  */
2166
2206
  get naked_torpedo() {
2167
- const ret = wasm.ship_naked_torpedo(this.ptr);
2207
+ const ret = wasm.ship_naked_torpedo(this.__wbg_ptr);
2168
2208
  return ret === 0xFFFFFF ? undefined : ret;
2169
2209
  }
2170
2210
  /**
2171
2211
  * @returns {number | undefined}
2172
2212
  */
2173
2213
  get naked_armor() {
2174
- const ret = wasm.ship_naked_armor(this.ptr);
2214
+ const ret = wasm.ship_naked_armor(this.__wbg_ptr);
2175
2215
  return ret === 0xFFFFFF ? undefined : ret;
2176
2216
  }
2177
2217
  /**
2178
2218
  * @returns {number | undefined}
2179
2219
  */
2180
2220
  get naked_anti_air() {
2181
- const ret = wasm.ship_naked_anti_air(this.ptr);
2221
+ const ret = wasm.ship_naked_anti_air(this.__wbg_ptr);
2182
2222
  return ret === 0xFFFFFF ? undefined : ret;
2183
2223
  }
2184
2224
  /**
2185
2225
  * @returns {number | undefined}
2186
2226
  */
2187
2227
  get naked_evasion() {
2188
- const ret = wasm.ship_naked_evasion(this.ptr);
2228
+ const ret = wasm.ship_naked_evasion(this.__wbg_ptr);
2189
2229
  return ret === 0xFFFFFF ? undefined : ret;
2190
2230
  }
2191
2231
  /**
2192
2232
  * @returns {number | undefined}
2193
2233
  */
2194
2234
  get naked_asw() {
2195
- const ret = wasm.ship_naked_asw(this.ptr);
2235
+ const ret = wasm.ship_naked_asw(this.__wbg_ptr);
2196
2236
  return ret === 0xFFFFFF ? undefined : ret;
2197
2237
  }
2198
2238
  /**
2199
2239
  * @returns {number | undefined}
2200
2240
  */
2201
2241
  get naked_los() {
2202
- const ret = wasm.ship_naked_los(this.ptr);
2242
+ const ret = wasm.ship_naked_los(this.__wbg_ptr);
2203
2243
  return ret === 0xFFFFFF ? undefined : ret;
2204
2244
  }
2205
2245
  /**
2206
2246
  * @returns {number | undefined}
2207
2247
  */
2208
2248
  get firepower() {
2209
- const ret = wasm.ship_firepower(this.ptr);
2249
+ const ret = wasm.ship_firepower(this.__wbg_ptr);
2210
2250
  return ret === 0xFFFFFF ? undefined : ret;
2211
2251
  }
2212
2252
  /**
2213
2253
  * @returns {number | undefined}
2214
2254
  */
2215
2255
  get torpedo() {
2216
- const ret = wasm.ship_torpedo(this.ptr);
2256
+ const ret = wasm.ship_torpedo(this.__wbg_ptr);
2217
2257
  return ret === 0xFFFFFF ? undefined : ret;
2218
2258
  }
2219
2259
  /**
2220
2260
  * @returns {number | undefined}
2221
2261
  */
2222
2262
  get armor() {
2223
- const ret = wasm.ship_armor(this.ptr);
2263
+ const ret = wasm.ship_armor(this.__wbg_ptr);
2224
2264
  return ret === 0xFFFFFF ? undefined : ret;
2225
2265
  }
2226
2266
  /**
2227
2267
  * @returns {number | undefined}
2228
2268
  */
2229
2269
  get anti_air() {
2230
- const ret = wasm.ship_anti_air(this.ptr);
2270
+ const ret = wasm.ship_anti_air(this.__wbg_ptr);
2231
2271
  return ret === 0xFFFFFF ? undefined : ret;
2232
2272
  }
2233
2273
  /**
2234
2274
  * @returns {number | undefined}
2235
2275
  */
2236
2276
  get evasion() {
2237
- const ret = wasm.ship_evasion(this.ptr);
2277
+ const ret = wasm.ship_evasion(this.__wbg_ptr);
2238
2278
  return ret === 0xFFFFFF ? undefined : ret;
2239
2279
  }
2240
2280
  /**
2241
2281
  * @returns {number | undefined}
2242
2282
  */
2243
2283
  get asw() {
2244
- const ret = wasm.ship_asw(this.ptr);
2284
+ const ret = wasm.ship_asw(this.__wbg_ptr);
2245
2285
  return ret === 0xFFFFFF ? undefined : ret;
2246
2286
  }
2247
2287
  /**
2248
2288
  * @returns {number | undefined}
2249
2289
  */
2250
2290
  get los() {
2251
- const ret = wasm.ship_los(this.ptr);
2291
+ const ret = wasm.ship_los(this.__wbg_ptr);
2252
2292
  return ret === 0xFFFFFF ? undefined : ret;
2253
2293
  }
2254
2294
  /**
@@ -2265,121 +2305,129 @@ export class Ship {
2265
2305
  eq_id(id) {
2266
2306
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2267
2307
  const len0 = WASM_VECTOR_LEN;
2268
- const ret = wasm.ship_eq_id(this.ptr, ptr0, len0);
2308
+ const ret = wasm.ship_eq_id(this.__wbg_ptr, ptr0, len0);
2269
2309
  return ret !== 0;
2270
2310
  }
2271
2311
  /**
2272
2312
  * @returns {ShipState}
2273
2313
  */
2274
2314
  state() {
2275
- const ret = wasm.ship_state(this.ptr);
2315
+ const ret = wasm.ship_state(this.__wbg_ptr);
2276
2316
  return takeObject(ret);
2277
2317
  }
2278
2318
  /**
2279
2319
  * @returns {CustomPowerModifiers}
2280
2320
  */
2281
2321
  custom_power_mods() {
2282
- const ret = wasm.ship_custom_power_mods(this.ptr);
2322
+ const ret = wasm.ship_custom_power_mods(this.__wbg_ptr);
2283
2323
  return takeObject(ret);
2284
2324
  }
2285
2325
  /**
2286
2326
  * @returns {ShipMeta}
2287
2327
  */
2288
2328
  meta() {
2289
- const ret = wasm.ship_meta(this.ptr);
2329
+ const ret = wasm.ship_meta(this.__wbg_ptr);
2290
2330
  return takeObject(ret);
2291
2331
  }
2292
2332
  /**
2293
2333
  * @returns {string}
2294
2334
  */
2295
2335
  get name() {
2336
+ let deferred1_0;
2337
+ let deferred1_1;
2296
2338
  try {
2297
2339
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2298
- wasm.ship_name(retptr, this.ptr);
2340
+ wasm.ship_name(retptr, this.__wbg_ptr);
2299
2341
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2300
2342
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2343
+ deferred1_0 = r0;
2344
+ deferred1_1 = r1;
2301
2345
  return getStringFromWasm0(r0, r1);
2302
2346
  } finally {
2303
2347
  wasm.__wbindgen_add_to_stack_pointer(16);
2304
- wasm.__wbindgen_free(r0, r1);
2348
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
2305
2349
  }
2306
2350
  }
2307
2351
  /**
2308
2352
  * @returns {string}
2309
2353
  */
2310
2354
  get yomi() {
2355
+ let deferred1_0;
2356
+ let deferred1_1;
2311
2357
  try {
2312
2358
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2313
- wasm.ship_yomi(retptr, this.ptr);
2359
+ wasm.ship_yomi(retptr, this.__wbg_ptr);
2314
2360
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2315
2361
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2362
+ deferred1_0 = r0;
2363
+ deferred1_1 = r1;
2316
2364
  return getStringFromWasm0(r0, r1);
2317
2365
  } finally {
2318
2366
  wasm.__wbindgen_add_to_stack_pointer(16);
2319
- wasm.__wbindgen_free(r0, r1);
2367
+ wasm.__wbindgen_free(deferred1_0, deferred1_1);
2320
2368
  }
2321
2369
  }
2322
2370
  /**
2323
2371
  * @returns {number}
2324
2372
  */
2325
2373
  get stype() {
2326
- const ret = wasm.ship_stype(this.ptr);
2374
+ const ret = wasm.ship_stype(this.__wbg_ptr);
2327
2375
  return ret;
2328
2376
  }
2329
2377
  /**
2330
2378
  * @returns {number}
2331
2379
  */
2332
2380
  get sort_id() {
2333
- const ret = wasm.ship_sort_id(this.ptr);
2381
+ const ret = wasm.ship_sort_id(this.__wbg_ptr);
2334
2382
  return ret;
2335
2383
  }
2336
2384
  /**
2337
2385
  * @returns {number}
2338
2386
  */
2339
2387
  remodel_rank() {
2340
- const ret = wasm.ship_remodel_rank(this.ptr);
2388
+ const ret = wasm.ship_remodel_rank(this.__wbg_ptr);
2341
2389
  return ret;
2342
2390
  }
2343
2391
  /**
2344
2392
  * @returns {number}
2345
2393
  */
2346
2394
  get slotnum() {
2347
- const ret = wasm.ship_slotnum(this.ptr);
2395
+ const ret = wasm.ship_slotnum(this.__wbg_ptr);
2348
2396
  return ret >>> 0;
2349
2397
  }
2350
2398
  /**
2351
2399
  * @returns {number}
2352
2400
  */
2353
2401
  get next_id() {
2354
- const ret = wasm.ship_next_id(this.ptr);
2402
+ const ret = wasm.ship_next_id(this.__wbg_ptr);
2355
2403
  return ret;
2356
2404
  }
2357
2405
  /**
2358
2406
  * @returns {boolean}
2359
2407
  */
2360
2408
  get useful() {
2361
- const ret = wasm.ship_useful(this.ptr);
2409
+ const ret = wasm.ship_useful(this.__wbg_ptr);
2362
2410
  return ret !== 0;
2363
2411
  }
2364
2412
  /**
2365
2413
  * @returns {DamageState}
2366
2414
  */
2367
2415
  damage_state() {
2368
- const ret = wasm.ship_damage_state(this.ptr);
2416
+ const ret = wasm.ship_damage_state(this.__wbg_ptr);
2369
2417
  return takeObject(ret);
2370
2418
  }
2371
2419
  /**
2372
2420
  * @returns {MoraleState}
2373
2421
  */
2374
2422
  morale_state() {
2375
- const ret = wasm.ship_morale_state(this.ptr);
2423
+ const ret = wasm.ship_morale_state(this.__wbg_ptr);
2376
2424
  return takeObject(ret);
2377
2425
  }
2378
2426
  /**
2379
2427
  * @returns {ShipCategory}
2380
2428
  */
2381
2429
  category() {
2382
- const ret = wasm.ship_category(this.ptr);
2430
+ const ret = wasm.ship_category(this.__wbg_ptr);
2383
2431
  return takeObject(ret);
2384
2432
  }
2385
2433
  /**
@@ -2387,7 +2435,7 @@ export class Ship {
2387
2435
  * @returns {boolean}
2388
2436
  */
2389
2437
  has_attr(attr) {
2390
- const ret = wasm.ship_has_attr(this.ptr, addHeapObject(attr));
2438
+ const ret = wasm.ship_has_attr(this.__wbg_ptr, addHeapObject(attr));
2391
2439
  return ret !== 0;
2392
2440
  }
2393
2441
  /**
@@ -2396,12 +2444,12 @@ export class Ship {
2396
2444
  gear_keys() {
2397
2445
  try {
2398
2446
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2399
- wasm.ship_gear_keys(retptr, this.ptr);
2447
+ wasm.ship_gear_keys(retptr, this.__wbg_ptr);
2400
2448
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2401
2449
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2402
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
2450
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2403
2451
  wasm.__wbindgen_free(r0, r1 * 4);
2404
- return v0;
2452
+ return v1;
2405
2453
  } finally {
2406
2454
  wasm.__wbindgen_add_to_stack_pointer(16);
2407
2455
  }
@@ -2413,7 +2461,7 @@ export class Ship {
2413
2461
  get_gear(key) {
2414
2462
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2415
2463
  const len0 = WASM_VECTOR_LEN;
2416
- const ret = wasm.ship_get_gear(this.ptr, ptr0, len0);
2464
+ const ret = wasm.ship_get_gear(this.__wbg_ptr, ptr0, len0);
2417
2465
  return ret === 0 ? undefined : Gear.__wrap(ret);
2418
2466
  }
2419
2467
  /**
@@ -2421,7 +2469,7 @@ export class Ship {
2421
2469
  * @returns {number | undefined}
2422
2470
  */
2423
2471
  get_damage_bound(state) {
2424
- const ret = wasm.ship_get_damage_bound(this.ptr, addHeapObject(state));
2472
+ const ret = wasm.ship_get_damage_bound(this.__wbg_ptr, addHeapObject(state));
2425
2473
  return ret === 0xFFFFFF ? undefined : ret;
2426
2474
  }
2427
2475
  /**
@@ -2430,7 +2478,7 @@ export class Ship {
2430
2478
  * @returns {number}
2431
2479
  */
2432
2480
  get_remaining_fuel(rate, ceil) {
2433
- const ret = wasm.ship_get_remaining_fuel(this.ptr, rate, ceil);
2481
+ const ret = wasm.ship_get_remaining_fuel(this.__wbg_ptr, rate, ceil);
2434
2482
  return ret;
2435
2483
  }
2436
2484
  /**
@@ -2439,7 +2487,7 @@ export class Ship {
2439
2487
  * @returns {number}
2440
2488
  */
2441
2489
  get_remaining_ammo(rate, ceil) {
2442
- const ret = wasm.ship_get_remaining_ammo(this.ptr, rate, ceil);
2490
+ const ret = wasm.ship_get_remaining_ammo(this.__wbg_ptr, rate, ceil);
2443
2491
  return ret;
2444
2492
  }
2445
2493
  /**
@@ -2449,7 +2497,7 @@ export class Ship {
2449
2497
  has_unknown_stat(key) {
2450
2498
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2451
2499
  const len0 = WASM_VECTOR_LEN;
2452
- const ret = wasm.ship_has_unknown_stat(this.ptr, ptr0, len0);
2500
+ const ret = wasm.ship_has_unknown_stat(this.__wbg_ptr, ptr0, len0);
2453
2501
  return ret !== 0;
2454
2502
  }
2455
2503
  /**
@@ -2459,7 +2507,7 @@ export class Ship {
2459
2507
  get_naked_stat(key) {
2460
2508
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2461
2509
  const len0 = WASM_VECTOR_LEN;
2462
- const ret = wasm.ship_get_naked_stat(this.ptr, ptr0, len0);
2510
+ const ret = wasm.ship_get_naked_stat(this.__wbg_ptr, ptr0, len0);
2463
2511
  return ret === 0xFFFFFF ? undefined : ret;
2464
2512
  }
2465
2513
  /**
@@ -2469,7 +2517,7 @@ export class Ship {
2469
2517
  get_stat_interval_left(key) {
2470
2518
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2471
2519
  const len0 = WASM_VECTOR_LEN;
2472
- const ret = wasm.ship_get_stat_interval_left(this.ptr, ptr0, len0);
2520
+ const ret = wasm.ship_get_stat_interval_left(this.__wbg_ptr, ptr0, len0);
2473
2521
  return ret === 0xFFFFFF ? undefined : ret;
2474
2522
  }
2475
2523
  /**
@@ -2479,7 +2527,7 @@ export class Ship {
2479
2527
  get_stat_interval_right(key) {
2480
2528
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2481
2529
  const len0 = WASM_VECTOR_LEN;
2482
- const ret = wasm.ship_get_stat_interval_right(this.ptr, ptr0, len0);
2530
+ const ret = wasm.ship_get_stat_interval_right(this.__wbg_ptr, ptr0, len0);
2483
2531
  return ret === 0xFFFFFF ? undefined : ret;
2484
2532
  }
2485
2533
  /**
@@ -2489,7 +2537,7 @@ export class Ship {
2489
2537
  get_gear_stat(key) {
2490
2538
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2491
2539
  const len0 = WASM_VECTOR_LEN;
2492
- const ret = wasm.ship_get_gear_stat(this.ptr, ptr0, len0);
2540
+ const ret = wasm.ship_get_gear_stat(this.__wbg_ptr, ptr0, len0);
2493
2541
  return ret;
2494
2542
  }
2495
2543
  /**
@@ -2499,7 +2547,7 @@ export class Ship {
2499
2547
  get_ebonus(key) {
2500
2548
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2501
2549
  const len0 = WASM_VECTOR_LEN;
2502
- const ret = wasm.ship_get_ebonus(this.ptr, ptr0, len0);
2550
+ const ret = wasm.ship_get_ebonus(this.__wbg_ptr, ptr0, len0);
2503
2551
  return ret;
2504
2552
  }
2505
2553
  /**
@@ -2509,28 +2557,28 @@ export class Ship {
2509
2557
  get_stat_mod(key) {
2510
2558
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2511
2559
  const len0 = WASM_VECTOR_LEN;
2512
- const ret = wasm.ship_get_stat_mod(this.ptr, ptr0, len0);
2560
+ const ret = wasm.ship_get_stat_mod(this.__wbg_ptr, ptr0, len0);
2513
2561
  return ret === 0xFFFFFF ? undefined : ret;
2514
2562
  }
2515
2563
  /**
2516
2564
  * @returns {boolean}
2517
2565
  */
2518
2566
  is_abyssal() {
2519
- const ret = wasm.ship_is_abyssal(this.ptr);
2567
+ const ret = wasm.ship_is_abyssal(this.__wbg_ptr);
2520
2568
  return ret !== 0;
2521
2569
  }
2522
2570
  /**
2523
2571
  * @returns {boolean}
2524
2572
  */
2525
2573
  is_submarine() {
2526
- const ret = wasm.ship_is_submarine(this.ptr);
2574
+ const ret = wasm.ship_is_submarine(this.__wbg_ptr);
2527
2575
  return ret !== 0;
2528
2576
  }
2529
2577
  /**
2530
2578
  * @returns {boolean}
2531
2579
  */
2532
2580
  is_amagiri() {
2533
- const ret = wasm.ship_is_amagiri(this.ptr);
2581
+ const ret = wasm.ship_is_amagiri(this.__wbg_ptr);
2534
2582
  return ret !== 0;
2535
2583
  }
2536
2584
  /**
@@ -2542,105 +2590,105 @@ export class Ship {
2542
2590
  _assertClass(gear, Gear);
2543
2591
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2544
2592
  const len0 = WASM_VECTOR_LEN;
2545
- const ret = wasm.ship_can_equip(this.ptr, gear.ptr, ptr0, len0);
2593
+ const ret = wasm.ship_can_equip(this.__wbg_ptr, gear.__wbg_ptr, ptr0, len0);
2546
2594
  return ret !== 0;
2547
2595
  }
2548
2596
  /**
2549
2597
  * @returns {number | undefined}
2550
2598
  */
2551
2599
  get max_hp() {
2552
- const ret = wasm.ship_max_hp(this.ptr);
2600
+ const ret = wasm.ship_max_hp(this.__wbg_ptr);
2553
2601
  return ret === 0xFFFFFF ? undefined : ret;
2554
2602
  }
2555
2603
  /**
2556
2604
  * @returns {number}
2557
2605
  */
2558
2606
  get max_ammo() {
2559
- const ret = wasm.ship_max_ammo(this.ptr);
2607
+ const ret = wasm.ship_max_ammo(this.__wbg_ptr);
2560
2608
  return ret;
2561
2609
  }
2562
2610
  /**
2563
2611
  * @returns {number}
2564
2612
  */
2565
2613
  get max_fuel() {
2566
- const ret = wasm.ship_max_fuel(this.ptr);
2614
+ const ret = wasm.ship_max_fuel(this.__wbg_ptr);
2567
2615
  return ret;
2568
2616
  }
2569
2617
  /**
2570
2618
  * @returns {number | undefined}
2571
2619
  */
2572
2620
  get naked_range() {
2573
- const ret = wasm.ship_naked_range(this.ptr);
2621
+ const ret = wasm.ship_naked_range(this.__wbg_ptr);
2574
2622
  return ret === 0xFFFFFF ? undefined : ret;
2575
2623
  }
2576
2624
  /**
2577
2625
  * @returns {number}
2578
2626
  */
2579
2627
  get naked_speed() {
2580
- const ret = wasm.ship_naked_speed(this.ptr);
2628
+ const ret = wasm.ship_naked_speed(this.__wbg_ptr);
2581
2629
  return ret;
2582
2630
  }
2583
2631
  /**
2584
2632
  * @returns {number | undefined}
2585
2633
  */
2586
2634
  get luck() {
2587
- const ret = wasm.ship_luck(this.ptr);
2635
+ const ret = wasm.ship_luck(this.__wbg_ptr);
2588
2636
  return ret === 0xFFFFFF ? undefined : ret;
2589
2637
  }
2590
2638
  /**
2591
2639
  * @returns {number | undefined}
2592
2640
  */
2593
2641
  get range() {
2594
- const ret = wasm.ship_range(this.ptr);
2642
+ const ret = wasm.ship_range(this.__wbg_ptr);
2595
2643
  return ret === 0xFFFFFF ? undefined : ret;
2596
2644
  }
2597
2645
  /**
2598
2646
  * @returns {number}
2599
2647
  */
2600
2648
  get speed() {
2601
- const ret = wasm.ship_speed(this.ptr);
2649
+ const ret = wasm.ship_speed(this.__wbg_ptr);
2602
2650
  return ret;
2603
2651
  }
2604
2652
  /**
2605
2653
  * @returns {number}
2606
2654
  */
2607
2655
  get accuracy() {
2608
- const ret = wasm.ship_accuracy(this.ptr);
2656
+ const ret = wasm.ship_accuracy(this.__wbg_ptr);
2609
2657
  return ret;
2610
2658
  }
2611
2659
  /**
2612
2660
  * @returns {number}
2613
2661
  */
2614
2662
  get innate_torpedo_accuracy() {
2615
- const ret = wasm.ship_innate_torpedo_accuracy(this.ptr);
2663
+ const ret = wasm.ship_innate_torpedo_accuracy(this.__wbg_ptr);
2616
2664
  return ret;
2617
2665
  }
2618
2666
  /**
2619
2667
  * @returns {boolean}
2620
2668
  */
2621
2669
  is_installation() {
2622
- const ret = wasm.ship_is_installation(this.ptr);
2670
+ const ret = wasm.ship_is_installation(this.__wbg_ptr);
2623
2671
  return ret !== 0;
2624
2672
  }
2625
2673
  /**
2626
2674
  * @returns {boolean}
2627
2675
  */
2628
2676
  is_pt_imp() {
2629
- const ret = wasm.ship_is_pt_imp(this.ptr);
2677
+ const ret = wasm.ship_is_pt_imp(this.__wbg_ptr);
2630
2678
  return ret !== 0;
2631
2679
  }
2632
2680
  /**
2633
2681
  * @returns {SpecialEnemyType}
2634
2682
  */
2635
2683
  special_enemy_type() {
2636
- const ret = wasm.ship_special_enemy_type(this.ptr);
2684
+ const ret = wasm.ship_special_enemy_type(this.__wbg_ptr);
2637
2685
  return takeObject(ret);
2638
2686
  }
2639
2687
  /**
2640
2688
  * @returns {boolean}
2641
2689
  */
2642
2690
  is_attackable_by_torpedo() {
2643
- const ret = wasm.ship_is_attackable_by_torpedo(this.ptr);
2691
+ const ret = wasm.ship_is_attackable_by_torpedo(this.__wbg_ptr);
2644
2692
  return ret !== 0;
2645
2693
  }
2646
2694
  /**
@@ -2648,7 +2696,7 @@ export class Ship {
2648
2696
  * @returns {number | undefined}
2649
2697
  */
2650
2698
  get_slot_size(index) {
2651
- const ret = wasm.ship_get_slot_size(this.ptr, index);
2699
+ const ret = wasm.ship_get_slot_size(this.__wbg_ptr, index);
2652
2700
  return ret === 0xFFFFFF ? undefined : ret;
2653
2701
  }
2654
2702
  /**
@@ -2656,21 +2704,21 @@ export class Ship {
2656
2704
  * @returns {number | undefined}
2657
2705
  */
2658
2706
  get_max_slot_size(index) {
2659
- const ret = wasm.ship_get_max_slot_size(this.ptr, index);
2707
+ const ret = wasm.ship_get_max_slot_size(this.__wbg_ptr, index);
2660
2708
  return ret === 0xFFFFFF ? undefined : ret;
2661
2709
  }
2662
2710
  /**
2663
2711
  * @returns {number}
2664
2712
  */
2665
2713
  remaining_ammo_mod() {
2666
- const ret = wasm.ship_remaining_ammo_mod(this.ptr);
2714
+ const ret = wasm.ship_remaining_ammo_mod(this.__wbg_ptr);
2667
2715
  return ret;
2668
2716
  }
2669
2717
  /**
2670
2718
  * @returns {number}
2671
2719
  */
2672
2720
  remaining_fuel_mod() {
2673
- const ret = wasm.ship_remaining_fuel_mod(this.ptr);
2721
+ const ret = wasm.ship_remaining_fuel_mod(this.__wbg_ptr);
2674
2722
  return ret;
2675
2723
  }
2676
2724
  /**
@@ -2680,7 +2728,7 @@ export class Ship {
2680
2728
  fighter_power(air_type) {
2681
2729
  try {
2682
2730
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2683
- wasm.ship_fighter_power(retptr, this.ptr, addHeapObject(air_type));
2731
+ wasm.ship_fighter_power(retptr, this.__wbg_ptr, addHeapObject(air_type));
2684
2732
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2685
2733
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2686
2734
  return r0 === 0 ? undefined : r1;
@@ -2694,7 +2742,7 @@ export class Ship {
2694
2742
  fleet_los_factor() {
2695
2743
  try {
2696
2744
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2697
- wasm.ship_fleet_los_factor(retptr, this.ptr);
2745
+ wasm.ship_fleet_los_factor(retptr, this.__wbg_ptr);
2698
2746
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2699
2747
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2700
2748
  return r0 === 0 ? undefined : r2;
@@ -2710,7 +2758,7 @@ export class Ship {
2710
2758
  ship_adjusted_anti_air(side) {
2711
2759
  try {
2712
2760
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2713
- wasm.ship_ship_adjusted_anti_air(retptr, this.ptr, addHeapObject(side));
2761
+ wasm.ship_ship_adjusted_anti_air(retptr, this.__wbg_ptr, addHeapObject(side));
2714
2762
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2715
2763
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2716
2764
  return r0 === 0 ? undefined : r2;
@@ -2723,14 +2771,14 @@ export class Ship {
2723
2771
  * @returns {number}
2724
2772
  */
2725
2773
  fleet_anti_air_mod() {
2726
- const ret = wasm.ship_fleet_anti_air_mod(this.ptr);
2774
+ const ret = wasm.ship_fleet_anti_air_mod(this.__wbg_ptr);
2727
2775
  return ret;
2728
2776
  }
2729
2777
  /**
2730
2778
  * @returns {number}
2731
2779
  */
2732
2780
  cruiser_fit_bonus() {
2733
- const ret = wasm.ship_cruiser_fit_bonus(this.ptr);
2781
+ const ret = wasm.ship_cruiser_fit_bonus(this.__wbg_ptr);
2734
2782
  return ret;
2735
2783
  }
2736
2784
  /**
@@ -2739,7 +2787,7 @@ export class Ship {
2739
2787
  basic_accuracy_term() {
2740
2788
  try {
2741
2789
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2742
- wasm.ship_basic_accuracy_term(retptr, this.ptr);
2790
+ wasm.ship_basic_accuracy_term(retptr, this.__wbg_ptr);
2743
2791
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2744
2792
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2745
2793
  return r0 === 0 ? undefined : r2;
@@ -2753,7 +2801,7 @@ export class Ship {
2753
2801
  basic_evasion_term() {
2754
2802
  try {
2755
2803
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2756
- wasm.ship_basic_evasion_term(retptr, this.ptr);
2804
+ wasm.ship_basic_evasion_term(retptr, this.__wbg_ptr);
2757
2805
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2758
2806
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2759
2807
  return r0 === 0 ? undefined : r2;
@@ -2770,7 +2818,7 @@ export class Ship {
2770
2818
  evasion_term(formation_mod, postcap_additive, postcap_multiplicative) {
2771
2819
  try {
2772
2820
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2773
- wasm.ship_evasion_term(retptr, this.ptr, formation_mod, postcap_additive, postcap_multiplicative);
2821
+ wasm.ship_evasion_term(retptr, this.__wbg_ptr, formation_mod, postcap_additive, postcap_multiplicative);
2774
2822
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2775
2823
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2776
2824
  return r0 === 0 ? undefined : r2;
@@ -2785,7 +2833,7 @@ export class Ship {
2785
2833
  basic_defense_power(armor_penetration) {
2786
2834
  try {
2787
2835
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2788
- wasm.ship_basic_defense_power(retptr, this.ptr, armor_penetration);
2836
+ wasm.ship_basic_defense_power(retptr, this.__wbg_ptr, armor_penetration);
2789
2837
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2790
2838
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2791
2839
  return r0 === 0 ? undefined : r2;
@@ -2797,7 +2845,7 @@ export class Ship {
2797
2845
  * @returns {number}
2798
2846
  */
2799
2847
  transport_point() {
2800
- const ret = wasm.ship_transport_point(this.ptr);
2848
+ const ret = wasm.ship_transport_point(this.__wbg_ptr);
2801
2849
  return ret;
2802
2850
  }
2803
2851
  /**
@@ -2807,7 +2855,7 @@ export class Ship {
2807
2855
  elos(node_divaricated_factor) {
2808
2856
  try {
2809
2857
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2810
- wasm.ship_elos(retptr, this.ptr, node_divaricated_factor);
2858
+ wasm.ship_elos(retptr, this.__wbg_ptr, node_divaricated_factor);
2811
2859
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2812
2860
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2813
2861
  return r0 === 0 ? undefined : r2;
@@ -2822,7 +2870,7 @@ export class Ship {
2822
2870
  ohko_power() {
2823
2871
  try {
2824
2872
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2825
- wasm.ship_ohko_power(retptr, this.ptr);
2873
+ wasm.ship_ohko_power(retptr, this.__wbg_ptr);
2826
2874
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2827
2875
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2828
2876
  return r0 === 0 ? undefined : r2;
@@ -2836,7 +2884,7 @@ export class Ship {
2836
2884
  state_day_gunfit_accuracy() {
2837
2885
  try {
2838
2886
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2839
- wasm.ship_state_day_gunfit_accuracy(retptr, this.ptr);
2887
+ wasm.ship_state_day_gunfit_accuracy(retptr, this.__wbg_ptr);
2840
2888
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2841
2889
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2842
2890
  return r0 === 0 ? undefined : r2;
@@ -2850,7 +2898,7 @@ export class Ship {
2850
2898
  state_night_gunfit_accuracy() {
2851
2899
  try {
2852
2900
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2853
- wasm.ship_state_night_gunfit_accuracy(retptr, this.ptr);
2901
+ wasm.ship_state_night_gunfit_accuracy(retptr, this.__wbg_ptr);
2854
2902
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2855
2903
  var r2 = getFloat64Memory0()[retptr / 8 + 1];
2856
2904
  return r0 === 0 ? undefined : r2;
@@ -2864,7 +2912,7 @@ export class Ship {
2864
2912
  * @returns {number}
2865
2913
  */
2866
2914
  gunfit_accuracy(is_night) {
2867
- const ret = wasm.ship_gunfit_accuracy(this.ptr, is_night);
2915
+ const ret = wasm.ship_gunfit_accuracy(this.__wbg_ptr, is_night);
2868
2916
  return ret;
2869
2917
  }
2870
2918
  }
@@ -2874,15 +2922,15 @@ export function __wbindgen_object_clone_ref(arg0) {
2874
2922
  return addHeapObject(ret);
2875
2923
  };
2876
2924
 
2925
+ export function __wbindgen_object_drop_ref(arg0) {
2926
+ takeObject(arg0);
2927
+ };
2928
+
2877
2929
  export function __wbindgen_string_new(arg0, arg1) {
2878
2930
  const ret = getStringFromWasm0(arg0, arg1);
2879
2931
  return addHeapObject(ret);
2880
2932
  };
2881
2933
 
2882
- export function __wbindgen_object_drop_ref(arg0) {
2883
- takeObject(arg0);
2884
- };
2885
-
2886
2934
  export function __wbindgen_is_undefined(arg0) {
2887
2935
  const ret = getObject(arg0) === undefined;
2888
2936
  return ret;
@@ -2893,7 +2941,7 @@ export function __wbg_ship_new(arg0) {
2893
2941
  return addHeapObject(ret);
2894
2942
  };
2895
2943
 
2896
- export function __wbg_createEquipmentBonuses_834ff059bf0b8153(arg0, arg1) {
2944
+ export function __wbg_createEquipmentBonuses_3f8344acc2a458d7(arg0, arg1) {
2897
2945
  const ret = createEquipmentBonuses(takeObject(arg0), takeObject(arg1));
2898
2946
  return addHeapObject(ret);
2899
2947
  };
@@ -2905,28 +2953,24 @@ export function __wbg_new_abda76e883ba8a5f() {
2905
2953
 
2906
2954
  export function __wbg_stack_658279fe44541cf6(arg0, arg1) {
2907
2955
  const ret = getObject(arg1).stack;
2908
- const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2909
- const len0 = WASM_VECTOR_LEN;
2910
- getInt32Memory0()[arg0 / 4 + 1] = len0;
2911
- getInt32Memory0()[arg0 / 4 + 0] = ptr0;
2956
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2957
+ const len1 = WASM_VECTOR_LEN;
2958
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
2959
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2912
2960
  };
2913
2961
 
2914
2962
  export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
2963
+ let deferred0_0;
2964
+ let deferred0_1;
2915
2965
  try {
2966
+ deferred0_0 = arg0;
2967
+ deferred0_1 = arg1;
2916
2968
  console.error(getStringFromWasm0(arg0, arg1));
2917
2969
  } finally {
2918
- wasm.__wbindgen_free(arg0, arg1);
2970
+ wasm.__wbindgen_free(deferred0_0, deferred0_1);
2919
2971
  }
2920
2972
  };
2921
2973
 
2922
- export function __wbg_getRandomValues_3774744e221a22ad() { return handleError(function (arg0, arg1) {
2923
- getObject(arg0).getRandomValues(getObject(arg1));
2924
- }, arguments) };
2925
-
2926
- export function __wbg_randomFillSync_e950366c42764a07() { return handleError(function (arg0, arg1) {
2927
- getObject(arg0).randomFillSync(takeObject(arg1));
2928
- }, arguments) };
2929
-
2930
2974
  export function __wbg_crypto_70a96de3b6b73dac(arg0) {
2931
2975
  const ret = getObject(arg0).crypto;
2932
2976
  return addHeapObject(ret);
@@ -2973,17 +3017,25 @@ export function __wbindgen_is_function(arg0) {
2973
3017
  return ret;
2974
3018
  };
2975
3019
 
2976
- export function __wbg_new_b525de17f44a8943() {
3020
+ export function __wbg_getRandomValues_3774744e221a22ad() { return handleError(function (arg0, arg1) {
3021
+ getObject(arg0).getRandomValues(getObject(arg1));
3022
+ }, arguments) };
3023
+
3024
+ export function __wbg_randomFillSync_e950366c42764a07() { return handleError(function (arg0, arg1) {
3025
+ getObject(arg0).randomFillSync(takeObject(arg1));
3026
+ }, arguments) };
3027
+
3028
+ export function __wbg_new_0394642eae39db16() {
2977
3029
  const ret = new Array();
2978
3030
  return addHeapObject(ret);
2979
3031
  };
2980
3032
 
2981
- export function __wbg_newnoargs_2b8b6bd7753c76ba(arg0, arg1) {
3033
+ export function __wbg_newnoargs_c9e6043b8ad84109(arg0, arg1) {
2982
3034
  const ret = new Function(getStringFromWasm0(arg0, arg1));
2983
3035
  return addHeapObject(ret);
2984
3036
  };
2985
3037
 
2986
- export function __wbg_call_95d1ea488d03e4e8() { return handleError(function (arg0, arg1) {
3038
+ export function __wbg_call_557a2f2deacc4912() { return handleError(function (arg0, arg1) {
2987
3039
  const ret = getObject(arg0).call(getObject(arg1));
2988
3040
  return addHeapObject(ret);
2989
3041
  }, arguments) };
@@ -2991,77 +3043,77 @@ export function __wbg_call_95d1ea488d03e4e8() { return handleError(function (arg
2991
3043
  export function __wbindgen_string_get(arg0, arg1) {
2992
3044
  const obj = getObject(arg1);
2993
3045
  const ret = typeof(obj) === 'string' ? obj : undefined;
2994
- var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2995
- var len0 = WASM_VECTOR_LEN;
2996
- getInt32Memory0()[arg0 / 4 + 1] = len0;
2997
- getInt32Memory0()[arg0 / 4 + 0] = ptr0;
3046
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3047
+ var len1 = WASM_VECTOR_LEN;
3048
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
3049
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2998
3050
  };
2999
3051
 
3000
- export function __wbg_self_e7c1f827057f6584() { return handleError(function () {
3052
+ export function __wbg_self_742dd6eab3e9211e() { return handleError(function () {
3001
3053
  const ret = self.self;
3002
3054
  return addHeapObject(ret);
3003
3055
  }, arguments) };
3004
3056
 
3005
- export function __wbg_window_a09ec664e14b1b81() { return handleError(function () {
3057
+ export function __wbg_window_c409e731db53a0e2() { return handleError(function () {
3006
3058
  const ret = window.window;
3007
3059
  return addHeapObject(ret);
3008
3060
  }, arguments) };
3009
3061
 
3010
- export function __wbg_globalThis_87cbb8506fecf3a9() { return handleError(function () {
3062
+ export function __wbg_globalThis_b70c095388441f2d() { return handleError(function () {
3011
3063
  const ret = globalThis.globalThis;
3012
3064
  return addHeapObject(ret);
3013
3065
  }, arguments) };
3014
3066
 
3015
- export function __wbg_global_c85a9259e621f3db() { return handleError(function () {
3067
+ export function __wbg_global_1c72617491ed7194() { return handleError(function () {
3016
3068
  const ret = global.global;
3017
3069
  return addHeapObject(ret);
3018
3070
  }, arguments) };
3019
3071
 
3020
- export function __wbg_push_49c286f04dd3bf59(arg0, arg1) {
3072
+ export function __wbg_push_109cfc26d02582dd(arg0, arg1) {
3021
3073
  const ret = getObject(arg0).push(getObject(arg1));
3022
3074
  return ret;
3023
3075
  };
3024
3076
 
3025
- export function __wbg_call_9495de66fdbe016b() { return handleError(function (arg0, arg1, arg2) {
3077
+ export function __wbg_call_587b30eea3e09332() { return handleError(function (arg0, arg1, arg2) {
3026
3078
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
3027
3079
  return addHeapObject(ret);
3028
3080
  }, arguments) };
3029
3081
 
3030
- export function __wbg_buffer_cf65c07de34b9a08(arg0) {
3082
+ export function __wbg_buffer_55ba7a6b1b92e2ac(arg0) {
3031
3083
  const ret = getObject(arg0).buffer;
3032
3084
  return addHeapObject(ret);
3033
3085
  };
3034
3086
 
3035
- export function __wbg_newwithbyteoffsetandlength_9fb2f11355ecadf5(arg0, arg1, arg2) {
3087
+ export function __wbg_newwithbyteoffsetandlength_88d1d8be5df94b9b(arg0, arg1, arg2) {
3036
3088
  const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
3037
3089
  return addHeapObject(ret);
3038
3090
  };
3039
3091
 
3040
- export function __wbg_new_537b7341ce90bb31(arg0) {
3092
+ export function __wbg_new_09938a7d020f049b(arg0) {
3041
3093
  const ret = new Uint8Array(getObject(arg0));
3042
3094
  return addHeapObject(ret);
3043
3095
  };
3044
3096
 
3045
- export function __wbg_set_17499e8aa4003ebd(arg0, arg1, arg2) {
3097
+ export function __wbg_set_3698e3ca519b3c3c(arg0, arg1, arg2) {
3046
3098
  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
3047
3099
  };
3048
3100
 
3049
- export function __wbg_newwithlength_b56c882b57805732(arg0) {
3101
+ export function __wbg_newwithlength_89eeca401d8918c2(arg0) {
3050
3102
  const ret = new Uint8Array(arg0 >>> 0);
3051
3103
  return addHeapObject(ret);
3052
3104
  };
3053
3105
 
3054
- export function __wbg_subarray_7526649b91a252a6(arg0, arg1, arg2) {
3106
+ export function __wbg_subarray_d82be056deb4ad27(arg0, arg1, arg2) {
3055
3107
  const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
3056
3108
  return addHeapObject(ret);
3057
3109
  };
3058
3110
 
3059
- export function __wbg_parse_3ac95b51fc312db8() { return handleError(function (arg0, arg1) {
3111
+ export function __wbg_parse_76a8a18ca3f8730b() { return handleError(function (arg0, arg1) {
3060
3112
  const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3061
3113
  return addHeapObject(ret);
3062
3114
  }, arguments) };
3063
3115
 
3064
- export function __wbg_stringify_029a979dfb73aa17() { return handleError(function (arg0) {
3116
+ export function __wbg_stringify_d06ad2addc54d51e() { return handleError(function (arg0) {
3065
3117
  const ret = JSON.stringify(getObject(arg0));
3066
3118
  return addHeapObject(ret);
3067
3119
  }, arguments) };