fleethub-core 1.12.18 → 1.12.20

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