fleethub-core 1.12.17 → 1.12.19

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.
@@ -1,201 +1,18 @@
1
-
2
- let imports = {};
3
- imports['__wbindgen_placeholder__'] = module.exports;
4
- imports['equipment-bonus'] = require('equipment-bonus');
5
-
6
- function addToExternrefTable0(obj) {
7
- const idx = wasm.__externref_table_alloc();
8
- wasm.__wbindgen_export_2.set(idx, obj);
9
- return idx;
10
- }
11
-
12
- function handleError(f, args) {
13
- try {
14
- return f.apply(this, args);
15
- } catch (e) {
16
- const idx = addToExternrefTable0(e);
17
- wasm.__wbindgen_exn_store(idx);
18
- }
19
- }
20
-
21
- let cachedUint8ArrayMemory0 = null;
22
-
23
- function getUint8ArrayMemory0() {
24
- if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
25
- cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
26
- }
27
- return cachedUint8ArrayMemory0;
28
- }
29
-
30
- let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
31
-
32
- cachedTextDecoder.decode();
33
-
34
- function decodeText(ptr, len) {
35
- return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
36
- }
37
-
38
- function getStringFromWasm0(ptr, len) {
39
- ptr = ptr >>> 0;
40
- return decodeText(ptr, len);
41
- }
42
-
43
- function getArrayU8FromWasm0(ptr, len) {
44
- ptr = ptr >>> 0;
45
- return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
46
- }
47
-
48
- let WASM_VECTOR_LEN = 0;
49
-
50
- const cachedTextEncoder = new TextEncoder();
51
-
52
- if (!('encodeInto' in cachedTextEncoder)) {
53
- cachedTextEncoder.encodeInto = function (arg, view) {
54
- const buf = cachedTextEncoder.encode(arg);
55
- view.set(buf);
56
- return {
57
- read: arg.length,
58
- written: buf.length
59
- };
60
- }
61
- }
62
-
63
- function passStringToWasm0(arg, malloc, realloc) {
64
-
65
- if (realloc === undefined) {
66
- const buf = cachedTextEncoder.encode(arg);
67
- const ptr = malloc(buf.length, 1) >>> 0;
68
- getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
69
- WASM_VECTOR_LEN = buf.length;
70
- return ptr;
71
- }
72
-
73
- let len = arg.length;
74
- let ptr = malloc(len, 1) >>> 0;
75
-
76
- const mem = getUint8ArrayMemory0();
77
-
78
- let offset = 0;
79
-
80
- for (; offset < len; offset++) {
81
- const code = arg.charCodeAt(offset);
82
- if (code > 0x7F) break;
83
- mem[ptr + offset] = code;
84
- }
85
-
86
- if (offset !== len) {
87
- if (offset !== 0) {
88
- arg = arg.slice(offset);
89
- }
90
- ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
91
- const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
92
- const ret = cachedTextEncoder.encodeInto(arg, view);
93
-
94
- offset += ret.written;
95
- ptr = realloc(ptr, len, offset, 1) >>> 0;
96
- }
97
-
98
- WASM_VECTOR_LEN = offset;
99
- return ptr;
100
- }
101
-
102
- let cachedDataViewMemory0 = null;
103
-
104
- function getDataViewMemory0() {
105
- if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
106
- cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
107
- }
108
- return cachedDataViewMemory0;
109
- }
110
-
111
- function isLikeNone(x) {
112
- return x === undefined || x === null;
113
- }
114
-
115
- let cachedUint16ArrayMemory0 = null;
116
-
117
- function getUint16ArrayMemory0() {
118
- if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
119
- cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
120
- }
121
- return cachedUint16ArrayMemory0;
122
- }
123
-
124
- function passArray16ToWasm0(arg, malloc) {
125
- const ptr = malloc(arg.length * 2, 2) >>> 0;
126
- getUint16ArrayMemory0().set(arg, ptr / 2);
127
- WASM_VECTOR_LEN = arg.length;
128
- return ptr;
129
- }
130
-
131
- function takeFromExternrefTable0(idx) {
132
- const value = wasm.__wbindgen_export_2.get(idx);
133
- wasm.__externref_table_dealloc(idx);
134
- return value;
135
- }
136
-
137
- function _assertClass(instance, klass) {
138
- if (!(instance instanceof klass)) {
139
- throw new Error(`expected instance of ${klass.name}`);
140
- }
141
- }
142
-
143
- function getArrayJsValueFromWasm0(ptr, len) {
144
- ptr = ptr >>> 0;
145
- const mem = getDataViewMemory0();
146
- const result = [];
147
- for (let i = ptr; i < ptr + 4 * len; i += 4) {
148
- result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
149
- }
150
- wasm.__externref_drop_slice(ptr, len);
151
- return result;
152
- }
153
- /**
154
- * @param {ShipConditions} value
155
- * @returns {ShipConditions}
156
- */
157
- exports.parse_ship_conditions = function(value) {
158
- const ret = wasm.parse_ship_conditions(value);
159
- return ret;
160
- };
161
-
162
- exports.set_panic_hook = function() {
163
- wasm.set_panic_hook();
164
- };
165
-
166
- function getArrayU16FromWasm0(ptr, len) {
167
- ptr = ptr >>> 0;
168
- return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
169
- }
170
-
171
- function passArray8ToWasm0(arg, malloc) {
172
- const ptr = malloc(arg.length * 1, 1) >>> 0;
173
- getUint8ArrayMemory0().set(arg, ptr / 1);
174
- WASM_VECTOR_LEN = arg.length;
175
- return ptr;
176
- }
177
-
178
- const AirSquadronFinalization = (typeof FinalizationRegistry === 'undefined')
179
- ? { register: () => {}, unregister: () => {} }
180
- : new FinalizationRegistry(ptr => wasm.__wbg_airsquadron_free(ptr >>> 0, 1));
1
+ /* @ts-self-types="./fleethub_core.d.ts" */
181
2
 
182
3
  class AirSquadron {
183
-
184
4
  static __wrap(ptr) {
185
- ptr = ptr >>> 0;
186
5
  const obj = Object.create(AirSquadron.prototype);
187
6
  obj.__wbg_ptr = ptr;
188
7
  AirSquadronFinalization.register(obj, obj.__wbg_ptr, obj);
189
8
  return obj;
190
9
  }
191
-
192
10
  __destroy_into_raw() {
193
11
  const ptr = this.__wbg_ptr;
194
12
  this.__wbg_ptr = 0;
195
13
  AirSquadronFinalization.unregister(this);
196
14
  return ptr;
197
15
  }
198
-
199
16
  free() {
200
17
  const ptr = this.__destroy_into_raw();
201
18
  wasm.__wbg_airsquadron_free(ptr, 0);
@@ -207,12 +24,22 @@ class AirSquadron {
207
24
  const ret = wasm.airsquadron_fighter_power(this.__wbg_ptr);
208
25
  return ret;
209
26
  }
27
+ /**
28
+ * @param {string} key
29
+ * @returns {Gear | undefined}
30
+ */
31
+ get_gear(key) {
32
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
33
+ const len0 = WASM_VECTOR_LEN;
34
+ const ret = wasm.airsquadron_get_gear(this.__wbg_ptr, ptr0, len0);
35
+ return ret === 0 ? undefined : Gear.__wrap(ret);
36
+ }
210
37
  /**
211
38
  * @param {number} index
212
39
  * @returns {number}
213
40
  */
214
- get_slot_size(index) {
215
- const ret = wasm.airsquadron_get_slot_size(this.__wbg_ptr, index);
41
+ get_max_slot_size(index) {
42
+ const ret = wasm.airsquadron_get_max_slot_size(this.__wbg_ptr, index);
216
43
  if (ret[2]) {
217
44
  throw takeFromExternrefTable0(ret[1]);
218
45
  }
@@ -222,8 +49,8 @@ class AirSquadron {
222
49
  * @param {number} index
223
50
  * @returns {number}
224
51
  */
225
- get_max_slot_size(index) {
226
- const ret = wasm.airsquadron_get_max_slot_size(this.__wbg_ptr, index);
52
+ get_slot_size(index) {
53
+ const ret = wasm.airsquadron_get_slot_size(this.__wbg_ptr, index);
227
54
  if (ret[2]) {
228
55
  throw takeFromExternrefTable0(ret[1]);
229
56
  }
@@ -245,14 +72,11 @@ class AirSquadron {
245
72
  return ret;
246
73
  }
247
74
  /**
248
- * @param {string} key
249
- * @returns {Gear | undefined}
75
+ * @returns {bigint}
250
76
  */
251
- get_gear(key) {
252
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
253
- const len0 = WASM_VECTOR_LEN;
254
- const ret = wasm.airsquadron_get_gear(this.__wbg_ptr, ptr0, len0);
255
- return ret === 0 ? undefined : Gear.__wrap(ret);
77
+ get hash() {
78
+ const ret = wasm.__wbg_get_airsquadron_hash(this.__wbg_ptr);
79
+ return BigInt.asUintN(64, ret);
256
80
  }
257
81
  /**
258
82
  * @returns {string}
@@ -270,19 +94,11 @@ class AirSquadron {
270
94
  }
271
95
  }
272
96
  /**
273
- * @param {string} arg0
274
- */
275
- set id(arg0) {
276
- const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
277
- const len0 = WASM_VECTOR_LEN;
278
- wasm.__wbg_set_airsquadron_id(this.__wbg_ptr, ptr0, len0);
279
- }
280
- /**
281
- * @returns {bigint}
97
+ * @returns {AirSquadronMode}
282
98
  */
283
- get hash() {
284
- const ret = wasm.__wbg_get_airsquadron_hash(this.__wbg_ptr);
285
- return BigInt.asUintN(64, ret);
99
+ get mode() {
100
+ const ret = wasm.__wbg_get_airsquadron_mode(this.__wbg_ptr);
101
+ return ret;
286
102
  }
287
103
  /**
288
104
  * @param {bigint} arg0
@@ -291,11 +107,12 @@ class AirSquadron {
291
107
  wasm.__wbg_set_airsquadron_hash(this.__wbg_ptr, arg0);
292
108
  }
293
109
  /**
294
- * @returns {AirSquadronMode}
110
+ * @param {string} arg0
295
111
  */
296
- get mode() {
297
- const ret = wasm.__wbg_get_airsquadron_mode(this.__wbg_ptr);
298
- return ret;
112
+ set id(arg0) {
113
+ const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
114
+ const len0 = WASM_VECTOR_LEN;
115
+ wasm.__wbg_set_airsquadron_id(this.__wbg_ptr, ptr0, len0);
299
116
  }
300
117
  /**
301
118
  * @param {AirSquadronMode} arg0
@@ -305,30 +122,21 @@ class AirSquadron {
305
122
  }
306
123
  }
307
124
  if (Symbol.dispose) AirSquadron.prototype[Symbol.dispose] = AirSquadron.prototype.free;
308
-
309
125
  exports.AirSquadron = AirSquadron;
310
126
 
311
- const AnalyzerFinalization = (typeof FinalizationRegistry === 'undefined')
312
- ? { register: () => {}, unregister: () => {} }
313
- : new FinalizationRegistry(ptr => wasm.__wbg_analyzer_free(ptr >>> 0, 1));
314
-
315
127
  class Analyzer {
316
-
317
128
  static __wrap(ptr) {
318
- ptr = ptr >>> 0;
319
129
  const obj = Object.create(Analyzer.prototype);
320
130
  obj.__wbg_ptr = ptr;
321
131
  AnalyzerFinalization.register(obj, obj.__wbg_ptr, obj);
322
132
  return obj;
323
133
  }
324
-
325
134
  __destroy_into_raw() {
326
135
  const ptr = this.__wbg_ptr;
327
136
  this.__wbg_ptr = 0;
328
137
  AnalyzerFinalization.unregister(this);
329
138
  return ptr;
330
139
  }
331
-
332
140
  free() {
333
141
  const ptr = this.__destroy_into_raw();
334
142
  wasm.__wbg_analyzer_free(ptr, 0);
@@ -349,14 +157,15 @@ class Analyzer {
349
157
  * @param {Ship} left_ship
350
158
  * @param {Comp} right_comp
351
159
  * @param {Ship} right_ship
160
+ * @param {DensityDetail | null} [density_detail]
352
161
  * @returns {NodeAttackAnalysis}
353
162
  */
354
- analyze_node_attack(config, left_comp, left_ship, right_comp, right_ship) {
163
+ analyze_node_attack(config, left_comp, left_ship, right_comp, right_ship, density_detail) {
355
164
  _assertClass(left_comp, Comp);
356
165
  _assertClass(left_ship, Ship);
357
166
  _assertClass(right_comp, Comp);
358
167
  _assertClass(right_ship, Ship);
359
- const ret = wasm.analyzer_analyze_node_attack(this.__wbg_ptr, config, left_comp.__wbg_ptr, left_ship.__wbg_ptr, right_comp.__wbg_ptr, right_ship.__wbg_ptr);
168
+ const ret = wasm.analyzer_analyze_node_attack(this.__wbg_ptr, config, left_comp.__wbg_ptr, left_ship.__wbg_ptr, right_comp.__wbg_ptr, right_ship.__wbg_ptr, isLikeNone(density_detail) ? 0 : addToExternrefTable0(density_detail));
360
169
  return ret;
361
170
  }
362
171
  /**
@@ -390,146 +199,56 @@ class Analyzer {
390
199
  }
391
200
  }
392
201
  if (Symbol.dispose) Analyzer.prototype[Symbol.dispose] = Analyzer.prototype.free;
393
-
394
202
  exports.Analyzer = Analyzer;
395
203
 
396
- const CompFinalization = (typeof FinalizationRegistry === 'undefined')
397
- ? { register: () => {}, unregister: () => {} }
398
- : new FinalizationRegistry(ptr => wasm.__wbg_comp_free(ptr >>> 0, 1));
399
-
400
204
  class Comp {
401
-
402
205
  static __wrap(ptr) {
403
- ptr = ptr >>> 0;
404
206
  const obj = Object.create(Comp.prototype);
405
207
  obj.__wbg_ptr = ptr;
406
208
  CompFinalization.register(obj, obj.__wbg_ptr, obj);
407
209
  return obj;
408
210
  }
409
-
410
211
  __destroy_into_raw() {
411
212
  const ptr = this.__wbg_ptr;
412
213
  this.__wbg_ptr = 0;
413
214
  CompFinalization.unregister(this);
414
215
  return ptr;
415
216
  }
416
-
417
217
  free() {
418
218
  const ptr = this.__destroy_into_raw();
419
219
  wasm.__wbg_comp_free(ptr, 0);
420
220
  }
421
221
  /**
422
- * @returns {OrgType}
222
+ * 艦隊防空値
223
+ * @param {number} formation_mod
224
+ * @returns {number}
423
225
  */
424
- get org_type() {
425
- const ret = wasm.__wbg_get_comp_org_type(this.__wbg_ptr);
226
+ adjusted_anti_air(formation_mod) {
227
+ const ret = wasm.comp_adjusted_anti_air(this.__wbg_ptr, formation_mod);
426
228
  return ret;
427
229
  }
428
230
  /**
429
231
  * @returns {number}
430
232
  */
431
- get hq_level() {
432
- const ret = wasm.__wbg_get_comp_hq_level(this.__wbg_ptr);
433
- return ret;
233
+ balloons() {
234
+ const ret = wasm.comp_balloons(this.__wbg_ptr);
235
+ return ret >>> 0;
434
236
  }
435
237
  /**
436
- * @returns {Fleet}
238
+ * @returns {Formation}
437
239
  */
438
- get main() {
439
- const ret = wasm.__wbg_get_comp_main(this.__wbg_ptr);
440
- return Fleet.__wrap(ret);
441
- }
442
- /**
443
- * @param {Fleet} arg0
444
- */
445
- set main(arg0) {
446
- _assertClass(arg0, Fleet);
447
- var ptr0 = arg0.__destroy_into_raw();
448
- wasm.__wbg_set_comp_main(this.__wbg_ptr, ptr0);
449
- }
450
- /**
451
- * @returns {Fleet | undefined}
452
- */
453
- get escort() {
454
- const ret = wasm.__wbg_get_comp_escort(this.__wbg_ptr);
455
- return ret === 0 ? undefined : Fleet.__wrap(ret);
456
- }
457
- /**
458
- * @param {Fleet | null} [arg0]
459
- */
460
- set escort(arg0) {
461
- let ptr0 = 0;
462
- if (!isLikeNone(arg0)) {
463
- _assertClass(arg0, Fleet);
464
- ptr0 = arg0.__destroy_into_raw();
465
- }
466
- wasm.__wbg_set_comp_escort(this.__wbg_ptr, ptr0);
467
- }
468
- /**
469
- * @returns {Fleet | undefined}
470
- */
471
- get route_sup() {
472
- const ret = wasm.__wbg_get_comp_route_sup(this.__wbg_ptr);
473
- return ret === 0 ? undefined : Fleet.__wrap(ret);
474
- }
475
- /**
476
- * @param {Fleet | null} [arg0]
477
- */
478
- set route_sup(arg0) {
479
- let ptr0 = 0;
480
- if (!isLikeNone(arg0)) {
481
- _assertClass(arg0, Fleet);
482
- ptr0 = arg0.__destroy_into_raw();
483
- }
484
- wasm.__wbg_set_comp_route_sup(this.__wbg_ptr, ptr0);
485
- }
486
- /**
487
- * @returns {Fleet | undefined}
488
- */
489
- get boss_sup() {
490
- const ret = wasm.__wbg_get_comp_boss_sup(this.__wbg_ptr);
491
- return ret === 0 ? undefined : Fleet.__wrap(ret);
492
- }
493
- /**
494
- * @param {Fleet | null} [arg0]
495
- */
496
- set boss_sup(arg0) {
497
- let ptr0 = 0;
498
- if (!isLikeNone(arg0)) {
499
- _assertClass(arg0, Fleet);
500
- ptr0 = arg0.__destroy_into_raw();
501
- }
502
- wasm.__wbg_set_comp_boss_sup(this.__wbg_ptr, ptr0);
503
- }
504
- /**
505
- * @returns {boolean}
506
- */
507
- is_combined() {
508
- const ret = wasm.comp_is_combined(this.__wbg_ptr);
509
- return ret !== 0;
510
- }
511
- /**
512
- * @param {FleetType} ft
513
- * @returns {string | undefined}
514
- */
515
- get_fleet_id(ft) {
516
- const ret = wasm.comp_get_fleet_id(this.__wbg_ptr, ft);
517
- let v1;
518
- if (ret[0] !== 0) {
519
- v1 = getStringFromWasm0(ret[0], ret[1]).slice();
520
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
521
- }
522
- return v1;
240
+ default_formation() {
241
+ const ret = wasm.comp_default_formation(this.__wbg_ptr);
242
+ return ret;
523
243
  }
524
244
  /**
525
- * @param {string} id
526
- * @returns {boolean}
245
+ * マップ索敵
246
+ * @param {number} node_divaricated_factor
247
+ * @returns {number | undefined}
527
248
  */
528
- has_ship_eid(id) {
529
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
530
- const len0 = WASM_VECTOR_LEN;
531
- const ret = wasm.comp_has_ship_eid(this.__wbg_ptr, ptr0, len0);
532
- return ret !== 0;
249
+ elos(node_divaricated_factor) {
250
+ const ret = wasm.comp_elos(this.__wbg_ptr, node_divaricated_factor);
251
+ return ret[0] === 0 ? undefined : ret[1];
533
252
  }
534
253
  /**
535
254
  * 制空値
@@ -539,7 +258,7 @@ class Comp {
539
258
  */
540
259
  fighter_power(escort_participates, air_type) {
541
260
  const ret = wasm.comp_fighter_power(this.__wbg_ptr, escort_participates, air_type);
542
- return ret === 0x100000001 ? undefined : ret;
261
+ return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
543
262
  }
544
263
  /**
545
264
  * @returns {string | undefined}
@@ -562,34 +281,36 @@ class Comp {
562
281
  return ret[0] === 0 ? undefined : ret[1];
563
282
  }
564
283
  /**
565
- * @returns {boolean}
566
- */
567
- has_route_sup() {
568
- const ret = wasm.comp_has_route_sup(this.__wbg_ptr);
569
- return ret !== 0;
570
- }
571
- /**
572
- * 輸送物資量(TP)
573
- * @returns {number}
284
+ * @param {FleetType} ft
285
+ * @returns {string | undefined}
574
286
  */
575
- transport_point() {
576
- const ret = wasm.comp_transport_point(this.__wbg_ptr);
577
- return ret;
287
+ get_fleet_id(ft) {
288
+ const ret = wasm.comp_get_fleet_id(this.__wbg_ptr, ft);
289
+ let v1;
290
+ if (ret[0] !== 0) {
291
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
292
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
293
+ }
294
+ return v1;
578
295
  }
579
296
  /**
580
- * 艦隊防空値
581
- * @param {number} formation_mod
582
- * @returns {number}
297
+ * @param {string} id
298
+ * @returns {Ship | undefined}
583
299
  */
584
- adjusted_anti_air(formation_mod) {
585
- const ret = wasm.comp_adjusted_anti_air(this.__wbg_ptr, formation_mod);
586
- return ret;
300
+ get_ship_by_eid_with_clone(id) {
301
+ const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
302
+ const len0 = WASM_VECTOR_LEN;
303
+ const ret = wasm.comp_get_ship_by_eid_with_clone(this.__wbg_ptr, ptr0, len0);
304
+ return ret === 0 ? undefined : Ship.__wrap(ret);
587
305
  }
588
306
  /**
589
- * @returns {Formation}
307
+ * @param {Ship} ship
308
+ * @param {Formation | null} [formation]
309
+ * @returns {ShipConditions}
590
310
  */
591
- default_formation() {
592
- const ret = wasm.comp_default_formation(this.__wbg_ptr);
311
+ get_ship_conditions(ship, formation) {
312
+ _assertClass(ship, Ship);
313
+ const ret = wasm.comp_get_ship_conditions(this.__wbg_ptr, ship.__wbg_ptr, isLikeNone(formation) ? 0 : addToExternrefTable0(formation));
593
314
  return ret;
594
315
  }
595
316
  /**
@@ -606,16 +327,6 @@ class Comp {
606
327
  }
607
328
  return v1;
608
329
  }
609
- /**
610
- * @param {Ship} ship
611
- * @param {Formation | null} [formation]
612
- * @returns {ShipConditions}
613
- */
614
- get_ship_conditions(ship, formation) {
615
- _assertClass(ship, Ship);
616
- const ret = wasm.comp_get_ship_conditions(this.__wbg_ptr, ship.__wbg_ptr, isLikeNone(formation) ? 0 : addToExternrefTable0(formation));
617
- return ret;
618
- }
619
330
  /**
620
331
  * @param {FleetType} ft
621
332
  * @param {ShipKey} key
@@ -625,24 +336,43 @@ class Comp {
625
336
  const ret = wasm.comp_get_ship_with_clone(this.__wbg_ptr, ft, key);
626
337
  return ret === 0 ? undefined : Ship.__wrap(ret);
627
338
  }
339
+ /**
340
+ * @returns {boolean}
341
+ */
342
+ has_route_sup() {
343
+ const ret = wasm.comp_has_route_sup(this.__wbg_ptr);
344
+ return ret !== 0;
345
+ }
628
346
  /**
629
347
  * @param {string} id
630
- * @returns {Ship | undefined}
348
+ * @returns {boolean}
631
349
  */
632
- get_ship_by_eid_with_clone(id) {
350
+ has_ship_eid(id) {
633
351
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
634
352
  const len0 = WASM_VECTOR_LEN;
635
- const ret = wasm.comp_get_ship_by_eid_with_clone(this.__wbg_ptr, ptr0, len0);
636
- return ret === 0 ? undefined : Ship.__wrap(ret);
353
+ const ret = wasm.comp_has_ship_eid(this.__wbg_ptr, ptr0, len0);
354
+ return ret !== 0;
637
355
  }
638
356
  /**
639
- * マップ索敵
640
- * @param {number} node_divaricated_factor
641
- * @returns {number | undefined}
357
+ * @returns {boolean}
642
358
  */
643
- elos(node_divaricated_factor) {
644
- const ret = wasm.comp_elos(this.__wbg_ptr, node_divaricated_factor);
645
- return ret[0] === 0 ? undefined : ret[1];
359
+ is_combined() {
360
+ const ret = wasm.comp_is_combined(this.__wbg_ptr);
361
+ return ret !== 0;
362
+ }
363
+ /**
364
+ * @returns {boolean}
365
+ */
366
+ is_enemy() {
367
+ const ret = wasm.comp_is_enemy(this.__wbg_ptr);
368
+ return ret !== 0;
369
+ }
370
+ /**
371
+ * @returns {boolean}
372
+ */
373
+ is_player() {
374
+ const ret = wasm.comp_is_player(this.__wbg_ptr);
375
+ return ret !== 0;
646
376
  }
647
377
  /**
648
378
  * @returns {CompMeta}
@@ -659,101 +389,110 @@ class Comp {
659
389
  return ret;
660
390
  }
661
391
  /**
392
+ * 輸送物資量(TP)
662
393
  * @returns {number}
663
394
  */
664
- balloons() {
665
- const ret = wasm.comp_balloons(this.__wbg_ptr);
666
- return ret >>> 0;
395
+ transport_point() {
396
+ const ret = wasm.comp_transport_point(this.__wbg_ptr);
397
+ return ret;
667
398
  }
668
399
  /**
669
- * @returns {boolean}
400
+ * @returns {Fleet | undefined}
670
401
  */
671
- is_enemy() {
672
- const ret = wasm.comp_is_enemy(this.__wbg_ptr);
673
- return ret !== 0;
402
+ get boss_sup() {
403
+ const ret = wasm.__wbg_get_comp_boss_sup(this.__wbg_ptr);
404
+ return ret === 0 ? undefined : Fleet.__wrap(ret);
674
405
  }
675
406
  /**
676
- * @returns {boolean}
407
+ * @returns {Fleet | undefined}
677
408
  */
678
- is_player() {
679
- const ret = wasm.comp_is_player(this.__wbg_ptr);
680
- return ret !== 0;
681
- }
682
- }
683
- if (Symbol.dispose) Comp.prototype[Symbol.dispose] = Comp.prototype.free;
684
-
685
- exports.Comp = Comp;
686
-
687
- const FhCoreFinalization = (typeof FinalizationRegistry === 'undefined')
688
- ? { register: () => {}, unregister: () => {} }
689
- : new FinalizationRegistry(ptr => wasm.__wbg_fhcore_free(ptr >>> 0, 1));
690
-
691
- class FhCore {
692
-
693
- __destroy_into_raw() {
694
- const ptr = this.__wbg_ptr;
695
- this.__wbg_ptr = 0;
696
- FhCoreFinalization.unregister(this);
697
- return ptr;
698
- }
699
-
700
- free() {
701
- const ptr = this.__destroy_into_raw();
702
- wasm.__wbg_fhcore_free(ptr, 0);
409
+ get escort() {
410
+ const ret = wasm.__wbg_get_comp_escort(this.__wbg_ptr);
411
+ return ret === 0 ? undefined : Fleet.__wrap(ret);
703
412
  }
704
413
  /**
705
- * @param {OrgState | null} [input]
706
- * @returns {Org | undefined}
414
+ * @returns {number}
707
415
  */
708
- create_org(input) {
709
- const ret = wasm.fhcore_create_org(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
710
- return ret === 0 ? undefined : Org.__wrap(ret);
416
+ get hq_level() {
417
+ const ret = wasm.__wbg_get_comp_hq_level(this.__wbg_ptr);
418
+ return ret;
711
419
  }
712
420
  /**
713
- * @param {GearState | null} [input]
714
- * @returns {Gear | undefined}
421
+ * @returns {Fleet}
715
422
  */
716
- create_gear(input) {
717
- const ret = wasm.fhcore_create_gear(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
718
- return ret === 0 ? undefined : Gear.__wrap(ret);
423
+ get main() {
424
+ const ret = wasm.__wbg_get_comp_main(this.__wbg_ptr);
425
+ return Fleet.__wrap(ret);
719
426
  }
720
427
  /**
721
- * @param {ShipState | null} [input]
722
- * @returns {Ship | undefined}
428
+ * @returns {OrgType}
723
429
  */
724
- create_ship(input) {
725
- const ret = wasm.fhcore_create_ship(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
726
- return ret === 0 ? undefined : Ship.__wrap(ret);
430
+ get org_type() {
431
+ const ret = wasm.__wbg_get_comp_org_type(this.__wbg_ptr);
432
+ return ret;
727
433
  }
728
434
  /**
729
- * @param {FleetState | null} [input]
730
- * @returns {Fleet}
435
+ * @returns {Fleet | undefined}
731
436
  */
732
- create_fleet(input) {
733
- const ret = wasm.fhcore_create_fleet(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
734
- return Fleet.__wrap(ret);
437
+ get route_sup() {
438
+ const ret = wasm.__wbg_get_comp_route_sup(this.__wbg_ptr);
439
+ return ret === 0 ? undefined : Fleet.__wrap(ret);
735
440
  }
736
441
  /**
737
- * @returns {Analyzer}
442
+ * @param {Fleet | null} [arg0]
738
443
  */
739
- create_analyzer() {
740
- const ret = wasm.fhcore_create_analyzer(this.__wbg_ptr);
741
- return Analyzer.__wrap(ret);
444
+ set boss_sup(arg0) {
445
+ let ptr0 = 0;
446
+ if (!isLikeNone(arg0)) {
447
+ _assertClass(arg0, Fleet);
448
+ ptr0 = arg0.__destroy_into_raw();
449
+ }
450
+ wasm.__wbg_set_comp_boss_sup(this.__wbg_ptr, ptr0);
742
451
  }
743
452
  /**
744
- * @returns {Ship[]}
453
+ * @param {Fleet | null} [arg0]
745
454
  */
746
- create_all_ships() {
747
- const ret = wasm.fhcore_create_all_ships(this.__wbg_ptr);
748
- return ret;
455
+ set escort(arg0) {
456
+ let ptr0 = 0;
457
+ if (!isLikeNone(arg0)) {
458
+ _assertClass(arg0, Fleet);
459
+ ptr0 = arg0.__destroy_into_raw();
460
+ }
461
+ wasm.__wbg_set_comp_escort(this.__wbg_ptr, ptr0);
749
462
  }
750
463
  /**
751
- * @param {number} ship_id
752
- * @returns {Ship | undefined}
464
+ * @param {Fleet} arg0
753
465
  */
754
- create_ship_by_id(ship_id) {
755
- const ret = wasm.fhcore_create_ship_by_id(this.__wbg_ptr, ship_id);
756
- return ret === 0 ? undefined : Ship.__wrap(ret);
466
+ set main(arg0) {
467
+ _assertClass(arg0, Fleet);
468
+ var ptr0 = arg0.__destroy_into_raw();
469
+ wasm.__wbg_set_comp_main(this.__wbg_ptr, ptr0);
470
+ }
471
+ /**
472
+ * @param {Fleet | null} [arg0]
473
+ */
474
+ set route_sup(arg0) {
475
+ let ptr0 = 0;
476
+ if (!isLikeNone(arg0)) {
477
+ _assertClass(arg0, Fleet);
478
+ ptr0 = arg0.__destroy_into_raw();
479
+ }
480
+ wasm.__wbg_set_comp_route_sup(this.__wbg_ptr, ptr0);
481
+ }
482
+ }
483
+ if (Symbol.dispose) Comp.prototype[Symbol.dispose] = Comp.prototype.free;
484
+ exports.Comp = Comp;
485
+
486
+ class FhCore {
487
+ __destroy_into_raw() {
488
+ const ptr = this.__wbg_ptr;
489
+ this.__wbg_ptr = 0;
490
+ FhCoreFinalization.unregister(this);
491
+ return ptr;
492
+ }
493
+ free() {
494
+ const ptr = this.__destroy_into_raw();
495
+ wasm.__wbg_fhcore_free(ptr, 0);
757
496
  }
758
497
  /**
759
498
  * @param {AirSquadronState | null} [input]
@@ -764,19 +503,18 @@ class FhCore {
764
503
  return AirSquadron.__wrap(ret);
765
504
  }
766
505
  /**
767
- * @returns {Ship}
506
+ * @returns {Ship[]}
768
507
  */
769
- create_default_ship() {
770
- const ret = wasm.fhcore_create_default_ship(this.__wbg_ptr);
771
- return Ship.__wrap(ret);
508
+ create_all_ships() {
509
+ const ret = wasm.fhcore_create_all_ships(this.__wbg_ptr);
510
+ return ret;
772
511
  }
773
512
  /**
774
- * @param {number} ship_id
775
- * @returns {ShipState | undefined}
513
+ * @returns {Analyzer}
776
514
  */
777
- create_ship_state_by_id(ship_id) {
778
- const ret = wasm.fhcore_create_ship_state_by_id(this.__wbg_ptr, ship_id);
779
- return ret;
515
+ create_analyzer() {
516
+ const ret = wasm.fhcore_create_analyzer(this.__wbg_ptr);
517
+ return Analyzer.__wrap(ret);
780
518
  }
781
519
  /**
782
520
  * @param {Uint16Array} main
@@ -791,6 +529,61 @@ class FhCore {
791
529
  const ret = wasm.fhcore_create_comp_by_map_enemy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
792
530
  return Comp.__wrap(ret);
793
531
  }
532
+ /**
533
+ * @returns {Ship}
534
+ */
535
+ create_default_ship() {
536
+ const ret = wasm.fhcore_create_default_ship(this.__wbg_ptr);
537
+ return Ship.__wrap(ret);
538
+ }
539
+ /**
540
+ * @param {FleetState | null} [input]
541
+ * @returns {Fleet}
542
+ */
543
+ create_fleet(input) {
544
+ const ret = wasm.fhcore_create_fleet(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
545
+ return Fleet.__wrap(ret);
546
+ }
547
+ /**
548
+ * @param {GearState | null} [input]
549
+ * @returns {Gear | undefined}
550
+ */
551
+ create_gear(input) {
552
+ const ret = wasm.fhcore_create_gear(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
553
+ return ret === 0 ? undefined : Gear.__wrap(ret);
554
+ }
555
+ /**
556
+ * @param {OrgState | null} [input]
557
+ * @returns {Org | undefined}
558
+ */
559
+ create_org(input) {
560
+ const ret = wasm.fhcore_create_org(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
561
+ return ret === 0 ? undefined : Org.__wrap(ret);
562
+ }
563
+ /**
564
+ * @param {ShipState | null} [input]
565
+ * @returns {Ship | undefined}
566
+ */
567
+ create_ship(input) {
568
+ const ret = wasm.fhcore_create_ship(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
569
+ return ret === 0 ? undefined : Ship.__wrap(ret);
570
+ }
571
+ /**
572
+ * @param {number} ship_id
573
+ * @returns {Ship | undefined}
574
+ */
575
+ create_ship_by_id(ship_id) {
576
+ const ret = wasm.fhcore_create_ship_by_id(this.__wbg_ptr, ship_id);
577
+ return ret === 0 ? undefined : Ship.__wrap(ret);
578
+ }
579
+ /**
580
+ * @param {number} ship_id
581
+ * @returns {ShipState | undefined}
582
+ */
583
+ create_ship_state_by_id(ship_id) {
584
+ const ret = wasm.fhcore_create_ship_state_by_id(this.__wbg_ptr, ship_id);
585
+ return ret;
586
+ }
794
587
  /**
795
588
  * @param {MasterData} js_master
796
589
  */
@@ -799,83 +592,63 @@ class FhCore {
799
592
  if (ret[2]) {
800
593
  throw takeFromExternrefTable0(ret[1]);
801
594
  }
802
- this.__wbg_ptr = ret[0] >>> 0;
595
+ this.__wbg_ptr = ret[0];
803
596
  FhCoreFinalization.register(this, this.__wbg_ptr, this);
804
597
  return this;
805
598
  }
806
599
  }
807
600
  if (Symbol.dispose) FhCore.prototype[Symbol.dispose] = FhCore.prototype.free;
808
-
809
601
  exports.FhCore = FhCore;
810
602
 
811
- const FleetFinalization = (typeof FinalizationRegistry === 'undefined')
812
- ? { register: () => {}, unregister: () => {} }
813
- : new FinalizationRegistry(ptr => wasm.__wbg_fleet_free(ptr >>> 0, 1));
814
-
815
603
  class Fleet {
816
-
817
604
  static __wrap(ptr) {
818
- ptr = ptr >>> 0;
819
605
  const obj = Object.create(Fleet.prototype);
820
606
  obj.__wbg_ptr = ptr;
821
607
  FleetFinalization.register(obj, obj.__wbg_ptr, obj);
822
608
  return obj;
823
609
  }
824
-
825
610
  __destroy_into_raw() {
826
611
  const ptr = this.__wbg_ptr;
827
612
  this.__wbg_ptr = 0;
828
613
  FleetFinalization.unregister(this);
829
614
  return ptr;
830
615
  }
831
-
832
616
  free() {
833
617
  const ptr = this.__destroy_into_raw();
834
618
  wasm.__wbg_fleet_free(ptr, 0);
835
619
  }
836
620
  /**
837
- * @returns {string}
838
- */
839
- get id() {
840
- let deferred1_0;
841
- let deferred1_1;
842
- try {
843
- const ret = wasm.__wbg_get_fleet_id(this.__wbg_ptr);
844
- deferred1_0 = ret[0];
845
- deferred1_1 = ret[1];
846
- return getStringFromWasm0(ret[0], ret[1]);
847
- } finally {
848
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
849
- }
850
- }
851
- /**
852
- * @param {string} arg0
621
+ * 航空索敵スコア
622
+ * @returns {number | undefined}
853
623
  */
854
- set id(arg0) {
855
- const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
856
- const len0 = WASM_VECTOR_LEN;
857
- wasm.__wbg_set_fleet_id(this.__wbg_ptr, ptr0, len0);
624
+ aviation_detection_score() {
625
+ const ret = wasm.fleet_aviation_detection_score(this.__wbg_ptr);
626
+ return ret[0] === 0 ? undefined : ret[1];
858
627
  }
859
628
  /**
860
- * @returns {bigint}
629
+ * @returns {number}
861
630
  */
862
- get hash() {
863
- const ret = wasm.__wbg_get_fleet_hash(this.__wbg_ptr);
864
- return BigInt.asUintN(64, ret);
631
+ count_ships() {
632
+ const ret = wasm.fleet_count_ships(this.__wbg_ptr);
633
+ return ret >>> 0;
865
634
  }
866
635
  /**
867
- * @returns {number}
636
+ * マップ索敵
637
+ * @param {number} hq_level
638
+ * @param {number} node_divaricated_factor
639
+ * @returns {number | undefined}
868
640
  */
869
- get len() {
870
- const ret = wasm.__wbg_get_fleet_len(this.__wbg_ptr);
871
- return ret >>> 0;
641
+ elos(hq_level, node_divaricated_factor) {
642
+ const ret = wasm.fleet_elos(this.__wbg_ptr, hq_level, node_divaricated_factor);
643
+ return ret[0] === 0 ? undefined : ret[1];
872
644
  }
873
645
  /**
646
+ * 遠征ボーナス
874
647
  * @returns {number}
875
648
  */
876
- count_ships() {
877
- const ret = wasm.fleet_count_ships(this.__wbg_ptr);
878
- return ret >>> 0;
649
+ expedition_bonus() {
650
+ const ret = wasm.fleet_expedition_bonus(this.__wbg_ptr);
651
+ return ret;
879
652
  }
880
653
  /**
881
654
  * @param {AirWaveType} air_type
@@ -883,7 +656,7 @@ class Fleet {
883
656
  */
884
657
  fighter_power(air_type) {
885
658
  const ret = wasm.fleet_fighter_power(this.__wbg_ptr, air_type);
886
- return ret === 0x100000001 ? undefined : ret;
659
+ return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
887
660
  }
888
661
  /**
889
662
  * @returns {number | undefined}
@@ -892,14 +665,6 @@ class Fleet {
892
665
  const ret = wasm.fleet_fleet_los_mod(this.__wbg_ptr);
893
666
  return ret[0] === 0 ? undefined : ret[1];
894
667
  }
895
- /**
896
- * 遠征ボーナス
897
- * @returns {number}
898
- */
899
- expedition_bonus() {
900
- const ret = wasm.fleet_expedition_bonus(this.__wbg_ptr);
901
- return ret;
902
- }
903
668
  /**
904
669
  * @param {string} id
905
670
  * @param {DamageState} state
@@ -912,14 +677,22 @@ class Fleet {
912
677
  return ret === 0xFFFFFF ? undefined : ret;
913
678
  }
914
679
  /**
915
- * @param {string} key
916
- * @returns {number | undefined}
680
+ * @returns {string[]}
917
681
  */
918
- sum_ship_stat_by(key) {
919
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
920
- const len0 = WASM_VECTOR_LEN;
921
- const ret = wasm.fleet_sum_ship_stat_by(this.__wbg_ptr, ptr0, len0);
922
- return ret[0] === 0 ? undefined : ret[1];
682
+ get_gear_ids_by_improvable() {
683
+ const ret = wasm.fleet_get_gear_ids_by_improvable(this.__wbg_ptr);
684
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
685
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
686
+ return v1;
687
+ }
688
+ /**
689
+ * @returns {string[]}
690
+ */
691
+ get_gear_ids_by_proficiency() {
692
+ const ret = wasm.fleet_get_gear_ids_by_proficiency(this.__wbg_ptr);
693
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
694
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
695
+ return v1;
923
696
  }
924
697
  /**
925
698
  * @param {string} id
@@ -945,59 +718,23 @@ class Fleet {
945
718
  const ret = wasm.fleet_get_remaining_fuel(this.__wbg_ptr, ptr0, len0, rate, ceil);
946
719
  return ret === 0xFFFFFF ? undefined : ret;
947
720
  }
948
- reset_battle_state() {
949
- wasm.fleet_reset_battle_state(this.__wbg_ptr);
950
- }
951
721
  /**
952
- * 航空索敵スコア
953
- * @returns {number | undefined}
722
+ * @param {ShipKey} key
723
+ * @returns {Ship | undefined}
954
724
  */
955
- aviation_detection_score() {
956
- const ret = wasm.fleet_aviation_detection_score(this.__wbg_ptr);
957
- return ret[0] === 0 ? undefined : ret[1];
725
+ get_ship(key) {
726
+ const ret = wasm.fleet_get_ship(this.__wbg_ptr, key);
727
+ return ret === 0 ? undefined : Ship.__wrap(ret);
958
728
  }
959
729
  /**
960
- * @returns {string[]}
961
- */
962
- get_gear_ids_by_improvable() {
963
- const ret = wasm.fleet_get_gear_ids_by_improvable(this.__wbg_ptr);
964
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
965
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
966
- return v1;
967
- }
968
- /**
969
- * @returns {string[]}
970
- */
971
- get_gear_ids_by_proficiency() {
972
- const ret = wasm.fleet_get_gear_ids_by_proficiency(this.__wbg_ptr);
973
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
974
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
975
- return v1;
976
- }
977
- /**
978
- * マップ索敵
979
- * @param {number} hq_level
980
- * @param {number} node_divaricated_factor
981
- * @returns {number | undefined}
982
- */
983
- elos(hq_level, node_divaricated_factor) {
984
- const ret = wasm.fleet_elos(this.__wbg_ptr, hq_level, node_divaricated_factor);
985
- return ret[0] === 0 ? undefined : ret[1];
986
- }
987
- /**
988
- * @returns {FleetMeta}
730
+ * @returns {FleetMeta}
989
731
  */
990
732
  meta() {
991
733
  const ret = wasm.fleet_meta(this.__wbg_ptr);
992
734
  return ret;
993
735
  }
994
- /**
995
- * @param {ShipKey} key
996
- * @returns {Ship | undefined}
997
- */
998
- get_ship(key) {
999
- const ret = wasm.fleet_get_ship(this.__wbg_ptr, key);
1000
- return ret === 0 ? undefined : Ship.__wrap(ret);
736
+ reset_battle_state() {
737
+ wasm.fleet_reset_battle_state(this.__wbg_ptr);
1001
738
  }
1002
739
  /**
1003
740
  * @returns {string[]}
@@ -1017,35 +754,22 @@ class Fleet {
1017
754
  wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1018
755
  return v1;
1019
756
  }
1020
- }
1021
- if (Symbol.dispose) Fleet.prototype[Symbol.dispose] = Fleet.prototype.free;
1022
-
1023
- exports.Fleet = Fleet;
1024
-
1025
- const GearFinalization = (typeof FinalizationRegistry === 'undefined')
1026
- ? { register: () => {}, unregister: () => {} }
1027
- : new FinalizationRegistry(ptr => wasm.__wbg_gear_free(ptr >>> 0, 1));
1028
-
1029
- class Gear {
1030
-
1031
- static __wrap(ptr) {
1032
- ptr = ptr >>> 0;
1033
- const obj = Object.create(Gear.prototype);
1034
- obj.__wbg_ptr = ptr;
1035
- GearFinalization.register(obj, obj.__wbg_ptr, obj);
1036
- return obj;
1037
- }
1038
-
1039
- __destroy_into_raw() {
1040
- const ptr = this.__wbg_ptr;
1041
- this.__wbg_ptr = 0;
1042
- GearFinalization.unregister(this);
1043
- return ptr;
757
+ /**
758
+ * @param {string} key
759
+ * @returns {number | undefined}
760
+ */
761
+ sum_ship_stat_by(key) {
762
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
763
+ const len0 = WASM_VECTOR_LEN;
764
+ const ret = wasm.fleet_sum_ship_stat_by(this.__wbg_ptr, ptr0, len0);
765
+ return ret[0] === 0 ? undefined : ret[1];
1044
766
  }
1045
-
1046
- free() {
1047
- const ptr = this.__destroy_into_raw();
1048
- wasm.__wbg_gear_free(ptr, 0);
767
+ /**
768
+ * @returns {bigint}
769
+ */
770
+ get hash() {
771
+ const ret = wasm.__wbg_get_fleet_hash(this.__wbg_ptr);
772
+ return BigInt.asUintN(64, ret);
1049
773
  }
1050
774
  /**
1051
775
  * @returns {string}
@@ -1054,7 +778,7 @@ class Gear {
1054
778
  let deferred1_0;
1055
779
  let deferred1_1;
1056
780
  try {
1057
- const ret = wasm.__wbg_get_gear_id(this.__wbg_ptr);
781
+ const ret = wasm.__wbg_get_fleet_id(this.__wbg_ptr);
1058
782
  deferred1_0 = ret[0];
1059
783
  deferred1_1 = ret[1];
1060
784
  return getStringFromWasm0(ret[0], ret[1]);
@@ -1062,255 +786,272 @@ class Gear {
1062
786
  wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1063
787
  }
1064
788
  }
789
+ /**
790
+ * @returns {number}
791
+ */
792
+ get len() {
793
+ const ret = wasm.__wbg_get_fleet_len(this.__wbg_ptr);
794
+ return ret >>> 0;
795
+ }
1065
796
  /**
1066
797
  * @param {string} arg0
1067
798
  */
1068
799
  set id(arg0) {
1069
800
  const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1070
801
  const len0 = WASM_VECTOR_LEN;
1071
- wasm.__wbg_set_gear_id(this.__wbg_ptr, ptr0, len0);
802
+ wasm.__wbg_set_fleet_id(this.__wbg_ptr, ptr0, len0);
1072
803
  }
1073
- /**
1074
- * @returns {bigint}
1075
- */
1076
- get hash() {
1077
- const ret = wasm.__wbg_get_gear_hash(this.__wbg_ptr);
1078
- return BigInt.asUintN(64, ret);
804
+ }
805
+ if (Symbol.dispose) Fleet.prototype[Symbol.dispose] = Fleet.prototype.free;
806
+ exports.Fleet = Fleet;
807
+
808
+ class Gear {
809
+ static __wrap(ptr) {
810
+ const obj = Object.create(Gear.prototype);
811
+ obj.__wbg_ptr = ptr;
812
+ GearFinalization.register(obj, obj.__wbg_ptr, obj);
813
+ return obj;
814
+ }
815
+ __destroy_into_raw() {
816
+ const ptr = this.__wbg_ptr;
817
+ this.__wbg_ptr = 0;
818
+ GearFinalization.unregister(this);
819
+ return ptr;
820
+ }
821
+ free() {
822
+ const ptr = this.__destroy_into_raw();
823
+ wasm.__wbg_gear_free(ptr, 0);
1079
824
  }
1080
825
  /**
1081
826
  * @returns {number}
1082
827
  */
1083
- get gear_id() {
1084
- const ret = wasm.__wbg_get_gear_gear_id(this.__wbg_ptr);
828
+ get ace() {
829
+ const ret = wasm.gear_ace(this.__wbg_ptr);
1085
830
  return ret;
1086
831
  }
1087
832
  /**
1088
833
  * @returns {number}
1089
834
  */
1090
- get stars() {
1091
- const ret = wasm.__wbg_get_gear_stars(this.__wbg_ptr);
835
+ get anti_bomber() {
836
+ const ret = wasm.gear_anti_bomber(this.__wbg_ptr);
1092
837
  return ret;
1093
838
  }
1094
839
  /**
840
+ * @param {number} slot_size
1095
841
  * @returns {number}
1096
842
  */
1097
- get exp() {
1098
- const ret = wasm.__wbg_get_gear_exp(this.__wbg_ptr);
843
+ calc_contact_trigger_factor(slot_size) {
844
+ const ret = wasm.gear_calc_contact_trigger_factor(this.__wbg_ptr, slot_size);
1099
845
  return ret;
1100
846
  }
1101
847
  /**
848
+ * @param {number} slot_size
1102
849
  * @returns {number}
1103
850
  */
1104
- get default_exp() {
1105
- const ret = wasm.__wbg_get_gear_default_exp(this.__wbg_ptr);
851
+ calc_fighter_power(slot_size) {
852
+ const ret = wasm.gear_calc_fighter_power(this.__wbg_ptr, slot_size);
1106
853
  return ret;
1107
854
  }
1108
855
  /**
1109
- * @returns {string}
1110
- */
1111
- get name() {
1112
- let deferred1_0;
1113
- let deferred1_1;
1114
- try {
1115
- const ret = wasm.__wbg_get_gear_name(this.__wbg_ptr);
1116
- deferred1_0 = ret[0];
1117
- deferred1_1 = ret[1];
1118
- return getStringFromWasm0(ret[0], ret[1]);
1119
- } finally {
1120
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1121
- }
1122
- }
1123
- /**
1124
- * @param {string} arg0
1125
- */
1126
- set name(arg0) {
1127
- const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1128
- const len0 = WASM_VECTOR_LEN;
1129
- wasm.__wbg_set_gear_name(this.__wbg_ptr, ptr0, len0);
1130
- }
1131
- /**
1132
- * @returns {Uint8Array}
856
+ * @param {number} slot_size
857
+ * @returns {number}
1133
858
  */
1134
- get types() {
1135
- const ret = wasm.__wbg_get_gear_types(this.__wbg_ptr);
1136
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
1137
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1138
- return v1;
859
+ calc_interception_power(slot_size) {
860
+ const ret = wasm.gear_calc_interception_power(this.__wbg_ptr, slot_size);
861
+ return ret;
1139
862
  }
1140
863
  /**
1141
- * @param {Uint8Array} arg0
864
+ * @returns {boolean}
1142
865
  */
1143
- set types(arg0) {
1144
- const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
1145
- const len0 = WASM_VECTOR_LEN;
1146
- wasm.__wbg_set_gear_types(this.__wbg_ptr, ptr0, len0);
866
+ can_be_deployed_to_land_base() {
867
+ const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
868
+ return ret !== 0;
1147
869
  }
1148
870
  /**
1149
- * @returns {GearType}
871
+ * @returns {GearCategory}
1150
872
  */
1151
- get gear_type() {
1152
- const ret = wasm.__wbg_get_gear_gear_type(this.__wbg_ptr);
873
+ category() {
874
+ const ret = wasm.gear_category(this.__wbg_ptr);
1153
875
  return ret;
1154
876
  }
1155
877
  /**
878
+ * @param {AirStateRank} rank
1156
879
  * @returns {number}
1157
880
  */
1158
- get max_hp() {
1159
- const ret = wasm.__wbg_get_gear_max_hp(this.__wbg_ptr);
881
+ contact_selection_rate(rank) {
882
+ const ret = wasm.gear_contact_selection_rate(this.__wbg_ptr, rank);
1160
883
  return ret;
1161
884
  }
1162
885
  /**
1163
- * @returns {number}
886
+ * @returns {Gear}
1164
887
  */
1165
- get firepower() {
1166
- const ret = wasm.__wbg_get_gear_firepower(this.__wbg_ptr);
1167
- return ret;
888
+ static default() {
889
+ const ret = wasm.gear_default();
890
+ return Gear.__wrap(ret);
1168
891
  }
1169
892
  /**
1170
893
  * @returns {number}
1171
894
  */
1172
- get armor() {
1173
- const ret = wasm.__wbg_get_gear_armor(this.__wbg_ptr);
895
+ elos() {
896
+ const ret = wasm.gear_elos(this.__wbg_ptr);
1174
897
  return ret;
1175
898
  }
1176
899
  /**
1177
900
  * @returns {number}
1178
901
  */
1179
- get torpedo() {
1180
- const ret = wasm.__wbg_get_gear_torpedo(this.__wbg_ptr);
902
+ expedition_bonus() {
903
+ const ret = wasm.gear_expedition_bonus(this.__wbg_ptr);
1181
904
  return ret;
1182
905
  }
1183
906
  /**
1184
907
  * @returns {number}
1185
908
  */
1186
- get anti_air() {
1187
- const ret = wasm.__wbg_get_gear_anti_air(this.__wbg_ptr);
909
+ fleet_anti_air_mod() {
910
+ const ret = wasm.gear_fleet_anti_air_mod(this.__wbg_ptr);
1188
911
  return ret;
1189
912
  }
1190
913
  /**
1191
914
  * @returns {number}
1192
915
  */
1193
- get speed() {
1194
- const ret = wasm.__wbg_get_gear_speed(this.__wbg_ptr);
916
+ get gear_type_id() {
917
+ const ret = wasm.gear_gear_type_id(this.__wbg_ptr);
1195
918
  return ret;
1196
919
  }
1197
920
  /**
1198
- * @returns {number}
921
+ * @param {GearAttr} attr
922
+ * @returns {boolean}
1199
923
  */
1200
- get bombing() {
1201
- const ret = wasm.__wbg_get_gear_bombing(this.__wbg_ptr);
1202
- return ret;
924
+ has_attr(attr) {
925
+ const ret = wasm.gear_has_attr(this.__wbg_ptr, attr);
926
+ return ret !== 0;
1203
927
  }
1204
928
  /**
1205
- * @returns {number}
929
+ * @returns {boolean}
1206
930
  */
1207
- get asw() {
1208
- const ret = wasm.__wbg_get_gear_asw(this.__wbg_ptr);
1209
- return ret;
931
+ has_proficiency() {
932
+ const ret = wasm.gear_has_proficiency(this.__wbg_ptr);
933
+ return ret !== 0;
1210
934
  }
1211
935
  /**
1212
936
  * @returns {number}
1213
937
  */
1214
- get los() {
1215
- const ret = wasm.__wbg_get_gear_los(this.__wbg_ptr);
938
+ get icon_id() {
939
+ const ret = wasm.gear_icon_id(this.__wbg_ptr);
1216
940
  return ret;
1217
941
  }
1218
942
  /**
1219
943
  * @returns {number}
1220
944
  */
1221
- get luck() {
1222
- const ret = wasm.__wbg_get_gear_luck(this.__wbg_ptr);
945
+ get interception() {
946
+ const ret = wasm.gear_interception(this.__wbg_ptr);
1223
947
  return ret;
1224
948
  }
1225
949
  /**
1226
- * @returns {number}
950
+ * @returns {boolean}
1227
951
  */
1228
- get accuracy() {
1229
- const ret = wasm.__wbg_get_gear_accuracy(this.__wbg_ptr);
1230
- return ret;
952
+ is_abyssal() {
953
+ const ret = wasm.gear_is_abyssal(this.__wbg_ptr);
954
+ return ret !== 0;
1231
955
  }
1232
956
  /**
1233
- * @returns {number}
957
+ * @returns {boolean}
1234
958
  */
1235
- get evasion() {
1236
- const ret = wasm.__wbg_get_gear_evasion(this.__wbg_ptr);
1237
- return ret;
959
+ is_abyssal_cuttlefish_torpedo() {
960
+ const ret = wasm.gear_is_abyssal_cuttlefish_torpedo(this.__wbg_ptr);
961
+ return ret !== 0;
1238
962
  }
1239
963
  /**
1240
- * @returns {number}
964
+ * @returns {boolean}
1241
965
  */
1242
- get range() {
1243
- const ret = wasm.__wbg_get_gear_range(this.__wbg_ptr);
1244
- return ret;
966
+ is_abyssal_patrolling_attack_hawk() {
967
+ const ret = wasm.gear_is_abyssal_patrolling_attack_hawk(this.__wbg_ptr);
968
+ return ret !== 0;
1245
969
  }
1246
970
  /**
1247
- * @returns {number}
971
+ * @returns {boolean}
1248
972
  */
1249
- get radius() {
1250
- const ret = wasm.__wbg_get_gear_radius(this.__wbg_ptr);
1251
- return ret;
973
+ is_balloon() {
974
+ const ret = wasm.gear_is_balloon(this.__wbg_ptr);
975
+ return ret !== 0;
1252
976
  }
1253
977
  /**
1254
- * @returns {number}
978
+ * @returns {boolean}
1255
979
  */
1256
- get cost() {
1257
- const ret = wasm.__wbg_get_gear_cost(this.__wbg_ptr);
1258
- return ret;
980
+ is_carrier_shelling_plane() {
981
+ const ret = wasm.gear_is_carrier_shelling_plane(this.__wbg_ptr);
982
+ return ret !== 0;
1259
983
  }
1260
984
  /**
1261
985
  * @returns {boolean}
1262
986
  */
1263
- get improvable() {
1264
- const ret = wasm.__wbg_get_gear_improvable(this.__wbg_ptr);
987
+ is_hayabusa_20th_squadron() {
988
+ const ret = wasm.gear_is_hayabusa_20th_squadron(this.__wbg_ptr);
1265
989
  return ret !== 0;
1266
990
  }
1267
991
  /**
1268
- * @returns {number}
992
+ * @returns {boolean}
1269
993
  */
1270
- get ship_anti_air_resist() {
1271
- const ret = wasm.__wbg_get_gear_ship_anti_air_resist(this.__wbg_ptr);
1272
- return ret;
994
+ is_high_angle_mount() {
995
+ const ret = wasm.gear_is_high_angle_mount(this.__wbg_ptr);
996
+ return ret !== 0;
1273
997
  }
1274
998
  /**
1275
- * @returns {number}
999
+ * @returns {boolean}
1276
1000
  */
1277
- get fleet_anti_air_resist() {
1278
- const ret = wasm.__wbg_get_gear_fleet_anti_air_resist(this.__wbg_ptr);
1279
- return ret;
1001
+ is_night_attacker() {
1002
+ const ret = wasm.gear_is_night_attacker(this.__wbg_ptr);
1003
+ return ret !== 0;
1280
1004
  }
1281
1005
  /**
1282
1006
  * @returns {boolean}
1283
1007
  */
1284
- is_abyssal() {
1285
- const ret = wasm.gear_is_abyssal(this.__wbg_ptr);
1008
+ is_night_bomber() {
1009
+ const ret = wasm.gear_is_night_bomber(this.__wbg_ptr);
1286
1010
  return ret !== 0;
1287
1011
  }
1288
1012
  /**
1289
1013
  * @returns {boolean}
1290
1014
  */
1291
- is_balloon() {
1292
- const ret = wasm.gear_is_balloon(this.__wbg_ptr);
1015
+ is_night_fighter() {
1016
+ const ret = wasm.gear_is_night_fighter(this.__wbg_ptr);
1017
+ return ret !== 0;
1018
+ }
1019
+ /**
1020
+ * @returns {boolean}
1021
+ */
1022
+ is_night_plane() {
1023
+ const ret = wasm.gear_is_night_plane(this.__wbg_ptr);
1024
+ return ret !== 0;
1025
+ }
1026
+ /**
1027
+ * @returns {boolean}
1028
+ */
1029
+ max_exp_eq_120() {
1030
+ const ret = wasm.gear_max_exp_eq_120(this.__wbg_ptr);
1293
1031
  return ret !== 0;
1294
1032
  }
1295
1033
  /**
1034
+ * @param {number} level
1296
1035
  * @returns {number}
1297
1036
  */
1298
- get anti_bomber() {
1299
- const ret = wasm.gear_anti_bomber(this.__wbg_ptr);
1037
+ night_contact_rate(level) {
1038
+ const ret = wasm.gear_night_contact_rate(this.__wbg_ptr, level);
1300
1039
  return ret;
1301
1040
  }
1302
1041
  /**
1042
+ * @param {number} slot_size
1043
+ * @param {boolean} anti_inst
1303
1044
  * @returns {number}
1304
1045
  */
1305
- get gear_type_id() {
1306
- const ret = wasm.gear_gear_type_id(this.__wbg_ptr);
1046
+ night_plane_power(slot_size, anti_inst) {
1047
+ const ret = wasm.gear_night_plane_power(this.__wbg_ptr, slot_size, anti_inst);
1307
1048
  return ret;
1308
1049
  }
1309
1050
  /**
1310
1051
  * @returns {number}
1311
1052
  */
1312
- get interception() {
1313
- const ret = wasm.gear_interception(this.__wbg_ptr);
1053
+ ship_anti_air_mod() {
1054
+ const ret = wasm.gear_ship_anti_air_mod(this.__wbg_ptr);
1314
1055
  return ret;
1315
1056
  }
1316
1057
  /**
@@ -1321,260 +1062,269 @@ class Gear {
1321
1062
  return ret;
1322
1063
  }
1323
1064
  /**
1324
- * @returns {boolean}
1325
- */
1326
- is_night_plane() {
1327
- const ret = wasm.gear_is_night_plane(this.__wbg_ptr);
1328
- return ret !== 0;
1329
- }
1330
- /**
1331
- * @returns {boolean}
1065
+ * @returns {number}
1332
1066
  */
1333
- max_exp_eq_120() {
1334
- const ret = wasm.gear_max_exp_eq_120(this.__wbg_ptr);
1335
- return ret !== 0;
1067
+ get accuracy() {
1068
+ const ret = wasm.__wbg_get_gear_accuracy(this.__wbg_ptr);
1069
+ return ret;
1336
1070
  }
1337
1071
  /**
1338
- * @returns {boolean}
1072
+ * @returns {number}
1339
1073
  */
1340
- has_proficiency() {
1341
- const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
1342
- return ret !== 0;
1074
+ get anti_air() {
1075
+ const ret = wasm.__wbg_get_gear_anti_air(this.__wbg_ptr);
1076
+ return ret;
1343
1077
  }
1344
1078
  /**
1345
- * @returns {boolean}
1079
+ * @returns {number}
1346
1080
  */
1347
- is_night_bomber() {
1348
- const ret = wasm.gear_is_night_bomber(this.__wbg_ptr);
1349
- return ret !== 0;
1081
+ get armor() {
1082
+ const ret = wasm.__wbg_get_gear_armor(this.__wbg_ptr);
1083
+ return ret;
1350
1084
  }
1351
1085
  /**
1352
1086
  * @returns {number}
1353
1087
  */
1354
- expedition_bonus() {
1355
- const ret = wasm.gear_expedition_bonus(this.__wbg_ptr);
1088
+ get asw() {
1089
+ const ret = wasm.__wbg_get_gear_asw(this.__wbg_ptr);
1356
1090
  return ret;
1357
1091
  }
1358
1092
  /**
1359
- * @returns {boolean}
1093
+ * @returns {number}
1360
1094
  */
1361
- is_night_fighter() {
1362
- const ret = wasm.gear_is_night_fighter(this.__wbg_ptr);
1363
- return ret !== 0;
1095
+ get bombing() {
1096
+ const ret = wasm.__wbg_get_gear_bombing(this.__wbg_ptr);
1097
+ return ret;
1364
1098
  }
1365
1099
  /**
1366
- * @returns {boolean}
1100
+ * @returns {number}
1367
1101
  */
1368
- is_night_attacker() {
1369
- const ret = wasm.gear_is_night_attacker(this.__wbg_ptr);
1370
- return ret !== 0;
1102
+ get cost() {
1103
+ const ret = wasm.__wbg_get_gear_cost(this.__wbg_ptr);
1104
+ return ret;
1371
1105
  }
1372
1106
  /**
1373
- * @param {number} slot_size
1374
- * @param {boolean} anti_inst
1375
1107
  * @returns {number}
1376
1108
  */
1377
- night_plane_power(slot_size, anti_inst) {
1378
- const ret = wasm.gear_night_plane_power(this.__wbg_ptr, slot_size, anti_inst);
1109
+ get default_exp() {
1110
+ const ret = wasm.__wbg_get_gear_default_exp(this.__wbg_ptr);
1379
1111
  return ret;
1380
1112
  }
1381
1113
  /**
1382
1114
  * @returns {number}
1383
1115
  */
1384
- ship_anti_air_mod() {
1385
- const ret = wasm.gear_ship_anti_air_mod(this.__wbg_ptr);
1116
+ get evasion() {
1117
+ const ret = wasm.__wbg_get_gear_evasion(this.__wbg_ptr);
1386
1118
  return ret;
1387
1119
  }
1388
1120
  /**
1389
- * @param {number} slot_size
1390
1121
  * @returns {number}
1391
1122
  */
1392
- calc_fighter_power(slot_size) {
1393
- const ret = wasm.gear_calc_fighter_power(this.__wbg_ptr, slot_size);
1123
+ get exp() {
1124
+ const ret = wasm.__wbg_get_gear_exp(this.__wbg_ptr);
1394
1125
  return ret;
1395
1126
  }
1396
1127
  /**
1397
1128
  * @returns {number}
1398
1129
  */
1399
- fleet_anti_air_mod() {
1400
- const ret = wasm.gear_fleet_anti_air_mod(this.__wbg_ptr);
1130
+ get firepower() {
1131
+ const ret = wasm.__wbg_get_gear_firepower(this.__wbg_ptr);
1401
1132
  return ret;
1402
1133
  }
1403
1134
  /**
1404
- * @param {number} level
1405
1135
  * @returns {number}
1406
1136
  */
1407
- night_contact_rate(level) {
1408
- const ret = wasm.gear_night_contact_rate(this.__wbg_ptr, level);
1137
+ get fleet_anti_air_resist() {
1138
+ const ret = wasm.__wbg_get_gear_fleet_anti_air_resist(this.__wbg_ptr);
1409
1139
  return ret;
1410
1140
  }
1411
1141
  /**
1412
- * @returns {boolean}
1142
+ * @returns {number}
1413
1143
  */
1414
- is_high_angle_mount() {
1415
- const ret = wasm.gear_is_high_angle_mount(this.__wbg_ptr);
1416
- return ret !== 0;
1144
+ get gear_id() {
1145
+ const ret = wasm.__wbg_get_gear_gear_id(this.__wbg_ptr);
1146
+ return ret;
1417
1147
  }
1418
1148
  /**
1419
- * @param {AirStateRank} rank
1420
- * @returns {number}
1149
+ * @returns {GearType}
1421
1150
  */
1422
- contact_selection_rate(rank) {
1423
- const ret = wasm.gear_contact_selection_rate(this.__wbg_ptr, rank);
1151
+ get gear_type() {
1152
+ const ret = wasm.__wbg_get_gear_gear_type(this.__wbg_ptr);
1424
1153
  return ret;
1425
1154
  }
1426
1155
  /**
1427
- * @param {number} slot_size
1428
- * @returns {number}
1156
+ * @returns {bigint}
1429
1157
  */
1430
- calc_interception_power(slot_size) {
1431
- const ret = wasm.gear_calc_interception_power(this.__wbg_ptr, slot_size);
1432
- return ret;
1158
+ get hash() {
1159
+ const ret = wasm.__wbg_get_gear_hash(this.__wbg_ptr);
1160
+ return BigInt.asUintN(64, ret);
1433
1161
  }
1434
1162
  /**
1435
- * @returns {boolean}
1163
+ * @returns {string}
1436
1164
  */
1437
- is_carrier_shelling_plane() {
1438
- const ret = wasm.gear_is_carrier_shelling_plane(this.__wbg_ptr);
1439
- return ret !== 0;
1165
+ get id() {
1166
+ let deferred1_0;
1167
+ let deferred1_1;
1168
+ try {
1169
+ const ret = wasm.__wbg_get_gear_id(this.__wbg_ptr);
1170
+ deferred1_0 = ret[0];
1171
+ deferred1_1 = ret[1];
1172
+ return getStringFromWasm0(ret[0], ret[1]);
1173
+ } finally {
1174
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1175
+ }
1440
1176
  }
1441
1177
  /**
1442
1178
  * @returns {boolean}
1443
1179
  */
1444
- is_hayabusa_20th_squadron() {
1445
- const ret = wasm.gear_is_hayabusa_20th_squadron(this.__wbg_ptr);
1180
+ get improvable() {
1181
+ const ret = wasm.__wbg_get_gear_improvable(this.__wbg_ptr);
1446
1182
  return ret !== 0;
1447
1183
  }
1448
1184
  /**
1449
- * @param {number} slot_size
1450
1185
  * @returns {number}
1451
1186
  */
1452
- calc_contact_trigger_factor(slot_size) {
1453
- const ret = wasm.gear_calc_contact_trigger_factor(this.__wbg_ptr, slot_size);
1187
+ get los() {
1188
+ const ret = wasm.__wbg_get_gear_los(this.__wbg_ptr);
1454
1189
  return ret;
1455
1190
  }
1456
1191
  /**
1457
- * @returns {boolean}
1192
+ * @returns {number}
1458
1193
  */
1459
- can_be_deployed_to_land_base() {
1460
- const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
1461
- return ret !== 0;
1194
+ get luck() {
1195
+ const ret = wasm.__wbg_get_gear_luck(this.__wbg_ptr);
1196
+ return ret;
1462
1197
  }
1463
1198
  /**
1464
- * @returns {boolean}
1199
+ * @returns {number}
1465
1200
  */
1466
- is_abyssal_cuttlefish_torpedo() {
1467
- const ret = wasm.gear_is_abyssal_cuttlefish_torpedo(this.__wbg_ptr);
1468
- return ret !== 0;
1201
+ get max_hp() {
1202
+ const ret = wasm.__wbg_get_gear_max_hp(this.__wbg_ptr);
1203
+ return ret;
1469
1204
  }
1470
1205
  /**
1471
- * @returns {boolean}
1206
+ * @returns {string}
1472
1207
  */
1473
- is_abyssal_patrolling_attack_hawk() {
1474
- const ret = wasm.gear_is_abyssal_patrolling_attack_hawk(this.__wbg_ptr);
1475
- return ret !== 0;
1208
+ get name() {
1209
+ let deferred1_0;
1210
+ let deferred1_1;
1211
+ try {
1212
+ const ret = wasm.__wbg_get_gear_name(this.__wbg_ptr);
1213
+ deferred1_0 = ret[0];
1214
+ deferred1_1 = ret[1];
1215
+ return getStringFromWasm0(ret[0], ret[1]);
1216
+ } finally {
1217
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1218
+ }
1476
1219
  }
1477
1220
  /**
1478
1221
  * @returns {number}
1479
1222
  */
1480
- get ace() {
1481
- const ret = wasm.gear_ace(this.__wbg_ptr);
1223
+ get radius() {
1224
+ const ret = wasm.__wbg_get_gear_radius(this.__wbg_ptr);
1482
1225
  return ret;
1483
1226
  }
1484
1227
  /**
1485
1228
  * @returns {number}
1486
1229
  */
1487
- elos() {
1488
- const ret = wasm.gear_elos(this.__wbg_ptr);
1230
+ get range() {
1231
+ const ret = wasm.__wbg_get_gear_range(this.__wbg_ptr);
1489
1232
  return ret;
1490
1233
  }
1491
1234
  /**
1492
- * @returns {Gear}
1235
+ * @returns {number}
1493
1236
  */
1494
- static default() {
1495
- const ret = wasm.gear_default();
1496
- return Gear.__wrap(ret);
1237
+ get ship_anti_air_resist() {
1238
+ const ret = wasm.__wbg_get_gear_ship_anti_air_resist(this.__wbg_ptr);
1239
+ return ret;
1497
1240
  }
1498
1241
  /**
1499
1242
  * @returns {number}
1500
1243
  */
1501
- get icon_id() {
1502
- const ret = wasm.gear_icon_id(this.__wbg_ptr);
1244
+ get speed() {
1245
+ const ret = wasm.__wbg_get_gear_speed(this.__wbg_ptr);
1503
1246
  return ret;
1504
1247
  }
1505
1248
  /**
1506
- * @returns {GearCategory}
1249
+ * @returns {number}
1507
1250
  */
1508
- category() {
1509
- const ret = wasm.gear_category(this.__wbg_ptr);
1251
+ get stars() {
1252
+ const ret = wasm.__wbg_get_gear_stars(this.__wbg_ptr);
1510
1253
  return ret;
1511
1254
  }
1512
1255
  /**
1513
- * @param {GearAttr} attr
1514
- * @returns {boolean}
1256
+ * @returns {number}
1515
1257
  */
1516
- has_attr(attr) {
1517
- const ret = wasm.gear_has_attr(this.__wbg_ptr, attr);
1518
- return ret !== 0;
1258
+ get torpedo() {
1259
+ const ret = wasm.__wbg_get_gear_torpedo(this.__wbg_ptr);
1260
+ return ret;
1261
+ }
1262
+ /**
1263
+ * @returns {Uint8Array}
1264
+ */
1265
+ get types() {
1266
+ const ret = wasm.__wbg_get_gear_types(this.__wbg_ptr);
1267
+ var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
1268
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1269
+ return v1;
1270
+ }
1271
+ /**
1272
+ * @param {string} arg0
1273
+ */
1274
+ set id(arg0) {
1275
+ const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1276
+ const len0 = WASM_VECTOR_LEN;
1277
+ wasm.__wbg_set_gear_id(this.__wbg_ptr, ptr0, len0);
1278
+ }
1279
+ /**
1280
+ * @param {string} arg0
1281
+ */
1282
+ set name(arg0) {
1283
+ const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1284
+ const len0 = WASM_VECTOR_LEN;
1285
+ wasm.__wbg_set_gear_name(this.__wbg_ptr, ptr0, len0);
1286
+ }
1287
+ /**
1288
+ * @param {Uint8Array} arg0
1289
+ */
1290
+ set types(arg0) {
1291
+ const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
1292
+ const len0 = WASM_VECTOR_LEN;
1293
+ wasm.__wbg_set_gear_types(this.__wbg_ptr, ptr0, len0);
1519
1294
  }
1520
1295
  }
1521
1296
  if (Symbol.dispose) Gear.prototype[Symbol.dispose] = Gear.prototype.free;
1522
-
1523
1297
  exports.Gear = Gear;
1524
1298
 
1525
- const OrgFinalization = (typeof FinalizationRegistry === 'undefined')
1526
- ? { register: () => {}, unregister: () => {} }
1527
- : new FinalizationRegistry(ptr => wasm.__wbg_org_free(ptr >>> 0, 1));
1528
-
1529
1299
  class Org {
1530
-
1531
1300
  static __wrap(ptr) {
1532
- ptr = ptr >>> 0;
1533
1301
  const obj = Object.create(Org.prototype);
1534
1302
  obj.__wbg_ptr = ptr;
1535
1303
  OrgFinalization.register(obj, obj.__wbg_ptr, obj);
1536
1304
  return obj;
1537
1305
  }
1538
-
1539
1306
  __destroy_into_raw() {
1540
1307
  const ptr = this.__wbg_ptr;
1541
1308
  this.__wbg_ptr = 0;
1542
1309
  OrgFinalization.unregister(this);
1543
1310
  return ptr;
1544
1311
  }
1545
-
1546
1312
  free() {
1547
1313
  const ptr = this.__destroy_into_raw();
1548
1314
  wasm.__wbg_org_free(ptr, 0);
1549
1315
  }
1550
1316
  /**
1551
- * @returns {string}
1552
- */
1553
- get id() {
1554
- let deferred1_0;
1555
- let deferred1_1;
1556
- try {
1557
- const ret = wasm.__wbg_get_org_id(this.__wbg_ptr);
1558
- deferred1_0 = ret[0];
1559
- deferred1_1 = ret[1];
1560
- return getStringFromWasm0(ret[0], ret[1]);
1561
- } finally {
1562
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1563
- }
1564
- }
1565
- /**
1566
- * @param {string} arg0
1317
+ * @returns {FleetKey | undefined}
1567
1318
  */
1568
- set id(arg0) {
1569
- const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1570
- const len0 = WASM_VECTOR_LEN;
1571
- wasm.__wbg_set_org_id(this.__wbg_ptr, ptr0, len0);
1319
+ get boss_sup() {
1320
+ const ret = wasm.__wbg_get_org_boss_sup(this.__wbg_ptr);
1321
+ return ret;
1572
1322
  }
1573
1323
  /**
1574
1324
  * @returns {bigint}
1575
1325
  */
1576
1326
  get hash() {
1577
- const ret = wasm.__wbg_get_gear_hash(this.__wbg_ptr);
1327
+ const ret = wasm.__wbg_get_org_hash(this.__wbg_ptr);
1578
1328
  return BigInt.asUintN(64, ret);
1579
1329
  }
1580
1330
  /**
@@ -1585,17 +1335,25 @@ class Org {
1585
1335
  return ret;
1586
1336
  }
1587
1337
  /**
1588
- * @returns {OrgType}
1338
+ * @returns {string}
1589
1339
  */
1590
- get org_type() {
1591
- const ret = wasm.__wbg_get_org_org_type(this.__wbg_ptr);
1592
- return ret;
1340
+ get id() {
1341
+ let deferred1_0;
1342
+ let deferred1_1;
1343
+ try {
1344
+ const ret = wasm.__wbg_get_org_id(this.__wbg_ptr);
1345
+ deferred1_0 = ret[0];
1346
+ deferred1_1 = ret[1];
1347
+ return getStringFromWasm0(ret[0], ret[1]);
1348
+ } finally {
1349
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1350
+ }
1593
1351
  }
1594
1352
  /**
1595
- * @returns {FleetKey}
1353
+ * @returns {OrgType}
1596
1354
  */
1597
- get sortie() {
1598
- const ret = wasm.__wbg_get_org_sortie(this.__wbg_ptr);
1355
+ get org_type() {
1356
+ const ret = wasm.__wbg_get_org_org_type(this.__wbg_ptr);
1599
1357
  return ret;
1600
1358
  }
1601
1359
  /**
@@ -1606,20 +1364,20 @@ class Org {
1606
1364
  return ret;
1607
1365
  }
1608
1366
  /**
1609
- * @returns {FleetKey | undefined}
1367
+ * @returns {FleetKey}
1610
1368
  */
1611
- get boss_sup() {
1612
- const ret = wasm.__wbg_get_org_boss_sup(this.__wbg_ptr);
1369
+ get sortie() {
1370
+ const ret = wasm.__wbg_get_org_sortie(this.__wbg_ptr);
1613
1371
  return ret;
1614
1372
  }
1615
1373
  /**
1616
- * @param {FleetKey} fleet_key
1617
- * @param {ShipKey} ship_key
1618
- * @returns {Ship | undefined}
1374
+ * @returns {string[]}
1619
1375
  */
1620
- clone_ship(fleet_key, ship_key) {
1621
- const ret = wasm.org_clone_ship(this.__wbg_ptr, fleet_key, ship_key);
1622
- return ret === 0 ? undefined : Ship.__wrap(ret);
1376
+ air_squadron_ids() {
1377
+ const ret = wasm.org_air_squadron_ids(this.__wbg_ptr);
1378
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
1379
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1380
+ return v1;
1623
1381
  }
1624
1382
  /**
1625
1383
  * @param {FleetKey} key
@@ -1629,97 +1387,41 @@ class Org {
1629
1387
  const ret = wasm.org_clone_fleet(this.__wbg_ptr, key);
1630
1388
  return Fleet.__wrap(ret);
1631
1389
  }
1632
- /**
1633
- * @returns {Comp}
1634
- */
1635
- create_comp() {
1636
- const ret = wasm.org_create_comp(this.__wbg_ptr);
1637
- return Comp.__wrap(ret);
1638
- }
1639
- /**
1640
- * @returns {boolean}
1641
- */
1642
- is_combined() {
1643
- const ret = wasm.org_is_combined(this.__wbg_ptr);
1644
- return ret !== 0;
1645
- }
1646
- /**
1647
- * @param {FleetKey} key
1648
- * @returns {string}
1649
- */
1650
- get_fleet_id(key) {
1651
- let deferred1_0;
1652
- let deferred1_1;
1653
- try {
1654
- const ret = wasm.org_get_fleet_id(this.__wbg_ptr, key);
1655
- deferred1_0 = ret[0];
1656
- deferred1_1 = ret[1];
1657
- return getStringFromWasm0(ret[0], ret[1]);
1658
- } finally {
1659
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1660
- }
1661
- }
1662
- /**
1663
- * @param {FleetKey} fleet_key
1664
- * @param {ShipKey} ship_key
1665
- * @returns {string | undefined}
1666
- */
1667
- get_ship_eid(fleet_key, ship_key) {
1668
- const ret = wasm.org_get_ship_eid(this.__wbg_ptr, fleet_key, ship_key);
1669
- let v1;
1670
- if (ret[0] !== 0) {
1671
- v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1672
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1673
- }
1674
- return v1;
1675
- }
1676
1390
  /**
1677
1391
  * @param {FleetKey} fleet_key
1678
1392
  * @param {ShipKey} ship_key
1679
- * @returns {number | undefined}
1680
- */
1681
- get_ship_mid(fleet_key, ship_key) {
1682
- const ret = wasm.org_get_ship_mid(this.__wbg_ptr, fleet_key, ship_key);
1683
- return ret === 0xFFFFFF ? undefined : ret;
1684
- }
1685
- /**
1686
- * @returns {string | undefined}
1393
+ * @returns {Ship | undefined}
1687
1394
  */
1688
- first_ship_id() {
1689
- const ret = wasm.org_first_ship_id(this.__wbg_ptr);
1690
- let v1;
1691
- if (ret[0] !== 0) {
1692
- v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1693
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1694
- }
1695
- return v1;
1395
+ clone_ship(fleet_key, ship_key) {
1396
+ const ret = wasm.org_clone_ship(this.__wbg_ptr, fleet_key, ship_key);
1397
+ return ret === 0 ? undefined : Ship.__wrap(ret);
1696
1398
  }
1697
1399
  /**
1698
- * @returns {Uint16Array}
1400
+ * @returns {Comp}
1699
1401
  */
1700
- main_ship_ids() {
1701
- const ret = wasm.org_main_ship_ids(this.__wbg_ptr);
1702
- var v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
1703
- wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
1704
- return v1;
1402
+ create_comp() {
1403
+ const ret = wasm.org_create_comp(this.__wbg_ptr);
1404
+ return Comp.__wrap(ret);
1705
1405
  }
1706
1406
  /**
1707
1407
  * @param {FleetKey} key
1708
- * @returns {FleetType | undefined}
1408
+ * @returns {Comp}
1709
1409
  */
1710
- get_fleet_type(key) {
1711
- const ret = wasm.org_get_fleet_type(this.__wbg_ptr, key);
1712
- return ret;
1410
+ create_comp_by_key(key) {
1411
+ const ret = wasm.org_create_comp_by_key(this.__wbg_ptr, key);
1412
+ return Comp.__wrap(ret);
1713
1413
  }
1714
1414
  /**
1715
1415
  * @param {string} id
1716
- * @returns {Ship | undefined}
1416
+ * @param {number} x
1417
+ * @param {number} y
1418
+ * @returns {MoveShipPayload | undefined}
1717
1419
  */
1718
- get_ship_by_id(id) {
1420
+ create_move_ship_payload(id, x, y) {
1719
1421
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1720
1422
  const len0 = WASM_VECTOR_LEN;
1721
- const ret = wasm.org_get_ship_by_id(this.__wbg_ptr, ptr0, len0);
1722
- return ret === 0 ? undefined : Ship.__wrap(ret);
1423
+ const ret = wasm.org_create_move_ship_payload(this.__wbg_ptr, ptr0, len0, x, y);
1424
+ return ret;
1723
1425
  }
1724
1426
  /**
1725
1427
  * @returns {Uint16Array}
@@ -1731,12 +1433,15 @@ class Org {
1731
1433
  return v1;
1732
1434
  }
1733
1435
  /**
1734
- * @returns {string[]}
1436
+ * @returns {string | undefined}
1735
1437
  */
1736
- air_squadron_ids() {
1737
- const ret = wasm.org_air_squadron_ids(this.__wbg_ptr);
1738
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
1739
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1438
+ first_ship_id() {
1439
+ const ret = wasm.org_first_ship_id(this.__wbg_ptr);
1440
+ let v1;
1441
+ if (ret[0] !== 0) {
1442
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1443
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1444
+ }
1740
1445
  return v1;
1741
1446
  }
1742
1447
  /**
@@ -1752,42 +1457,6 @@ class Org {
1752
1457
  }
1753
1458
  return AirSquadron.__wrap(ret[0]);
1754
1459
  }
1755
- /**
1756
- * @param {FleetKey} key
1757
- * @returns {Comp}
1758
- */
1759
- create_comp_by_key(key) {
1760
- const ret = wasm.org_create_comp_by_key(this.__wbg_ptr, key);
1761
- return Comp.__wrap(ret);
1762
- }
1763
- /**
1764
- * 防空時の基地制空値
1765
- * @returns {number}
1766
- */
1767
- interception_power() {
1768
- const ret = wasm.org_interception_power(this.__wbg_ptr);
1769
- return ret;
1770
- }
1771
- /**
1772
- * @param {string} id
1773
- * @param {number} x
1774
- * @param {number} y
1775
- * @returns {MoveShipPayload | undefined}
1776
- */
1777
- create_move_ship_payload(id, x, y) {
1778
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1779
- const len0 = WASM_VECTOR_LEN;
1780
- const ret = wasm.org_create_move_ship_payload(this.__wbg_ptr, ptr0, len0, x, y);
1781
- return ret;
1782
- }
1783
- /**
1784
- * 高高度迎撃時の基地制空値
1785
- * @returns {number}
1786
- */
1787
- high_altitude_interception_power() {
1788
- const ret = wasm.org_high_altitude_interception_power(this.__wbg_ptr);
1789
- return ret;
1790
- }
1791
1460
  /**
1792
1461
  * @returns {string[]}
1793
1462
  */
@@ -1807,12 +1476,85 @@ class Org {
1807
1476
  return v1;
1808
1477
  }
1809
1478
  /**
1810
- * @returns {Side}
1479
+ * @param {FleetKey} key
1480
+ * @returns {string}
1811
1481
  */
1812
- side() {
1813
- const ret = wasm.org_side(this.__wbg_ptr);
1482
+ get_fleet_id(key) {
1483
+ let deferred1_0;
1484
+ let deferred1_1;
1485
+ try {
1486
+ const ret = wasm.org_get_fleet_id(this.__wbg_ptr, key);
1487
+ deferred1_0 = ret[0];
1488
+ deferred1_1 = ret[1];
1489
+ return getStringFromWasm0(ret[0], ret[1]);
1490
+ } finally {
1491
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1492
+ }
1493
+ }
1494
+ /**
1495
+ * @param {FleetKey} key
1496
+ * @returns {FleetType | undefined}
1497
+ */
1498
+ get_fleet_type(key) {
1499
+ const ret = wasm.org_get_fleet_type(this.__wbg_ptr, key);
1500
+ return ret;
1501
+ }
1502
+ /**
1503
+ * @param {string} id
1504
+ * @returns {Ship | undefined}
1505
+ */
1506
+ get_ship_by_id(id) {
1507
+ const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1508
+ const len0 = WASM_VECTOR_LEN;
1509
+ const ret = wasm.org_get_ship_by_id(this.__wbg_ptr, ptr0, len0);
1510
+ return ret === 0 ? undefined : Ship.__wrap(ret);
1511
+ }
1512
+ /**
1513
+ * @param {FleetKey} fleet_key
1514
+ * @param {ShipKey} ship_key
1515
+ * @returns {string | undefined}
1516
+ */
1517
+ get_ship_eid(fleet_key, ship_key) {
1518
+ const ret = wasm.org_get_ship_eid(this.__wbg_ptr, fleet_key, ship_key);
1519
+ let v1;
1520
+ if (ret[0] !== 0) {
1521
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1522
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1523
+ }
1524
+ return v1;
1525
+ }
1526
+ /**
1527
+ * @param {FleetKey} fleet_key
1528
+ * @param {ShipKey} ship_key
1529
+ * @returns {number | undefined}
1530
+ */
1531
+ get_ship_mid(fleet_key, ship_key) {
1532
+ const ret = wasm.org_get_ship_mid(this.__wbg_ptr, fleet_key, ship_key);
1533
+ return ret === 0xFFFFFF ? undefined : ret;
1534
+ }
1535
+ /**
1536
+ * 高高度迎撃時の基地制空値
1537
+ * @returns {number}
1538
+ */
1539
+ high_altitude_interception_power() {
1540
+ const ret = wasm.org_high_altitude_interception_power(this.__wbg_ptr);
1541
+ return ret;
1542
+ }
1543
+ /**
1544
+ * 防空時の基地制空値
1545
+ * @returns {number}
1546
+ */
1547
+ interception_power() {
1548
+ const ret = wasm.org_interception_power(this.__wbg_ptr);
1814
1549
  return ret;
1815
1550
  }
1551
+ /**
1552
+ * @returns {boolean}
1553
+ */
1554
+ is_combined() {
1555
+ const ret = wasm.org_is_combined(this.__wbg_ptr);
1556
+ return ret !== 0;
1557
+ }
1816
1558
  /**
1817
1559
  * @returns {boolean}
1818
1560
  */
@@ -1834,6 +1576,15 @@ class Org {
1834
1576
  const ret = wasm.org_is_single(this.__wbg_ptr);
1835
1577
  return ret !== 0;
1836
1578
  }
1579
+ /**
1580
+ * @returns {Uint16Array}
1581
+ */
1582
+ main_ship_ids() {
1583
+ const ret = wasm.org_main_ship_ids(this.__wbg_ptr);
1584
+ var v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
1585
+ wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
1586
+ return v1;
1587
+ }
1837
1588
  /**
1838
1589
  * @param {FleetKey} key
1839
1590
  * @returns {string[]}
@@ -1844,106 +1595,111 @@ class Org {
1844
1595
  wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1845
1596
  return v1;
1846
1597
  }
1598
+ /**
1599
+ * @returns {Side}
1600
+ */
1601
+ side() {
1602
+ const ret = wasm.org_side(this.__wbg_ptr);
1603
+ return ret;
1604
+ }
1605
+ /**
1606
+ * @param {string} arg0
1607
+ */
1608
+ set id(arg0) {
1609
+ const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1610
+ const len0 = WASM_VECTOR_LEN;
1611
+ wasm.__wbg_set_org_id(this.__wbg_ptr, ptr0, len0);
1612
+ }
1847
1613
  }
1848
1614
  if (Symbol.dispose) Org.prototype[Symbol.dispose] = Org.prototype.free;
1849
-
1850
1615
  exports.Org = Org;
1851
1616
 
1852
- const ShipFinalization = (typeof FinalizationRegistry === 'undefined')
1853
- ? { register: () => {}, unregister: () => {} }
1854
- : new FinalizationRegistry(ptr => wasm.__wbg_ship_free(ptr >>> 0, 1));
1855
-
1856
1617
  class Ship {
1857
-
1858
1618
  static __wrap(ptr) {
1859
- ptr = ptr >>> 0;
1860
1619
  const obj = Object.create(Ship.prototype);
1861
1620
  obj.__wbg_ptr = ptr;
1862
1621
  ShipFinalization.register(obj, obj.__wbg_ptr, obj);
1863
1622
  return obj;
1864
1623
  }
1865
-
1866
1624
  __destroy_into_raw() {
1867
1625
  const ptr = this.__wbg_ptr;
1868
1626
  this.__wbg_ptr = 0;
1869
1627
  ShipFinalization.unregister(this);
1870
1628
  return ptr;
1871
1629
  }
1872
-
1873
1630
  free() {
1874
1631
  const ptr = this.__destroy_into_raw();
1875
1632
  wasm.__wbg_ship_free(ptr, 0);
1876
1633
  }
1877
1634
  /**
1878
- * @returns {string}
1635
+ * @returns {number}
1879
1636
  */
1880
- get id() {
1881
- let deferred1_0;
1882
- let deferred1_1;
1883
- try {
1884
- const ret = wasm.__wbg_get_ship_id(this.__wbg_ptr);
1885
- deferred1_0 = ret[0];
1886
- deferred1_1 = ret[1];
1887
- return getStringFromWasm0(ret[0], ret[1]);
1888
- } finally {
1889
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1890
- }
1637
+ get ammo() {
1638
+ const ret = wasm.__wbg_get_ship_ammo(this.__wbg_ptr);
1639
+ return ret;
1891
1640
  }
1892
1641
  /**
1893
- * @param {string} arg0
1642
+ * @returns {number}
1894
1643
  */
1895
- set id(arg0) {
1896
- const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1897
- const len0 = WASM_VECTOR_LEN;
1898
- wasm.__wbg_set_ship_id(this.__wbg_ptr, ptr0, len0);
1644
+ get ctype() {
1645
+ const ret = wasm.__wbg_get_ship_ctype(this.__wbg_ptr);
1646
+ return ret;
1899
1647
  }
1900
1648
  /**
1901
- * @returns {bigint}
1649
+ * @returns {number}
1902
1650
  */
1903
- get hash() {
1904
- const ret = wasm.__wbg_get_ship_hash(this.__wbg_ptr);
1905
- return BigInt.asUintN(64, ret);
1651
+ get current_hp() {
1652
+ const ret = wasm.__wbg_get_ship_current_hp(this.__wbg_ptr);
1653
+ return ret;
1906
1654
  }
1907
1655
  /**
1908
1656
  * @returns {number}
1909
1657
  */
1910
- get ship_id() {
1911
- const ret = wasm.__wbg_get_ship_ship_id(this.__wbg_ptr);
1658
+ get fuel() {
1659
+ const ret = wasm.__wbg_get_ship_fuel(this.__wbg_ptr);
1912
1660
  return ret;
1913
1661
  }
1914
1662
  /**
1915
- * @returns {number}
1663
+ * @returns {bigint}
1916
1664
  */
1917
- get level() {
1918
- const ret = wasm.__wbg_get_ship_level(this.__wbg_ptr);
1919
- return ret;
1665
+ get hash() {
1666
+ const ret = wasm.__wbg_get_ship_hash(this.__wbg_ptr);
1667
+ return BigInt.asUintN(64, ret);
1920
1668
  }
1921
1669
  /**
1922
- * @returns {number}
1670
+ * @returns {string}
1923
1671
  */
1924
- get current_hp() {
1925
- const ret = wasm.__wbg_get_ship_current_hp(this.__wbg_ptr);
1926
- return ret;
1672
+ get id() {
1673
+ let deferred1_0;
1674
+ let deferred1_1;
1675
+ try {
1676
+ const ret = wasm.__wbg_get_ship_id(this.__wbg_ptr);
1677
+ deferred1_0 = ret[0];
1678
+ deferred1_1 = ret[1];
1679
+ return getStringFromWasm0(ret[0], ret[1]);
1680
+ } finally {
1681
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1682
+ }
1927
1683
  }
1928
1684
  /**
1929
1685
  * @returns {number}
1930
1686
  */
1931
- get morale() {
1932
- const ret = wasm.__wbg_get_ship_morale(this.__wbg_ptr);
1687
+ get level() {
1688
+ const ret = wasm.__wbg_get_ship_level(this.__wbg_ptr);
1933
1689
  return ret;
1934
1690
  }
1935
1691
  /**
1936
1692
  * @returns {number}
1937
1693
  */
1938
- get ammo() {
1939
- const ret = wasm.__wbg_get_ship_ammo(this.__wbg_ptr);
1694
+ get morale() {
1695
+ const ret = wasm.__wbg_get_ship_morale(this.__wbg_ptr);
1940
1696
  return ret;
1941
1697
  }
1942
1698
  /**
1943
1699
  * @returns {number}
1944
1700
  */
1945
- get fuel() {
1946
- const ret = wasm.__wbg_get_ship_fuel(this.__wbg_ptr);
1701
+ get ship_id() {
1702
+ const ret = wasm.__wbg_get_ship_ship_id(this.__wbg_ptr);
1947
1703
  return ret;
1948
1704
  }
1949
1705
  /**
@@ -1953,13 +1709,6 @@ class Ship {
1953
1709
  const ret = wasm.__wbg_get_ship_ship_type(this.__wbg_ptr);
1954
1710
  return ret;
1955
1711
  }
1956
- /**
1957
- * @returns {number}
1958
- */
1959
- get ctype() {
1960
- const ret = wasm.__wbg_get_ship_ctype(this.__wbg_ptr);
1961
- return ret;
1962
- }
1963
1712
  /**
1964
1713
  * @returns {SlotSizeVec}
1965
1714
  */
@@ -1967,6 +1716,14 @@ class Ship {
1967
1716
  const ret = wasm.__wbg_get_ship_slots(this.__wbg_ptr);
1968
1717
  return ret;
1969
1718
  }
1719
+ /**
1720
+ * @param {string} arg0
1721
+ */
1722
+ set id(arg0) {
1723
+ const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1724
+ const len0 = WASM_VECTOR_LEN;
1725
+ wasm.__wbg_set_ship_id(this.__wbg_ptr, ptr0, len0);
1726
+ }
1970
1727
  /**
1971
1728
  * @param {SlotSizeVec} arg0
1972
1729
  */
@@ -1974,182 +1731,158 @@ class Ship {
1974
1731
  wasm.__wbg_set_ship_slots(this.__wbg_ptr, arg0);
1975
1732
  }
1976
1733
  /**
1977
- * @param {string} key
1978
1734
  * @returns {number}
1979
1735
  */
1980
- get_ebonus(key) {
1981
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1982
- const len0 = WASM_VECTOR_LEN;
1983
- const ret = wasm.ship_get_ebonus(this.__wbg_ptr, ptr0, len0);
1736
+ get accuracy() {
1737
+ const ret = wasm.ship_accuracy(this.__wbg_ptr);
1984
1738
  return ret;
1985
1739
  }
1986
1740
  /**
1987
- * @returns {boolean}
1988
- */
1989
- is_abyssal() {
1990
- const ret = wasm.ship_is_abyssal(this.__wbg_ptr);
1991
- return ret !== 0;
1992
- }
1993
- /**
1994
- * @returns {boolean}
1995
- */
1996
- is_amagiri() {
1997
- const ret = wasm.ship_is_amagiri(this.__wbg_ptr);
1998
- return ret !== 0;
1999
- }
2000
- /**
2001
- * 確殺攻撃力
2002
1741
  * @returns {number | undefined}
2003
1742
  */
2004
- ohko_power() {
2005
- const ret = wasm.ship_ohko_power(this.__wbg_ptr);
2006
- return ret[0] === 0 ? undefined : ret[1];
1743
+ get anti_air() {
1744
+ const ret = wasm.ship_anti_air(this.__wbg_ptr);
1745
+ return ret === 0xFFFFFF ? undefined : ret;
2007
1746
  }
2008
1747
  /**
2009
1748
  * @returns {number | undefined}
2010
1749
  */
2011
- get naked_armor() {
2012
- const ret = wasm.ship_naked_armor(this.__wbg_ptr);
1750
+ get armor() {
1751
+ const ret = wasm.ship_armor(this.__wbg_ptr);
2013
1752
  return ret === 0xFFFFFF ? undefined : ret;
2014
1753
  }
2015
1754
  /**
2016
1755
  * @returns {number | undefined}
2017
1756
  */
2018
- get naked_range() {
2019
- const ret = wasm.ship_naked_range(this.__wbg_ptr);
1757
+ get asw() {
1758
+ const ret = wasm.ship_asw(this.__wbg_ptr);
2020
1759
  return ret === 0xFFFFFF ? undefined : ret;
2021
1760
  }
2022
1761
  /**
2023
- * @returns {number}
1762
+ * @returns {number | undefined}
2024
1763
  */
2025
- get naked_speed() {
2026
- const ret = wasm.ship_naked_speed(this.__wbg_ptr);
2027
- return ret;
1764
+ basic_accuracy_term() {
1765
+ const ret = wasm.ship_basic_accuracy_term(this.__wbg_ptr);
1766
+ return ret[0] === 0 ? undefined : ret[1];
2028
1767
  }
2029
1768
  /**
2030
- * @returns {DamageState}
1769
+ * @param {number} armor_penetration
1770
+ * @returns {number | undefined}
2031
1771
  */
2032
- damage_state() {
2033
- const ret = wasm.ship_damage_state(this.__wbg_ptr);
2034
- return ret;
1772
+ basic_defense_power(armor_penetration) {
1773
+ const ret = wasm.ship_basic_defense_power(this.__wbg_ptr, armor_penetration);
1774
+ return ret[0] === 0 ? undefined : ret[1];
2035
1775
  }
2036
1776
  /**
2037
- * @param {number} formation_mod
2038
- * @param {number} postcap_additive
2039
- * @param {number} postcap_multiplicative
2040
1777
  * @returns {number | undefined}
2041
1778
  */
2042
- evasion_term(formation_mod, postcap_additive, postcap_multiplicative) {
2043
- const ret = wasm.ship_evasion_term(this.__wbg_ptr, formation_mod, postcap_additive, postcap_multiplicative);
1779
+ basic_evasion_term() {
1780
+ const ret = wasm.ship_basic_evasion_term(this.__wbg_ptr);
2044
1781
  return ret[0] === 0 ? undefined : ret[1];
2045
1782
  }
2046
1783
  /**
1784
+ * @param {Gear} gear
2047
1785
  * @param {string} key
2048
- * @returns {number | undefined}
1786
+ * @returns {boolean}
2049
1787
  */
2050
- get_stat_mod(key) {
1788
+ can_equip(gear, key) {
1789
+ _assertClass(gear, Gear);
2051
1790
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2052
1791
  const len0 = WASM_VECTOR_LEN;
2053
- const ret = wasm.ship_get_stat_mod(this.__wbg_ptr, ptr0, len0);
2054
- return ret === 0xFFFFFF ? undefined : ret;
2055
- }
2056
- /**
2057
- * @returns {boolean}
2058
- */
2059
- is_submarine() {
2060
- const ret = wasm.ship_is_submarine(this.__wbg_ptr);
1792
+ const ret = wasm.ship_can_equip(this.__wbg_ptr, gear.__wbg_ptr, ptr0, len0);
2061
1793
  return ret !== 0;
2062
1794
  }
2063
1795
  /**
2064
- * @returns {MoraleState}
1796
+ * @returns {ShipCategory}
2065
1797
  */
2066
- morale_state() {
2067
- const ret = wasm.ship_morale_state(this.__wbg_ptr);
1798
+ category() {
1799
+ const ret = wasm.ship_category(this.__wbg_ptr);
2068
1800
  return ret;
2069
1801
  }
2070
1802
  /**
2071
1803
  * @returns {number}
2072
1804
  */
2073
- get remodel_rank() {
2074
- const ret = wasm.ship_remodel_rank(this.__wbg_ptr);
1805
+ cruiser_fit_bonus() {
1806
+ const ret = wasm.ship_cruiser_fit_bonus(this.__wbg_ptr);
2075
1807
  return ret;
2076
1808
  }
2077
1809
  /**
2078
- * @param {AirWaveType} air_type
2079
- * @returns {number | undefined}
1810
+ * @returns {CustomPowerModifiers}
2080
1811
  */
2081
- fighter_power(air_type) {
2082
- const ret = wasm.ship_fighter_power(this.__wbg_ptr, air_type);
2083
- return ret === 0x100000001 ? undefined : ret;
1812
+ custom_power_mods() {
1813
+ const ret = wasm.ship_custom_power_mods(this.__wbg_ptr);
1814
+ return ret;
2084
1815
  }
2085
1816
  /**
2086
- * @param {string} key
2087
- * @returns {number}
1817
+ * @returns {DamageState}
2088
1818
  */
2089
- get_gear_stat(key) {
2090
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2091
- const len0 = WASM_VECTOR_LEN;
2092
- const ret = wasm.ship_get_gear_stat(this.__wbg_ptr, ptr0, len0);
1819
+ damage_state() {
1820
+ const ret = wasm.ship_damage_state(this.__wbg_ptr);
2093
1821
  return ret;
2094
1822
  }
2095
1823
  /**
2096
- * @param {number} index
2097
- * @returns {number | undefined}
1824
+ * @returns {Ship}
2098
1825
  */
2099
- get_slot_size(index) {
2100
- const ret = wasm.ship_get_slot_size(this.__wbg_ptr, index);
2101
- return ret === 0xFFFFFF ? undefined : ret;
1826
+ static default() {
1827
+ const ret = wasm.ship_default();
1828
+ return Ship.__wrap(ret);
2102
1829
  }
2103
1830
  /**
1831
+ * @param {number} node_divaricated_factor
2104
1832
  * @returns {number | undefined}
2105
1833
  */
2106
- get naked_evasion() {
2107
- const ret = wasm.ship_naked_evasion(this.__wbg_ptr);
2108
- return ret === 0xFFFFFF ? undefined : ret;
1834
+ elos(node_divaricated_factor) {
1835
+ const ret = wasm.ship_elos(this.__wbg_ptr, node_divaricated_factor);
1836
+ return ret[0] === 0 ? undefined : ret[1];
2109
1837
  }
2110
1838
  /**
2111
- * @returns {number | undefined}
1839
+ * @param {string} id
1840
+ * @returns {boolean}
2112
1841
  */
2113
- get naked_torpedo() {
2114
- const ret = wasm.ship_naked_torpedo(this.__wbg_ptr);
2115
- return ret === 0xFFFFFF ? undefined : ret;
1842
+ eq_id(id) {
1843
+ const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1844
+ const len0 = WASM_VECTOR_LEN;
1845
+ const ret = wasm.ship_eq_id(this.__wbg_ptr, ptr0, len0);
1846
+ return ret !== 0;
2116
1847
  }
2117
1848
  /**
2118
- * @param {string} key
2119
1849
  * @returns {number | undefined}
2120
1850
  */
2121
- get_naked_stat(key) {
2122
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2123
- const len0 = WASM_VECTOR_LEN;
2124
- const ret = wasm.ship_get_naked_stat(this.__wbg_ptr, ptr0, len0);
1851
+ get evasion() {
1852
+ const ret = wasm.ship_evasion(this.__wbg_ptr);
2125
1853
  return ret === 0xFFFFFF ? undefined : ret;
2126
1854
  }
2127
1855
  /**
1856
+ * @param {number} formation_mod
1857
+ * @param {number} postcap_additive
1858
+ * @param {number} postcap_multiplicative
2128
1859
  * @returns {number | undefined}
2129
1860
  */
2130
- get naked_anti_air() {
2131
- const ret = wasm.ship_naked_anti_air(this.__wbg_ptr);
2132
- return ret === 0xFFFFFF ? undefined : ret;
1861
+ evasion_term(formation_mod, postcap_additive, postcap_multiplicative) {
1862
+ const ret = wasm.ship_evasion_term(this.__wbg_ptr, formation_mod, postcap_additive, postcap_multiplicative);
1863
+ return ret[0] === 0 ? undefined : ret[1];
2133
1864
  }
2134
1865
  /**
2135
- * @returns {boolean}
1866
+ * @param {AirWaveType} air_type
1867
+ * @returns {number | undefined}
2136
1868
  */
2137
- is_installation() {
2138
- const ret = wasm.ship_is_installation(this.__wbg_ptr);
2139
- return ret !== 0;
1869
+ fighter_power(air_type) {
1870
+ const ret = wasm.ship_fighter_power(this.__wbg_ptr, air_type);
1871
+ return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
2140
1872
  }
2141
1873
  /**
2142
1874
  * @returns {number | undefined}
2143
1875
  */
2144
- get naked_firepower() {
2145
- const ret = wasm.ship_naked_firepower(this.__wbg_ptr);
1876
+ get firepower() {
1877
+ const ret = wasm.ship_firepower(this.__wbg_ptr);
2146
1878
  return ret === 0xFFFFFF ? undefined : ret;
2147
1879
  }
2148
1880
  /**
1881
+ * 艦隊対空補正
2149
1882
  * @returns {number}
2150
1883
  */
2151
- transport_point() {
2152
- const ret = wasm.ship_transport_point(this.__wbg_ptr);
1884
+ fleet_anti_air_mod() {
1885
+ const ret = wasm.ship_fleet_anti_air_mod(this.__wbg_ptr);
2153
1886
  return ret;
2154
1887
  }
2155
1888
  /**
@@ -2159,6 +1892,15 @@ class Ship {
2159
1892
  const ret = wasm.ship_fleet_los_factor(this.__wbg_ptr);
2160
1893
  return ret[0] === 0 ? undefined : ret[1];
2161
1894
  }
1895
+ /**
1896
+ * @returns {string[]}
1897
+ */
1898
+ gear_keys() {
1899
+ const ret = wasm.ship_gear_keys(this.__wbg_ptr);
1900
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
1901
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1902
+ return v1;
1903
+ }
2162
1904
  /**
2163
1905
  * @param {DamageState} state
2164
1906
  * @returns {number | undefined}
@@ -2169,26 +1911,32 @@ class Ship {
2169
1911
  }
2170
1912
  /**
2171
1913
  * @param {string} key
2172
- * @returns {boolean}
1914
+ * @returns {number}
2173
1915
  */
2174
- has_unknown_stat(key) {
1916
+ get_ebonus(key) {
2175
1917
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2176
1918
  const len0 = WASM_VECTOR_LEN;
2177
- const ret = wasm.ship_has_unknown_stat(this.__wbg_ptr, ptr0, len0);
2178
- return ret !== 0;
1919
+ const ret = wasm.ship_get_ebonus(this.__wbg_ptr, ptr0, len0);
1920
+ return ret;
2179
1921
  }
2180
1922
  /**
2181
- * @returns {number}
1923
+ * @param {string} key
1924
+ * @returns {Gear | undefined}
2182
1925
  */
2183
- cruiser_fit_bonus() {
2184
- const ret = wasm.ship_cruiser_fit_bonus(this.__wbg_ptr);
2185
- return ret;
1926
+ get_gear(key) {
1927
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1928
+ const len0 = WASM_VECTOR_LEN;
1929
+ const ret = wasm.ship_get_gear(this.__wbg_ptr, ptr0, len0);
1930
+ return ret === 0 ? undefined : Gear.__wrap(ret);
2186
1931
  }
2187
1932
  /**
2188
- * @returns {CustomPowerModifiers}
1933
+ * @param {string} key
1934
+ * @returns {number}
2189
1935
  */
2190
- custom_power_mods() {
2191
- const ret = wasm.ship_custom_power_mods(this.__wbg_ptr);
1936
+ get_gear_stat(key) {
1937
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1938
+ const len0 = WASM_VECTOR_LEN;
1939
+ const ret = wasm.ship_get_gear_stat(this.__wbg_ptr, ptr0, len0);
2192
1940
  return ret;
2193
1941
  }
2194
1942
  /**
@@ -2200,19 +1948,14 @@ class Ship {
2200
1948
  return ret === 0xFFFFFF ? undefined : ret;
2201
1949
  }
2202
1950
  /**
1951
+ * @param {string} key
2203
1952
  * @returns {number | undefined}
2204
1953
  */
2205
- basic_evasion_term() {
2206
- const ret = wasm.ship_basic_evasion_term(this.__wbg_ptr);
2207
- return ret[0] === 0 ? undefined : ret[1];
2208
- }
2209
- /**
2210
- * 艦隊対空補正
2211
- * @returns {number}
2212
- */
2213
- fleet_anti_air_mod() {
2214
- const ret = wasm.ship_fleet_anti_air_mod(this.__wbg_ptr);
2215
- return ret;
1954
+ get_naked_stat(key) {
1955
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1956
+ const len0 = WASM_VECTOR_LEN;
1957
+ const ret = wasm.ship_get_naked_stat(this.__wbg_ptr, ptr0, len0);
1958
+ return ret === 0xFFFFFF ? undefined : ret;
2216
1959
  }
2217
1960
  /**
2218
1961
  * @param {number} rate
@@ -2233,40 +1976,12 @@ class Ship {
2233
1976
  return ret;
2234
1977
  }
2235
1978
  /**
2236
- * @returns {number}
2237
- */
2238
- remaining_ammo_mod() {
2239
- const ret = wasm.ship_remaining_ammo_mod(this.__wbg_ptr);
2240
- return ret;
2241
- }
2242
- /**
2243
- * @returns {number}
2244
- */
2245
- remaining_fuel_mod() {
2246
- const ret = wasm.ship_remaining_fuel_mod(this.__wbg_ptr);
2247
- return ret;
2248
- }
2249
- /**
2250
- * @returns {SpecialEnemyType}
2251
- */
2252
- special_enemy_type() {
2253
- const ret = wasm.ship_special_enemy_type(this.__wbg_ptr);
2254
- return ret;
2255
- }
2256
- /**
2257
- * @returns {number | undefined}
2258
- */
2259
- basic_accuracy_term() {
2260
- const ret = wasm.ship_basic_accuracy_term(this.__wbg_ptr);
2261
- return ret[0] === 0 ? undefined : ret[1];
2262
- }
2263
- /**
2264
- * @param {number} armor_penetration
1979
+ * @param {number} index
2265
1980
  * @returns {number | undefined}
2266
1981
  */
2267
- basic_defense_power(armor_penetration) {
2268
- const ret = wasm.ship_basic_defense_power(this.__wbg_ptr, armor_penetration);
2269
- return ret[0] === 0 ? undefined : ret[1];
1982
+ get_slot_size(index) {
1983
+ const ret = wasm.ship_get_slot_size(this.__wbg_ptr, index);
1984
+ return ret === 0xFFFFFF ? undefined : ret;
2270
1985
  }
2271
1986
  /**
2272
1987
  * @param {string} key
@@ -2279,147 +1994,127 @@ class Ship {
2279
1994
  return ret === 0xFFFFFF ? undefined : ret;
2280
1995
  }
2281
1996
  /**
2282
- * 加重対空
2283
- * @param {Side} side
1997
+ * @param {string} key
2284
1998
  * @returns {number | undefined}
2285
1999
  */
2286
- ship_adjusted_anti_air(side) {
2287
- const ret = wasm.ship_ship_adjusted_anti_air(this.__wbg_ptr, side);
2288
- return ret[0] === 0 ? undefined : ret[1];
2000
+ get_stat_interval_right(key) {
2001
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2002
+ const len0 = WASM_VECTOR_LEN;
2003
+ const ret = wasm.ship_get_stat_interval_right(this.__wbg_ptr, ptr0, len0);
2004
+ return ret === 0xFFFFFF ? undefined : ret;
2289
2005
  }
2290
2006
  /**
2291
2007
  * @param {string} key
2292
2008
  * @returns {number | undefined}
2293
2009
  */
2294
- get_stat_interval_right(key) {
2010
+ get_stat_mod(key) {
2295
2011
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2296
2012
  const len0 = WASM_VECTOR_LEN;
2297
- const ret = wasm.ship_get_stat_interval_right(this.__wbg_ptr, ptr0, len0);
2013
+ const ret = wasm.ship_get_stat_mod(this.__wbg_ptr, ptr0, len0);
2298
2014
  return ret === 0xFFFFFF ? undefined : ret;
2299
2015
  }
2300
2016
  /**
2017
+ * フィット砲補正
2018
+ * @param {boolean} is_night
2301
2019
  * @returns {number}
2302
2020
  */
2303
- get innate_torpedo_accuracy() {
2304
- const ret = wasm.ship_innate_torpedo_accuracy(this.__wbg_ptr);
2021
+ gunfit_accuracy(is_night) {
2022
+ const ret = wasm.ship_gunfit_accuracy(this.__wbg_ptr, is_night);
2305
2023
  return ret;
2306
2024
  }
2307
2025
  /**
2026
+ * @param {ShipAttr} attr
2308
2027
  * @returns {boolean}
2309
2028
  */
2310
- is_attackable_by_torpedo() {
2311
- const ret = wasm.ship_is_attackable_by_torpedo(this.__wbg_ptr);
2029
+ has_attr(attr) {
2030
+ const ret = wasm.ship_has_attr(this.__wbg_ptr, attr);
2312
2031
  return ret !== 0;
2313
2032
  }
2314
2033
  /**
2315
- * @returns {number | undefined}
2034
+ * @param {string} key
2035
+ * @returns {boolean}
2316
2036
  */
2317
- get asw() {
2318
- const ret = wasm.ship_asw(this.__wbg_ptr);
2319
- return ret === 0xFFFFFF ? undefined : ret;
2037
+ has_unknown_stat(key) {
2038
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2039
+ const len0 = WASM_VECTOR_LEN;
2040
+ const ret = wasm.ship_has_unknown_stat(this.__wbg_ptr, ptr0, len0);
2041
+ return ret !== 0;
2320
2042
  }
2321
2043
  /**
2322
- * @returns {number | undefined}
2044
+ * @returns {number}
2323
2045
  */
2324
- get los() {
2325
- const ret = wasm.ship_los(this.__wbg_ptr);
2326
- return ret === 0xFFFFFF ? undefined : ret;
2046
+ get innate_torpedo_accuracy() {
2047
+ const ret = wasm.ship_innate_torpedo_accuracy(this.__wbg_ptr);
2048
+ return ret;
2327
2049
  }
2328
2050
  /**
2329
- * @param {number} node_divaricated_factor
2330
- * @returns {number | undefined}
2051
+ * @returns {boolean}
2331
2052
  */
2332
- elos(node_divaricated_factor) {
2333
- const ret = wasm.ship_elos(this.__wbg_ptr, node_divaricated_factor);
2334
- return ret[0] === 0 ? undefined : ret[1];
2053
+ is_abyssal() {
2054
+ const ret = wasm.ship_is_abyssal(this.__wbg_ptr);
2055
+ return ret !== 0;
2335
2056
  }
2336
2057
  /**
2337
- * @returns {number | undefined}
2058
+ * @returns {boolean}
2338
2059
  */
2339
- get luck() {
2340
- const ret = wasm.ship_luck(this.__wbg_ptr);
2341
- return ret === 0xFFFFFF ? undefined : ret;
2060
+ is_amagiri() {
2061
+ const ret = wasm.ship_is_amagiri(this.__wbg_ptr);
2062
+ return ret !== 0;
2342
2063
  }
2343
2064
  /**
2344
- * @returns {ShipMeta}
2065
+ * @returns {boolean}
2345
2066
  */
2346
- meta() {
2347
- const ret = wasm.ship_meta(this.__wbg_ptr);
2348
- return ret;
2349
- }
2350
- /**
2351
- * @returns {string}
2352
- */
2353
- get name() {
2354
- let deferred1_0;
2355
- let deferred1_1;
2356
- try {
2357
- const ret = wasm.ship_name(this.__wbg_ptr);
2358
- deferred1_0 = ret[0];
2359
- deferred1_1 = ret[1];
2360
- return getStringFromWasm0(ret[0], ret[1]);
2361
- } finally {
2362
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2363
- }
2067
+ is_attackable_by_torpedo() {
2068
+ const ret = wasm.ship_is_attackable_by_torpedo(this.__wbg_ptr);
2069
+ return ret !== 0;
2364
2070
  }
2365
2071
  /**
2366
- * @returns {string}
2072
+ * @returns {boolean}
2367
2073
  */
2368
- get yomi() {
2369
- let deferred1_0;
2370
- let deferred1_1;
2371
- try {
2372
- const ret = wasm.ship_yomi(this.__wbg_ptr);
2373
- deferred1_0 = ret[0];
2374
- deferred1_1 = ret[1];
2375
- return getStringFromWasm0(ret[0], ret[1]);
2376
- } finally {
2377
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2378
- }
2074
+ is_installation() {
2075
+ const ret = wasm.ship_is_installation(this.__wbg_ptr);
2076
+ return ret !== 0;
2379
2077
  }
2380
2078
  /**
2381
- * @returns {number | undefined}
2079
+ * @returns {boolean}
2382
2080
  */
2383
- get armor() {
2384
- const ret = wasm.ship_armor(this.__wbg_ptr);
2385
- return ret === 0xFFFFFF ? undefined : ret;
2081
+ is_pt_imp() {
2082
+ const ret = wasm.ship_is_pt_imp(this.__wbg_ptr);
2083
+ return ret !== 0;
2386
2084
  }
2387
2085
  /**
2388
- * @param {string} id
2389
2086
  * @returns {boolean}
2390
2087
  */
2391
- eq_id(id) {
2392
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2393
- const len0 = WASM_VECTOR_LEN;
2394
- const ret = wasm.ship_eq_id(this.__wbg_ptr, ptr0, len0);
2088
+ is_submarine() {
2089
+ const ret = wasm.ship_is_submarine(this.__wbg_ptr);
2395
2090
  return ret !== 0;
2396
2091
  }
2397
2092
  /**
2398
2093
  * @returns {number | undefined}
2399
2094
  */
2400
- get range() {
2401
- const ret = wasm.ship_range(this.__wbg_ptr);
2095
+ get los() {
2096
+ const ret = wasm.ship_los(this.__wbg_ptr);
2402
2097
  return ret === 0xFFFFFF ? undefined : ret;
2403
2098
  }
2404
2099
  /**
2405
- * @returns {number}
2100
+ * @returns {number | undefined}
2406
2101
  */
2407
- get speed() {
2408
- const ret = wasm.ship_speed(this.__wbg_ptr);
2409
- return ret;
2102
+ get luck() {
2103
+ const ret = wasm.ship_luck(this.__wbg_ptr);
2104
+ return ret === 0xFFFFFF ? undefined : ret;
2410
2105
  }
2411
2106
  /**
2412
- * @returns {ShipState}
2107
+ * @returns {number}
2413
2108
  */
2414
- state() {
2415
- const ret = wasm.ship_state(this.__wbg_ptr);
2109
+ get max_ammo() {
2110
+ const ret = wasm.ship_max_ammo(this.__wbg_ptr);
2416
2111
  return ret;
2417
2112
  }
2418
2113
  /**
2419
2114
  * @returns {number}
2420
2115
  */
2421
- get stype() {
2422
- const ret = wasm.ship_stype(this.__wbg_ptr);
2116
+ get max_fuel() {
2117
+ const ret = wasm.ship_max_fuel(this.__wbg_ptr);
2423
2118
  return ret;
2424
2119
  }
2425
2120
  /**
@@ -2430,163 +2125,182 @@ class Ship {
2430
2125
  return ret === 0xFFFFFF ? undefined : ret;
2431
2126
  }
2432
2127
  /**
2433
- * @returns {boolean}
2128
+ * @returns {ShipMeta}
2434
2129
  */
2435
- get useful() {
2436
- const ret = wasm.ship_useful(this.__wbg_ptr);
2437
- return ret !== 0;
2130
+ meta() {
2131
+ const ret = wasm.ship_meta(this.__wbg_ptr);
2132
+ return ret;
2438
2133
  }
2439
2134
  /**
2440
- * @returns {Ship}
2135
+ * @returns {MoraleState}
2441
2136
  */
2442
- static default() {
2443
- const ret = wasm.ship_default();
2444
- return Ship.__wrap(ret);
2137
+ morale_state() {
2138
+ const ret = wasm.ship_morale_state(this.__wbg_ptr);
2139
+ return ret;
2445
2140
  }
2446
2141
  /**
2447
2142
  * @returns {number | undefined}
2448
2143
  */
2449
- get evasion() {
2450
- const ret = wasm.ship_evasion(this.__wbg_ptr);
2144
+ get naked_anti_air() {
2145
+ const ret = wasm.ship_naked_anti_air(this.__wbg_ptr);
2451
2146
  return ret === 0xFFFFFF ? undefined : ret;
2452
2147
  }
2453
2148
  /**
2454
- * @returns {number}
2149
+ * @returns {number | undefined}
2455
2150
  */
2456
- get next_id() {
2457
- const ret = wasm.ship_next_id(this.__wbg_ptr);
2458
- return ret;
2151
+ get naked_armor() {
2152
+ const ret = wasm.ship_naked_armor(this.__wbg_ptr);
2153
+ return ret === 0xFFFFFF ? undefined : ret;
2459
2154
  }
2460
2155
  /**
2461
- * @returns {number}
2156
+ * @returns {number | undefined}
2462
2157
  */
2463
- get slotnum() {
2464
- const ret = wasm.ship_slotnum(this.__wbg_ptr);
2465
- return ret >>> 0;
2158
+ get naked_asw() {
2159
+ const ret = wasm.ship_naked_asw(this.__wbg_ptr);
2160
+ return ret === 0xFFFFFF ? undefined : ret;
2466
2161
  }
2467
2162
  /**
2468
- * @returns {number}
2163
+ * @returns {number | undefined}
2469
2164
  */
2470
- get sort_id() {
2471
- const ret = wasm.ship_sort_id(this.__wbg_ptr);
2472
- return ret;
2165
+ get naked_evasion() {
2166
+ const ret = wasm.ship_naked_evasion(this.__wbg_ptr);
2167
+ return ret === 0xFFFFFF ? undefined : ret;
2473
2168
  }
2474
2169
  /**
2475
2170
  * @returns {number | undefined}
2476
2171
  */
2477
- get torpedo() {
2478
- const ret = wasm.ship_torpedo(this.__wbg_ptr);
2172
+ get naked_firepower() {
2173
+ const ret = wasm.ship_naked_firepower(this.__wbg_ptr);
2174
+ return ret === 0xFFFFFF ? undefined : ret;
2175
+ }
2176
+ /**
2177
+ * @returns {number | undefined}
2178
+ */
2179
+ get naked_los() {
2180
+ const ret = wasm.ship_naked_los(this.__wbg_ptr);
2181
+ return ret === 0xFFFFFF ? undefined : ret;
2182
+ }
2183
+ /**
2184
+ * @returns {number | undefined}
2185
+ */
2186
+ get naked_range() {
2187
+ const ret = wasm.ship_naked_range(this.__wbg_ptr);
2479
2188
  return ret === 0xFFFFFF ? undefined : ret;
2480
2189
  }
2481
2190
  /**
2482
2191
  * @returns {number}
2483
2192
  */
2484
- get accuracy() {
2485
- const ret = wasm.ship_accuracy(this.__wbg_ptr);
2193
+ get naked_speed() {
2194
+ const ret = wasm.ship_naked_speed(this.__wbg_ptr);
2486
2195
  return ret;
2487
2196
  }
2488
2197
  /**
2489
2198
  * @returns {number | undefined}
2490
2199
  */
2491
- get anti_air() {
2492
- const ret = wasm.ship_anti_air(this.__wbg_ptr);
2200
+ get naked_torpedo() {
2201
+ const ret = wasm.ship_naked_torpedo(this.__wbg_ptr);
2493
2202
  return ret === 0xFFFFFF ? undefined : ret;
2494
2203
  }
2495
2204
  /**
2496
- * @returns {ShipCategory}
2205
+ * @returns {string}
2497
2206
  */
2498
- category() {
2499
- const ret = wasm.ship_category(this.__wbg_ptr);
2207
+ get name() {
2208
+ let deferred1_0;
2209
+ let deferred1_1;
2210
+ try {
2211
+ const ret = wasm.ship_name(this.__wbg_ptr);
2212
+ deferred1_0 = ret[0];
2213
+ deferred1_1 = ret[1];
2214
+ return getStringFromWasm0(ret[0], ret[1]);
2215
+ } finally {
2216
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2217
+ }
2218
+ }
2219
+ /**
2220
+ * @returns {number}
2221
+ */
2222
+ get next_id() {
2223
+ const ret = wasm.ship_next_id(this.__wbg_ptr);
2500
2224
  return ret;
2501
2225
  }
2502
2226
  /**
2503
- * @param {string} key
2504
- * @returns {Gear | undefined}
2227
+ * 確殺攻撃力
2228
+ * @returns {number | undefined}
2505
2229
  */
2506
- get_gear(key) {
2507
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2508
- const len0 = WASM_VECTOR_LEN;
2509
- const ret = wasm.ship_get_gear(this.__wbg_ptr, ptr0, len0);
2510
- return ret === 0 ? undefined : Gear.__wrap(ret);
2230
+ ohko_power() {
2231
+ const ret = wasm.ship_ohko_power(this.__wbg_ptr);
2232
+ return ret[0] === 0 ? undefined : ret[1];
2511
2233
  }
2512
2234
  /**
2513
- * @param {ShipAttr} attr
2514
- * @returns {boolean}
2235
+ * @returns {number | undefined}
2515
2236
  */
2516
- has_attr(attr) {
2517
- const ret = wasm.ship_has_attr(this.__wbg_ptr, attr);
2518
- return ret !== 0;
2237
+ get range() {
2238
+ const ret = wasm.ship_range(this.__wbg_ptr);
2239
+ return ret === 0xFFFFFF ? undefined : ret;
2519
2240
  }
2520
2241
  /**
2521
2242
  * @returns {number}
2522
2243
  */
2523
- get max_ammo() {
2524
- const ret = wasm.ship_max_ammo(this.__wbg_ptr);
2244
+ remaining_ammo_mod() {
2245
+ const ret = wasm.ship_remaining_ammo_mod(this.__wbg_ptr);
2525
2246
  return ret;
2526
2247
  }
2527
2248
  /**
2528
2249
  * @returns {number}
2529
2250
  */
2530
- get max_fuel() {
2531
- const ret = wasm.ship_max_fuel(this.__wbg_ptr);
2251
+ remaining_fuel_mod() {
2252
+ const ret = wasm.ship_remaining_fuel_mod(this.__wbg_ptr);
2532
2253
  return ret;
2533
2254
  }
2534
2255
  /**
2535
- * @param {Gear} gear
2536
- * @param {string} key
2537
- * @returns {boolean}
2256
+ * @returns {number}
2538
2257
  */
2539
- can_equip(gear, key) {
2540
- _assertClass(gear, Gear);
2541
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2542
- const len0 = WASM_VECTOR_LEN;
2543
- const ret = wasm.ship_can_equip(this.__wbg_ptr, gear.__wbg_ptr, ptr0, len0);
2544
- return ret !== 0;
2258
+ get remodel_rank() {
2259
+ const ret = wasm.ship_remodel_rank(this.__wbg_ptr);
2260
+ return ret;
2545
2261
  }
2546
2262
  /**
2263
+ * 加重対空
2264
+ * @param {Side} side
2547
2265
  * @returns {number | undefined}
2548
2266
  */
2549
- get firepower() {
2550
- const ret = wasm.ship_firepower(this.__wbg_ptr);
2551
- return ret === 0xFFFFFF ? undefined : ret;
2267
+ ship_adjusted_anti_air(side) {
2268
+ const ret = wasm.ship_ship_adjusted_anti_air(this.__wbg_ptr, side);
2269
+ return ret[0] === 0 ? undefined : ret[1];
2552
2270
  }
2553
2271
  /**
2554
- * @returns {string[]}
2272
+ * @returns {number}
2555
2273
  */
2556
- gear_keys() {
2557
- const ret = wasm.ship_gear_keys(this.__wbg_ptr);
2558
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
2559
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
2560
- return v1;
2274
+ get slotnum() {
2275
+ const ret = wasm.ship_slotnum(this.__wbg_ptr);
2276
+ return ret >>> 0;
2561
2277
  }
2562
2278
  /**
2563
- * @returns {boolean}
2279
+ * @returns {number}
2564
2280
  */
2565
- is_pt_imp() {
2566
- const ret = wasm.ship_is_pt_imp(this.__wbg_ptr);
2567
- return ret !== 0;
2281
+ get sort_id() {
2282
+ const ret = wasm.ship_sort_id(this.__wbg_ptr);
2283
+ return ret;
2568
2284
  }
2569
2285
  /**
2570
- * @returns {number | undefined}
2286
+ * @returns {SpecialEnemyType}
2571
2287
  */
2572
- get naked_asw() {
2573
- const ret = wasm.ship_naked_asw(this.__wbg_ptr);
2574
- return ret === 0xFFFFFF ? undefined : ret;
2288
+ special_enemy_type() {
2289
+ const ret = wasm.ship_special_enemy_type(this.__wbg_ptr);
2290
+ return ret;
2575
2291
  }
2576
2292
  /**
2577
- * @returns {number | undefined}
2293
+ * @returns {number}
2578
2294
  */
2579
- get naked_los() {
2580
- const ret = wasm.ship_naked_los(this.__wbg_ptr);
2581
- return ret === 0xFFFFFF ? undefined : ret;
2295
+ get speed() {
2296
+ const ret = wasm.ship_speed(this.__wbg_ptr);
2297
+ return ret;
2582
2298
  }
2583
2299
  /**
2584
- * フィット砲補正
2585
- * @param {boolean} is_night
2586
- * @returns {number}
2300
+ * @returns {ShipState}
2587
2301
  */
2588
- gunfit_accuracy(is_night) {
2589
- const ret = wasm.ship_gunfit_accuracy(this.__wbg_ptr, is_night);
2302
+ state() {
2303
+ const ret = wasm.ship_state(this.__wbg_ptr);
2590
2304
  return ret;
2591
2305
  }
2592
2306
  /**
@@ -2603,214 +2317,414 @@ class Ship {
2603
2317
  const ret = wasm.ship_state_night_gunfit_accuracy(this.__wbg_ptr);
2604
2318
  return ret[0] === 0 ? undefined : ret[1];
2605
2319
  }
2320
+ /**
2321
+ * @returns {number}
2322
+ */
2323
+ get stype() {
2324
+ const ret = wasm.ship_stype(this.__wbg_ptr);
2325
+ return ret;
2326
+ }
2327
+ /**
2328
+ * @returns {number | undefined}
2329
+ */
2330
+ get torpedo() {
2331
+ const ret = wasm.ship_torpedo(this.__wbg_ptr);
2332
+ return ret === 0xFFFFFF ? undefined : ret;
2333
+ }
2334
+ /**
2335
+ * @returns {number}
2336
+ */
2337
+ transport_point() {
2338
+ const ret = wasm.ship_transport_point(this.__wbg_ptr);
2339
+ return ret;
2340
+ }
2341
+ /**
2342
+ * @returns {boolean}
2343
+ */
2344
+ get useful() {
2345
+ const ret = wasm.ship_useful(this.__wbg_ptr);
2346
+ return ret !== 0;
2347
+ }
2348
+ /**
2349
+ * @returns {string}
2350
+ */
2351
+ get yomi() {
2352
+ let deferred1_0;
2353
+ let deferred1_1;
2354
+ try {
2355
+ const ret = wasm.ship_yomi(this.__wbg_ptr);
2356
+ deferred1_0 = ret[0];
2357
+ deferred1_1 = ret[1];
2358
+ return getStringFromWasm0(ret[0], ret[1]);
2359
+ } finally {
2360
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2361
+ }
2362
+ }
2606
2363
  }
2607
2364
  if (Symbol.dispose) Ship.prototype[Symbol.dispose] = Ship.prototype.free;
2608
-
2609
2365
  exports.Ship = Ship;
2610
2366
 
2611
- exports.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
2612
- const ret = arg0.call(arg1);
2613
- return ret;
2614
- }, arguments) };
2615
-
2616
- exports.__wbg_call_a5400b25a865cfd8 = function() { return handleError(function (arg0, arg1, arg2) {
2617
- const ret = arg0.call(arg1, arg2);
2618
- return ret;
2619
- }, arguments) };
2620
-
2621
- exports.__wbg_crypto_ed58b8e10a292839 = function(arg0) {
2622
- const ret = arg0.crypto;
2623
- return ret;
2624
- };
2625
-
2626
- exports.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
2627
- let deferred0_0;
2628
- let deferred0_1;
2629
- try {
2630
- deferred0_0 = arg0;
2631
- deferred0_1 = arg1;
2632
- console.error(getStringFromWasm0(arg0, arg1));
2633
- } finally {
2634
- wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
2635
- }
2636
- };
2637
-
2638
- exports.__wbg_getRandomValues_bcb4912f16000dc4 = function() { return handleError(function (arg0, arg1) {
2639
- arg0.getRandomValues(arg1);
2640
- }, arguments) };
2641
-
2642
- exports.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
2643
- const ret = arg0.length;
2644
- return ret;
2645
- };
2646
-
2647
- exports.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
2648
- const ret = arg0.msCrypto;
2649
- return ret;
2650
- };
2651
-
2652
- exports.__wbg_new_1f3a344cf3123716 = function() {
2653
- const ret = new Array();
2654
- return ret;
2655
- };
2656
-
2657
- exports.__wbg_new_8a6f238a6ece86ea = function() {
2658
- const ret = new Error();
2367
+ /**
2368
+ * @param {ShipConditions} value
2369
+ * @returns {ShipConditions}
2370
+ */
2371
+ function parse_ship_conditions(value) {
2372
+ const ret = wasm.parse_ship_conditions(value);
2659
2373
  return ret;
2660
- };
2374
+ }
2375
+ exports.parse_ship_conditions = parse_ship_conditions;
2661
2376
 
2662
- exports.__wbg_newnoargs_254190557c45b4ec = function(arg0, arg1) {
2663
- const ret = new Function(getStringFromWasm0(arg0, arg1));
2664
- return ret;
2665
- };
2377
+ function set_panic_hook() {
2378
+ wasm.set_panic_hook();
2379
+ }
2380
+ exports.set_panic_hook = set_panic_hook;
2381
+ const import1 = require("equipment-bonus");
2382
+
2383
+ function __wbg_get_imports() {
2384
+ const import0 = {
2385
+ __proto__: null,
2386
+ __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
2387
+ const ret = typeof(arg0) === 'function';
2388
+ return ret;
2389
+ },
2390
+ __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
2391
+ const val = arg0;
2392
+ const ret = typeof(val) === 'object' && val !== null;
2393
+ return ret;
2394
+ },
2395
+ __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
2396
+ const ret = typeof(arg0) === 'string';
2397
+ return ret;
2398
+ },
2399
+ __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
2400
+ const ret = arg0 === undefined;
2401
+ return ret;
2402
+ },
2403
+ __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
2404
+ const obj = arg1;
2405
+ const ret = typeof(obj) === 'string' ? obj : undefined;
2406
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2407
+ var len1 = WASM_VECTOR_LEN;
2408
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2409
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2410
+ },
2411
+ __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
2412
+ throw new Error(getStringFromWasm0(arg0, arg1));
2413
+ },
2414
+ __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
2415
+ const ret = arg0.call(arg1, arg2);
2416
+ return ret;
2417
+ }, arguments); },
2418
+ __wbg_crypto_38df2bab126b63dc: function(arg0) {
2419
+ const ret = arg0.crypto;
2420
+ return ret;
2421
+ },
2422
+ __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
2423
+ let deferred0_0;
2424
+ let deferred0_1;
2425
+ try {
2426
+ deferred0_0 = arg0;
2427
+ deferred0_1 = arg1;
2428
+ console.error(getStringFromWasm0(arg0, arg1));
2429
+ } finally {
2430
+ wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
2431
+ }
2432
+ },
2433
+ __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
2434
+ arg0.getRandomValues(arg1);
2435
+ }, arguments); },
2436
+ __wbg_length_1f0964f4a5e2c6d8: function(arg0) {
2437
+ const ret = arg0.length;
2438
+ return ret;
2439
+ },
2440
+ __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
2441
+ const ret = arg0.msCrypto;
2442
+ return ret;
2443
+ },
2444
+ __wbg_new_227d7c05414eb861: function() {
2445
+ const ret = new Error();
2446
+ return ret;
2447
+ },
2448
+ __wbg_new_32b398fb48b6d94a: function() {
2449
+ const ret = new Array();
2450
+ return ret;
2451
+ },
2452
+ __wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
2453
+ const ret = new Uint8Array(arg0 >>> 0);
2454
+ return ret;
2455
+ },
2456
+ __wbg_node_84ea875411254db1: function(arg0) {
2457
+ const ret = arg0.node;
2458
+ return ret;
2459
+ },
2460
+ __wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
2461
+ const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
2462
+ return ret;
2463
+ }, arguments); },
2464
+ __wbg_process_44c7a14e11e9f69e: function(arg0) {
2465
+ const ret = arg0.process;
2466
+ return ret;
2467
+ },
2468
+ __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
2469
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
2470
+ },
2471
+ __wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
2472
+ const ret = arg0.push(arg1);
2473
+ return ret;
2474
+ },
2475
+ __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
2476
+ arg0.randomFillSync(arg1);
2477
+ }, arguments); },
2478
+ __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
2479
+ const ret = module.require;
2480
+ return ret;
2481
+ }, arguments); },
2482
+ __wbg_ship_new: function(arg0) {
2483
+ const ret = Ship.__wrap(arg0);
2484
+ return ret;
2485
+ },
2486
+ __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
2487
+ const ret = arg1.stack;
2488
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2489
+ const len1 = WASM_VECTOR_LEN;
2490
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2491
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2492
+ },
2493
+ __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
2494
+ const ret = typeof global === 'undefined' ? null : global;
2495
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2496
+ },
2497
+ __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
2498
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
2499
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2500
+ },
2501
+ __wbg_static_accessor_SELF_146583524fe1469b: function() {
2502
+ const ret = typeof self === 'undefined' ? null : self;
2503
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2504
+ },
2505
+ __wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
2506
+ const ret = typeof window === 'undefined' ? null : window;
2507
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2508
+ },
2509
+ __wbg_stringify_b54333f60f1e4dad: function() { return handleError(function (arg0) {
2510
+ const ret = JSON.stringify(arg0);
2511
+ return ret;
2512
+ }, arguments); },
2513
+ __wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
2514
+ const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
2515
+ return ret;
2516
+ },
2517
+ __wbg_versions_276b2795b1c6a219: function(arg0) {
2518
+ const ret = arg0.versions;
2519
+ return ret;
2520
+ },
2521
+ __wbindgen_cast_0000000000000001: function(arg0, arg1) {
2522
+ // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
2523
+ const ret = getArrayU8FromWasm0(arg0, arg1);
2524
+ return ret;
2525
+ },
2526
+ __wbindgen_cast_0000000000000002: function(arg0, arg1) {
2527
+ // Cast intrinsic for `Ref(String) -> Externref`.
2528
+ const ret = getStringFromWasm0(arg0, arg1);
2529
+ return ret;
2530
+ },
2531
+ __wbindgen_init_externref_table: function() {
2532
+ const table = wasm.__wbindgen_externrefs;
2533
+ const offset = table.grow(4);
2534
+ table.set(0, undefined);
2535
+ table.set(offset + 0, undefined);
2536
+ table.set(offset + 1, null);
2537
+ table.set(offset + 2, true);
2538
+ table.set(offset + 3, false);
2539
+ },
2540
+ };
2541
+ return {
2542
+ __proto__: null,
2543
+ "./fleethub_core_bg.js": import0,
2544
+ "equipment-bonus": import1,
2545
+ };
2546
+ }
2666
2547
 
2667
- exports.__wbg_newwithlength_a167dcc7aaa3ba77 = function(arg0) {
2668
- const ret = new Uint8Array(arg0 >>> 0);
2669
- return ret;
2670
- };
2548
+ const AirSquadronFinalization = (typeof FinalizationRegistry === 'undefined')
2549
+ ? { register: () => {}, unregister: () => {} }
2550
+ : new FinalizationRegistry(ptr => wasm.__wbg_airsquadron_free(ptr, 1));
2551
+ const AnalyzerFinalization = (typeof FinalizationRegistry === 'undefined')
2552
+ ? { register: () => {}, unregister: () => {} }
2553
+ : new FinalizationRegistry(ptr => wasm.__wbg_analyzer_free(ptr, 1));
2554
+ const CompFinalization = (typeof FinalizationRegistry === 'undefined')
2555
+ ? { register: () => {}, unregister: () => {} }
2556
+ : new FinalizationRegistry(ptr => wasm.__wbg_comp_free(ptr, 1));
2557
+ const FhCoreFinalization = (typeof FinalizationRegistry === 'undefined')
2558
+ ? { register: () => {}, unregister: () => {} }
2559
+ : new FinalizationRegistry(ptr => wasm.__wbg_fhcore_free(ptr, 1));
2560
+ const FleetFinalization = (typeof FinalizationRegistry === 'undefined')
2561
+ ? { register: () => {}, unregister: () => {} }
2562
+ : new FinalizationRegistry(ptr => wasm.__wbg_fleet_free(ptr, 1));
2563
+ const GearFinalization = (typeof FinalizationRegistry === 'undefined')
2564
+ ? { register: () => {}, unregister: () => {} }
2565
+ : new FinalizationRegistry(ptr => wasm.__wbg_gear_free(ptr, 1));
2566
+ const OrgFinalization = (typeof FinalizationRegistry === 'undefined')
2567
+ ? { register: () => {}, unregister: () => {} }
2568
+ : new FinalizationRegistry(ptr => wasm.__wbg_org_free(ptr, 1));
2569
+ const ShipFinalization = (typeof FinalizationRegistry === 'undefined')
2570
+ ? { register: () => {}, unregister: () => {} }
2571
+ : new FinalizationRegistry(ptr => wasm.__wbg_ship_free(ptr, 1));
2671
2572
 
2672
- exports.__wbg_node_02999533c4ea02e3 = function(arg0) {
2673
- const ret = arg0.node;
2674
- return ret;
2675
- };
2573
+ function addToExternrefTable0(obj) {
2574
+ const idx = wasm.__externref_table_alloc();
2575
+ wasm.__wbindgen_externrefs.set(idx, obj);
2576
+ return idx;
2577
+ }
2676
2578
 
2677
- exports.__wbg_parse_442f5ba02e5eaf8b = function() { return handleError(function (arg0, arg1) {
2678
- const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
2679
- return ret;
2680
- }, arguments) };
2579
+ function _assertClass(instance, klass) {
2580
+ if (!(instance instanceof klass)) {
2581
+ throw new Error(`expected instance of ${klass.name}`);
2582
+ }
2583
+ }
2681
2584
 
2682
- exports.__wbg_process_5c1d670bc53614b8 = function(arg0) {
2683
- const ret = arg0.process;
2684
- return ret;
2685
- };
2585
+ function getArrayJsValueFromWasm0(ptr, len) {
2586
+ ptr = ptr >>> 0;
2587
+ const mem = getDataViewMemory0();
2588
+ const result = [];
2589
+ for (let i = ptr; i < ptr + 4 * len; i += 4) {
2590
+ result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
2591
+ }
2592
+ wasm.__externref_drop_slice(ptr, len);
2593
+ return result;
2594
+ }
2686
2595
 
2687
- exports.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
2688
- Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
2689
- };
2596
+ function getArrayU16FromWasm0(ptr, len) {
2597
+ ptr = ptr >>> 0;
2598
+ return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
2599
+ }
2690
2600
 
2691
- exports.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
2692
- const ret = arg0.push(arg1);
2693
- return ret;
2694
- };
2601
+ function getArrayU8FromWasm0(ptr, len) {
2602
+ ptr = ptr >>> 0;
2603
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
2604
+ }
2695
2605
 
2696
- exports.__wbg_randomFillSync_ab2cfe79ebbf2740 = function() { return handleError(function (arg0, arg1) {
2697
- arg0.randomFillSync(arg1);
2698
- }, arguments) };
2606
+ let cachedDataViewMemory0 = null;
2607
+ function getDataViewMemory0() {
2608
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
2609
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
2610
+ }
2611
+ return cachedDataViewMemory0;
2612
+ }
2699
2613
 
2700
- exports.__wbg_require_79b1e9274cde3c87 = function() { return handleError(function () {
2701
- const ret = module.require;
2702
- return ret;
2703
- }, arguments) };
2614
+ function getStringFromWasm0(ptr, len) {
2615
+ return decodeText(ptr >>> 0, len);
2616
+ }
2704
2617
 
2705
- exports.__wbg_ship_new = function(arg0) {
2706
- const ret = Ship.__wrap(arg0);
2707
- return ret;
2708
- };
2618
+ let cachedUint16ArrayMemory0 = null;
2619
+ function getUint16ArrayMemory0() {
2620
+ if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
2621
+ cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
2622
+ }
2623
+ return cachedUint16ArrayMemory0;
2624
+ }
2709
2625
 
2710
- exports.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
2711
- const ret = arg1.stack;
2712
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2713
- const len1 = WASM_VECTOR_LEN;
2714
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2715
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2716
- };
2626
+ let cachedUint8ArrayMemory0 = null;
2627
+ function getUint8ArrayMemory0() {
2628
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
2629
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
2630
+ }
2631
+ return cachedUint8ArrayMemory0;
2632
+ }
2717
2633
 
2718
- exports.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function() {
2719
- const ret = typeof global === 'undefined' ? null : global;
2720
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2721
- };
2634
+ function handleError(f, args) {
2635
+ try {
2636
+ return f.apply(this, args);
2637
+ } catch (e) {
2638
+ const idx = addToExternrefTable0(e);
2639
+ wasm.__wbindgen_exn_store(idx);
2640
+ }
2641
+ }
2722
2642
 
2723
- exports.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function() {
2724
- const ret = typeof globalThis === 'undefined' ? null : globalThis;
2725
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2726
- };
2643
+ function isLikeNone(x) {
2644
+ return x === undefined || x === null;
2645
+ }
2727
2646
 
2728
- exports.__wbg_static_accessor_SELF_995b214ae681ff99 = function() {
2729
- const ret = typeof self === 'undefined' ? null : self;
2730
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2731
- };
2647
+ function passArray16ToWasm0(arg, malloc) {
2648
+ const ptr = malloc(arg.length * 2, 2) >>> 0;
2649
+ getUint16ArrayMemory0().set(arg, ptr / 2);
2650
+ WASM_VECTOR_LEN = arg.length;
2651
+ return ptr;
2652
+ }
2732
2653
 
2733
- exports.__wbg_static_accessor_WINDOW_cde3890479c675ea = function() {
2734
- const ret = typeof window === 'undefined' ? null : window;
2735
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2736
- };
2654
+ function passArray8ToWasm0(arg, malloc) {
2655
+ const ptr = malloc(arg.length * 1, 1) >>> 0;
2656
+ getUint8ArrayMemory0().set(arg, ptr / 1);
2657
+ WASM_VECTOR_LEN = arg.length;
2658
+ return ptr;
2659
+ }
2737
2660
 
2738
- exports.__wbg_stringify_b98c93d0a190446a = function() { return handleError(function (arg0) {
2739
- const ret = JSON.stringify(arg0);
2740
- return ret;
2741
- }, arguments) };
2661
+ function passStringToWasm0(arg, malloc, realloc) {
2662
+ if (realloc === undefined) {
2663
+ const buf = cachedTextEncoder.encode(arg);
2664
+ const ptr = malloc(buf.length, 1) >>> 0;
2665
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
2666
+ WASM_VECTOR_LEN = buf.length;
2667
+ return ptr;
2668
+ }
2742
2669
 
2743
- exports.__wbg_subarray_70fd07feefe14294 = function(arg0, arg1, arg2) {
2744
- const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
2745
- return ret;
2746
- };
2670
+ let len = arg.length;
2671
+ let ptr = malloc(len, 1) >>> 0;
2747
2672
 
2748
- exports.__wbg_versions_c71aa1626a93e0a1 = function(arg0) {
2749
- const ret = arg0.versions;
2750
- return ret;
2751
- };
2673
+ const mem = getUint8ArrayMemory0();
2752
2674
 
2753
- exports.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
2754
- const ret = typeof(arg0) === 'function';
2755
- return ret;
2756
- };
2675
+ let offset = 0;
2757
2676
 
2758
- exports.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function(arg0) {
2759
- const val = arg0;
2760
- const ret = typeof(val) === 'object' && val !== null;
2761
- return ret;
2762
- };
2677
+ for (; offset < len; offset++) {
2678
+ const code = arg.charCodeAt(offset);
2679
+ if (code > 0x7F) break;
2680
+ mem[ptr + offset] = code;
2681
+ }
2682
+ if (offset !== len) {
2683
+ if (offset !== 0) {
2684
+ arg = arg.slice(offset);
2685
+ }
2686
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
2687
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
2688
+ const ret = cachedTextEncoder.encodeInto(arg, view);
2763
2689
 
2764
- exports.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
2765
- const ret = typeof(arg0) === 'string';
2766
- return ret;
2767
- };
2690
+ offset += ret.written;
2691
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
2692
+ }
2768
2693
 
2769
- exports.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
2770
- const ret = arg0 === undefined;
2771
- return ret;
2772
- };
2694
+ WASM_VECTOR_LEN = offset;
2695
+ return ptr;
2696
+ }
2773
2697
 
2774
- exports.__wbg_wbindgenstringget_0f16a6ddddef376f = function(arg0, arg1) {
2775
- const obj = arg1;
2776
- const ret = typeof(obj) === 'string' ? obj : undefined;
2777
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2778
- var len1 = WASM_VECTOR_LEN;
2779
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2780
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2781
- };
2698
+ function takeFromExternrefTable0(idx) {
2699
+ const value = wasm.__wbindgen_externrefs.get(idx);
2700
+ wasm.__externref_table_dealloc(idx);
2701
+ return value;
2702
+ }
2782
2703
 
2783
- exports.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
2784
- throw new Error(getStringFromWasm0(arg0, arg1));
2785
- };
2704
+ let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
2705
+ cachedTextDecoder.decode();
2706
+ function decodeText(ptr, len) {
2707
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
2708
+ }
2786
2709
 
2787
- exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
2788
- // Cast intrinsic for `Ref(String) -> Externref`.
2789
- const ret = getStringFromWasm0(arg0, arg1);
2790
- return ret;
2791
- };
2710
+ const cachedTextEncoder = new TextEncoder();
2792
2711
 
2793
- exports.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
2794
- // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
2795
- const ret = getArrayU8FromWasm0(arg0, arg1);
2796
- return ret;
2797
- };
2712
+ if (!('encodeInto' in cachedTextEncoder)) {
2713
+ cachedTextEncoder.encodeInto = function (arg, view) {
2714
+ const buf = cachedTextEncoder.encode(arg);
2715
+ view.set(buf);
2716
+ return {
2717
+ read: arg.length,
2718
+ written: buf.length
2719
+ };
2720
+ };
2721
+ }
2798
2722
 
2799
- exports.__wbindgen_init_externref_table = function() {
2800
- const table = wasm.__wbindgen_export_2;
2801
- const offset = table.grow(4);
2802
- table.set(0, undefined);
2803
- table.set(offset + 0, undefined);
2804
- table.set(offset + 1, null);
2805
- table.set(offset + 2, true);
2806
- table.set(offset + 3, false);
2807
- ;
2808
- };
2723
+ let WASM_VECTOR_LEN = 0;
2809
2724
 
2810
2725
  const wasmPath = `${__dirname}/fleethub_core_bg.wasm`;
2811
2726
  const wasmBytes = require('fs').readFileSync(wasmPath);
2812
2727
  const wasmModule = new WebAssembly.Module(wasmBytes);
2813
- const wasm = exports.__wasm = new WebAssembly.Instance(wasmModule, imports).exports;
2814
-
2728
+ let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
2729
+ let wasm = wasmInstance.exports;
2815
2730
  wasm.__wbindgen_start();
2816
-