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