fleethub-core 0.5.1 → 0.8.0

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