fleethub-core 1.12.1 → 1.12.3

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