ms-toollib 1.4.8 → 1.4.10

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.
Files changed (3) hide show
  1. package/ms_toollib_bg.js +318 -1065
  2. package/ms_toollib_bg.wasm +0 -0
  3. package/package.json +1 -1
package/ms_toollib_bg.js CHANGED
@@ -4,6 +4,26 @@ export function __wbg_set_wasm(val) {
4
4
  }
5
5
 
6
6
 
7
+ const heap = new Array(128).fill(undefined);
8
+
9
+ heap.push(undefined, null, true, false);
10
+
11
+ function getObject(idx) { return heap[idx]; }
12
+
13
+ let heap_next = heap.length;
14
+
15
+ function dropObject(idx) {
16
+ if (idx < 132) return;
17
+ heap[idx] = heap_next;
18
+ heap_next = idx;
19
+ }
20
+
21
+ function takeObject(idx) {
22
+ const ret = getObject(idx);
23
+ dropObject(idx);
24
+ return ret;
25
+ }
26
+
7
27
  const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
8
28
 
9
29
  let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -24,47 +44,15 @@ function getStringFromWasm0(ptr, len) {
24
44
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
25
45
  }
26
46
 
27
- const heap = new Array(128).fill(undefined);
28
-
29
- heap.push(undefined, null, true, false);
30
-
31
- let heap_next = heap.length;
32
-
33
47
  function addHeapObject(obj) {
34
48
  if (heap_next === heap.length) heap.push(heap.length + 1);
35
49
  const idx = heap_next;
36
50
  heap_next = heap[idx];
37
51
 
38
- if (typeof(heap_next) !== 'number') throw new Error('corrupt heap');
39
-
40
52
  heap[idx] = obj;
41
53
  return idx;
42
54
  }
43
55
 
44
- function getObject(idx) { return heap[idx]; }
45
-
46
- function _assertBoolean(n) {
47
- if (typeof(n) !== 'boolean') {
48
- throw new Error('expected a boolean argument');
49
- }
50
- }
51
-
52
- function dropObject(idx) {
53
- if (idx < 132) return;
54
- heap[idx] = heap_next;
55
- heap_next = idx;
56
- }
57
-
58
- function takeObject(idx) {
59
- const ret = getObject(idx);
60
- dropObject(idx);
61
- return ret;
62
- }
63
-
64
- function _assertNum(n) {
65
- if (typeof(n) !== 'number') throw new Error('expected a number argument');
66
- }
67
-
68
56
  let WASM_VECTOR_LEN = 0;
69
57
 
70
58
  const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
@@ -86,8 +74,6 @@ const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
86
74
 
87
75
  function passStringToWasm0(arg, malloc, realloc) {
88
76
 
89
- if (typeof(arg) !== 'string') throw new Error('expected a string argument');
90
-
91
77
  if (realloc === undefined) {
92
78
  const buf = cachedTextEncoder.encode(arg);
93
79
  const ptr = malloc(buf.length, 1) >>> 0;
@@ -116,7 +102,7 @@ function passStringToWasm0(arg, malloc, realloc) {
116
102
  ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
117
103
  const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
118
104
  const ret = encodeString(arg, view);
119
- if (ret.read !== arg.length) throw new Error('failed to pass whole string');
105
+
120
106
  offset += ret.written;
121
107
  }
122
108
 
@@ -178,7 +164,6 @@ export function cal_possibility_onboard(board_json, mine_num) {
178
164
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
179
165
  const ptr0 = passStringToWasm0(board_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
180
166
  const len0 = WASM_VECTOR_LEN;
181
- _assertNum(mine_num);
182
167
  wasm.cal_possibility_onboard(retptr, ptr0, len0, mine_num);
183
168
  var r0 = getInt32Memory0()[retptr / 4 + 0];
184
169
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -204,11 +189,6 @@ export function laymine_number(row, column, mine_num, x0, y0) {
204
189
  let deferred1_1;
205
190
  try {
206
191
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
207
- _assertNum(row);
208
- _assertNum(column);
209
- _assertNum(mine_num);
210
- _assertNum(x0);
211
- _assertNum(y0);
212
192
  wasm.laymine_number(retptr, row, column, mine_num, x0, y0);
213
193
  var r0 = getInt32Memory0()[retptr / 4 + 0];
214
194
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -234,11 +214,6 @@ export function laymine_op_number(row, column, mine_num, x0, y0) {
234
214
  let deferred1_1;
235
215
  try {
236
216
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
237
- _assertNum(row);
238
- _assertNum(column);
239
- _assertNum(mine_num);
240
- _assertNum(x0);
241
- _assertNum(y0);
242
217
  wasm.laymine_op_number(retptr, row, column, mine_num, x0, y0);
243
218
  var r0 = getInt32Memory0()[retptr / 4 + 0];
244
219
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -265,12 +240,6 @@ export function laymine_solvable(row, column, mine_num, x0, y0, max_times) {
265
240
  let deferred1_1;
266
241
  try {
267
242
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
268
- _assertNum(row);
269
- _assertNum(column);
270
- _assertNum(mine_num);
271
- _assertNum(x0);
272
- _assertNum(y0);
273
- _assertNum(max_times);
274
243
  wasm.laymine_solvable(retptr, row, column, mine_num, x0, y0, max_times);
275
244
  var r0 = getInt32Memory0()[retptr / 4 + 0];
276
245
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -283,22 +252,6 @@ export function laymine_solvable(row, column, mine_num, x0, y0, max_times) {
283
252
  }
284
253
  }
285
254
 
286
- function logError(f, args) {
287
- try {
288
- return f.apply(this, args);
289
- } catch (e) {
290
- let error = (function () {
291
- try {
292
- return e instanceof Error ? `${e.message}\n\nStack:\n${e.stack}` : e.toString();
293
- } catch(_) {
294
- return "<failed to stringify thrown value>";
295
- }
296
- }());
297
- console.error("wasm-bindgen: imported JS function that was not marked as `catch` threw an error:", error);
298
- throw e;
299
- }
300
- }
301
-
302
255
  function handleError(f, args) {
303
256
  try {
304
257
  return f.apply(this, args);
@@ -310,10 +263,6 @@ function handleError(f, args) {
310
263
  */
311
264
  export class AvfVideo {
312
265
 
313
- constructor() {
314
- throw new Error('cannot invoke `new` directly');
315
- }
316
-
317
266
  static __wrap(ptr) {
318
267
  ptr = ptr >>> 0;
319
268
  const obj = Object.create(AvfVideo.prototype);
@@ -422,15 +371,11 @@ export class AvfVideo {
422
371
  /**
423
372
  */
424
373
  parse_video() {
425
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
426
- _assertNum(this.__wbg_ptr);
427
374
  wasm.avfvideo_parse_video(this.__wbg_ptr);
428
375
  }
429
376
  /**
430
377
  */
431
378
  analyse() {
432
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
433
- _assertNum(this.__wbg_ptr);
434
379
  wasm.avfvideo_analyse(this.__wbg_ptr);
435
380
  }
436
381
  /**
@@ -438,9 +383,7 @@ export class AvfVideo {
438
383
  */
439
384
  get get_raw_data() {
440
385
  try {
441
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
442
386
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
443
- _assertNum(this.__wbg_ptr);
444
387
  wasm.avfvideo_get_raw_data(retptr, this.__wbg_ptr);
445
388
  var r0 = getInt32Memory0()[retptr / 4 + 0];
446
389
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -456,9 +399,7 @@ export class AvfVideo {
456
399
  */
457
400
  get get_software() {
458
401
  try {
459
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
460
402
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
461
- _assertNum(this.__wbg_ptr);
462
403
  wasm.avfvideo_get_software(retptr, this.__wbg_ptr);
463
404
  var r0 = getInt32Memory0()[retptr / 4 + 0];
464
405
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -473,8 +414,6 @@ export class AvfVideo {
473
414
  * @returns {number}
474
415
  */
475
416
  get get_row() {
476
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
477
- _assertNum(this.__wbg_ptr);
478
417
  const ret = wasm.avfvideo_get_row(this.__wbg_ptr);
479
418
  return ret >>> 0;
480
419
  }
@@ -482,8 +421,6 @@ export class AvfVideo {
482
421
  * @returns {number}
483
422
  */
484
423
  get get_column() {
485
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
486
- _assertNum(this.__wbg_ptr);
487
424
  const ret = wasm.avfvideo_get_column(this.__wbg_ptr);
488
425
  return ret >>> 0;
489
426
  }
@@ -491,8 +428,6 @@ export class AvfVideo {
491
428
  * @returns {number}
492
429
  */
493
430
  get get_level() {
494
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
495
- _assertNum(this.__wbg_ptr);
496
431
  const ret = wasm.avfvideo_get_level(this.__wbg_ptr);
497
432
  return ret;
498
433
  }
@@ -500,8 +435,6 @@ export class AvfVideo {
500
435
  * @returns {number}
501
436
  */
502
437
  get get_mode() {
503
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
504
- _assertNum(this.__wbg_ptr);
505
438
  const ret = wasm.avfvideo_get_mode(this.__wbg_ptr);
506
439
  return ret;
507
440
  }
@@ -509,8 +442,6 @@ export class AvfVideo {
509
442
  * @returns {boolean}
510
443
  */
511
444
  get get_is_completed() {
512
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
513
- _assertNum(this.__wbg_ptr);
514
445
  const ret = wasm.avfvideo_get_is_completed(this.__wbg_ptr);
515
446
  return ret !== 0;
516
447
  }
@@ -518,8 +449,6 @@ export class AvfVideo {
518
449
  * @returns {boolean}
519
450
  */
520
451
  get get_is_official() {
521
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
522
- _assertNum(this.__wbg_ptr);
523
452
  const ret = wasm.avfvideo_get_is_official(this.__wbg_ptr);
524
453
  return ret !== 0;
525
454
  }
@@ -527,8 +456,6 @@ export class AvfVideo {
527
456
  * @returns {boolean}
528
457
  */
529
458
  get get_is_fair() {
530
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
531
- _assertNum(this.__wbg_ptr);
532
459
  const ret = wasm.avfvideo_get_is_fair(this.__wbg_ptr);
533
460
  return ret !== 0;
534
461
  }
@@ -536,8 +463,6 @@ export class AvfVideo {
536
463
  * @returns {number}
537
464
  */
538
465
  get get_mine_num() {
539
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
540
- _assertNum(this.__wbg_ptr);
541
466
  const ret = wasm.avfvideo_get_mine_num(this.__wbg_ptr);
542
467
  return ret >>> 0;
543
468
  }
@@ -546,9 +471,7 @@ export class AvfVideo {
546
471
  */
547
472
  get get_player_identifier() {
548
473
  try {
549
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
550
474
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
551
- _assertNum(this.__wbg_ptr);
552
475
  wasm.avfvideo_get_player_identifier(retptr, this.__wbg_ptr);
553
476
  var r0 = getInt32Memory0()[retptr / 4 + 0];
554
477
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -564,9 +487,7 @@ export class AvfVideo {
564
487
  */
565
488
  get get_race_identifier() {
566
489
  try {
567
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
568
490
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
569
- _assertNum(this.__wbg_ptr);
570
491
  wasm.avfvideo_get_race_identifier(retptr, this.__wbg_ptr);
571
492
  var r0 = getInt32Memory0()[retptr / 4 + 0];
572
493
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -582,9 +503,7 @@ export class AvfVideo {
582
503
  */
583
504
  get get_uniqueness_identifier() {
584
505
  try {
585
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
586
506
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
587
- _assertNum(this.__wbg_ptr);
588
507
  wasm.avfvideo_get_uniqueness_identifier(retptr, this.__wbg_ptr);
589
508
  var r0 = getInt32Memory0()[retptr / 4 + 0];
590
509
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -600,9 +519,7 @@ export class AvfVideo {
600
519
  */
601
520
  get get_country() {
602
521
  try {
603
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
604
522
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
605
- _assertNum(this.__wbg_ptr);
606
523
  wasm.avfvideo_get_country(retptr, this.__wbg_ptr);
607
524
  var r0 = getInt32Memory0()[retptr / 4 + 0];
608
525
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -618,9 +535,7 @@ export class AvfVideo {
618
535
  */
619
536
  get get_device_uuid() {
620
537
  try {
621
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
622
538
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
623
- _assertNum(this.__wbg_ptr);
624
539
  wasm.avfvideo_get_device_uuid(retptr, this.__wbg_ptr);
625
540
  var r0 = getInt32Memory0()[retptr / 4 + 0];
626
541
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -635,8 +550,6 @@ export class AvfVideo {
635
550
  * @returns {number}
636
551
  */
637
552
  get get_bbbv() {
638
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
639
- _assertNum(this.__wbg_ptr);
640
553
  const ret = wasm.avfvideo_get_bbbv(this.__wbg_ptr);
641
554
  return ret >>> 0;
642
555
  }
@@ -645,9 +558,7 @@ export class AvfVideo {
645
558
  */
646
559
  get get_start_time() {
647
560
  try {
648
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
649
561
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
650
- _assertNum(this.__wbg_ptr);
651
562
  wasm.avfvideo_get_start_time(retptr, this.__wbg_ptr);
652
563
  var r0 = getInt32Memory0()[retptr / 4 + 0];
653
564
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -663,9 +574,7 @@ export class AvfVideo {
663
574
  */
664
575
  get get_end_time() {
665
576
  try {
666
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
667
577
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
668
- _assertNum(this.__wbg_ptr);
669
578
  wasm.avfvideo_get_end_time(retptr, this.__wbg_ptr);
670
579
  var r0 = getInt32Memory0()[retptr / 4 + 0];
671
580
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -680,8 +589,6 @@ export class AvfVideo {
680
589
  * @returns {number}
681
590
  */
682
591
  get get_op() {
683
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
684
- _assertNum(this.__wbg_ptr);
685
592
  const ret = wasm.avfvideo_get_op(this.__wbg_ptr);
686
593
  return ret >>> 0;
687
594
  }
@@ -689,8 +596,6 @@ export class AvfVideo {
689
596
  * @returns {number}
690
597
  */
691
598
  get get_isl() {
692
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
693
- _assertNum(this.__wbg_ptr);
694
599
  const ret = wasm.avfvideo_get_isl(this.__wbg_ptr);
695
600
  return ret >>> 0;
696
601
  }
@@ -698,8 +603,6 @@ export class AvfVideo {
698
603
  * @returns {number}
699
604
  */
700
605
  get get_hizi() {
701
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
702
- _assertNum(this.__wbg_ptr);
703
606
  const ret = wasm.avfvideo_get_hizi(this.__wbg_ptr);
704
607
  return ret >>> 0;
705
608
  }
@@ -707,8 +610,6 @@ export class AvfVideo {
707
610
  * @returns {number}
708
611
  */
709
612
  get get_cell0() {
710
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
711
- _assertNum(this.__wbg_ptr);
712
613
  const ret = wasm.avfvideo_get_cell0(this.__wbg_ptr);
713
614
  return ret >>> 0;
714
615
  }
@@ -716,8 +617,6 @@ export class AvfVideo {
716
617
  * @returns {number}
717
618
  */
718
619
  get get_cell1() {
719
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
720
- _assertNum(this.__wbg_ptr);
721
620
  const ret = wasm.avfvideo_get_cell1(this.__wbg_ptr);
722
621
  return ret >>> 0;
723
622
  }
@@ -725,8 +624,6 @@ export class AvfVideo {
725
624
  * @returns {number}
726
625
  */
727
626
  get get_cell2() {
728
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
729
- _assertNum(this.__wbg_ptr);
730
627
  const ret = wasm.avfvideo_get_cell2(this.__wbg_ptr);
731
628
  return ret >>> 0;
732
629
  }
@@ -734,8 +631,6 @@ export class AvfVideo {
734
631
  * @returns {number}
735
632
  */
736
633
  get get_cell3() {
737
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
738
- _assertNum(this.__wbg_ptr);
739
634
  const ret = wasm.avfvideo_get_cell3(this.__wbg_ptr);
740
635
  return ret >>> 0;
741
636
  }
@@ -743,8 +638,6 @@ export class AvfVideo {
743
638
  * @returns {number}
744
639
  */
745
640
  get get_cell4() {
746
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
747
- _assertNum(this.__wbg_ptr);
748
641
  const ret = wasm.avfvideo_get_cell4(this.__wbg_ptr);
749
642
  return ret >>> 0;
750
643
  }
@@ -752,8 +645,6 @@ export class AvfVideo {
752
645
  * @returns {number}
753
646
  */
754
647
  get get_cell5() {
755
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
756
- _assertNum(this.__wbg_ptr);
757
648
  const ret = wasm.avfvideo_get_cell5(this.__wbg_ptr);
758
649
  return ret >>> 0;
759
650
  }
@@ -761,8 +652,6 @@ export class AvfVideo {
761
652
  * @returns {number}
762
653
  */
763
654
  get get_cell6() {
764
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
765
- _assertNum(this.__wbg_ptr);
766
655
  const ret = wasm.avfvideo_get_cell6(this.__wbg_ptr);
767
656
  return ret >>> 0;
768
657
  }
@@ -770,8 +659,6 @@ export class AvfVideo {
770
659
  * @returns {number}
771
660
  */
772
661
  get get_cell7() {
773
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
774
- _assertNum(this.__wbg_ptr);
775
662
  const ret = wasm.avfvideo_get_cell7(this.__wbg_ptr);
776
663
  return ret >>> 0;
777
664
  }
@@ -779,8 +666,6 @@ export class AvfVideo {
779
666
  * @returns {number}
780
667
  */
781
668
  get get_cell8() {
782
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
783
- _assertNum(this.__wbg_ptr);
784
669
  const ret = wasm.avfvideo_get_cell8(this.__wbg_ptr);
785
670
  return ret >>> 0;
786
671
  }
@@ -788,8 +673,6 @@ export class AvfVideo {
788
673
  * @returns {number}
789
674
  */
790
675
  get get_rtime() {
791
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
792
- _assertNum(this.__wbg_ptr);
793
676
  const ret = wasm.avfvideo_get_rtime(this.__wbg_ptr);
794
677
  return ret;
795
678
  }
@@ -797,8 +680,6 @@ export class AvfVideo {
797
680
  * @returns {number}
798
681
  */
799
682
  get get_rtime_ms() {
800
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
801
- _assertNum(this.__wbg_ptr);
802
683
  const ret = wasm.avfvideo_get_rtime_ms(this.__wbg_ptr);
803
684
  return ret >>> 0;
804
685
  }
@@ -806,8 +687,6 @@ export class AvfVideo {
806
687
  * @returns {number}
807
688
  */
808
689
  get get_etime() {
809
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
810
- _assertNum(this.__wbg_ptr);
811
690
  const ret = wasm.avfvideo_get_etime(this.__wbg_ptr);
812
691
  return ret;
813
692
  }
@@ -815,8 +694,6 @@ export class AvfVideo {
815
694
  * @returns {number}
816
695
  */
817
696
  get get_video_start_time() {
818
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
819
- _assertNum(this.__wbg_ptr);
820
697
  const ret = wasm.avfvideo_get_video_start_time(this.__wbg_ptr);
821
698
  return ret;
822
699
  }
@@ -824,8 +701,6 @@ export class AvfVideo {
824
701
  * @returns {number}
825
702
  */
826
703
  get get_video_end_time() {
827
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
828
- _assertNum(this.__wbg_ptr);
829
704
  const ret = wasm.avfvideo_get_video_end_time(this.__wbg_ptr);
830
705
  return ret;
831
706
  }
@@ -833,8 +708,6 @@ export class AvfVideo {
833
708
  * @returns {number}
834
709
  */
835
710
  get get_bbbv_s() {
836
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
837
- _assertNum(this.__wbg_ptr);
838
711
  const ret = wasm.avfvideo_get_bbbv_s(this.__wbg_ptr);
839
712
  return ret;
840
713
  }
@@ -842,8 +715,6 @@ export class AvfVideo {
842
715
  * @returns {number}
843
716
  */
844
717
  get get_stnb() {
845
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
846
- _assertNum(this.__wbg_ptr);
847
718
  const ret = wasm.avfvideo_get_stnb(this.__wbg_ptr);
848
719
  return ret;
849
720
  }
@@ -851,8 +722,6 @@ export class AvfVideo {
851
722
  * @returns {number}
852
723
  */
853
724
  get get_rqp() {
854
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
855
- _assertNum(this.__wbg_ptr);
856
725
  const ret = wasm.avfvideo_get_rqp(this.__wbg_ptr);
857
726
  return ret;
858
727
  }
@@ -860,8 +729,6 @@ export class AvfVideo {
860
729
  * @returns {number}
861
730
  */
862
731
  get get_left() {
863
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
864
- _assertNum(this.__wbg_ptr);
865
732
  const ret = wasm.avfvideo_get_left(this.__wbg_ptr);
866
733
  return ret >>> 0;
867
734
  }
@@ -869,8 +736,6 @@ export class AvfVideo {
869
736
  * @returns {number}
870
737
  */
871
738
  get get_right() {
872
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
873
- _assertNum(this.__wbg_ptr);
874
739
  const ret = wasm.avfvideo_get_right(this.__wbg_ptr);
875
740
  return ret >>> 0;
876
741
  }
@@ -878,8 +743,6 @@ export class AvfVideo {
878
743
  * @returns {number}
879
744
  */
880
745
  get get_double() {
881
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
882
- _assertNum(this.__wbg_ptr);
883
746
  const ret = wasm.avfvideo_get_double(this.__wbg_ptr);
884
747
  return ret >>> 0;
885
748
  }
@@ -887,8 +750,6 @@ export class AvfVideo {
887
750
  * @returns {number}
888
751
  */
889
752
  get get_cl() {
890
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
891
- _assertNum(this.__wbg_ptr);
892
753
  const ret = wasm.avfvideo_get_cl(this.__wbg_ptr);
893
754
  return ret >>> 0;
894
755
  }
@@ -896,8 +757,6 @@ export class AvfVideo {
896
757
  * @returns {number}
897
758
  */
898
759
  get get_flag() {
899
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
900
- _assertNum(this.__wbg_ptr);
901
760
  const ret = wasm.avfvideo_get_flag(this.__wbg_ptr);
902
761
  return ret >>> 0;
903
762
  }
@@ -905,8 +764,6 @@ export class AvfVideo {
905
764
  * @returns {number}
906
765
  */
907
766
  get get_bbbv_solved() {
908
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
909
- _assertNum(this.__wbg_ptr);
910
767
  const ret = wasm.avfvideo_get_bbbv_solved(this.__wbg_ptr);
911
768
  return ret >>> 0;
912
769
  }
@@ -914,8 +771,6 @@ export class AvfVideo {
914
771
  * @returns {number}
915
772
  */
916
773
  get get_ce() {
917
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
918
- _assertNum(this.__wbg_ptr);
919
774
  const ret = wasm.avfvideo_get_ce(this.__wbg_ptr);
920
775
  return ret >>> 0;
921
776
  }
@@ -923,8 +778,6 @@ export class AvfVideo {
923
778
  * @returns {number}
924
779
  */
925
780
  get get_left_s() {
926
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
927
- _assertNum(this.__wbg_ptr);
928
781
  const ret = wasm.avfvideo_get_left_s(this.__wbg_ptr);
929
782
  return ret;
930
783
  }
@@ -932,8 +785,6 @@ export class AvfVideo {
932
785
  * @returns {number}
933
786
  */
934
787
  get get_right_s() {
935
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
936
- _assertNum(this.__wbg_ptr);
937
788
  const ret = wasm.avfvideo_get_right_s(this.__wbg_ptr);
938
789
  return ret;
939
790
  }
@@ -941,8 +792,6 @@ export class AvfVideo {
941
792
  * @returns {number}
942
793
  */
943
794
  get get_double_s() {
944
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
945
- _assertNum(this.__wbg_ptr);
946
795
  const ret = wasm.avfvideo_get_double_s(this.__wbg_ptr);
947
796
  return ret;
948
797
  }
@@ -950,8 +799,6 @@ export class AvfVideo {
950
799
  * @returns {number}
951
800
  */
952
801
  get get_cl_s() {
953
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
954
- _assertNum(this.__wbg_ptr);
955
802
  const ret = wasm.avfvideo_get_cl_s(this.__wbg_ptr);
956
803
  return ret;
957
804
  }
@@ -959,8 +806,6 @@ export class AvfVideo {
959
806
  * @returns {number}
960
807
  */
961
808
  get get_flag_s() {
962
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
963
- _assertNum(this.__wbg_ptr);
964
809
  const ret = wasm.avfvideo_get_flag_s(this.__wbg_ptr);
965
810
  return ret;
966
811
  }
@@ -968,8 +813,6 @@ export class AvfVideo {
968
813
  * @returns {number}
969
814
  */
970
815
  get get_path() {
971
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
972
- _assertNum(this.__wbg_ptr);
973
816
  const ret = wasm.avfvideo_get_path(this.__wbg_ptr);
974
817
  return ret;
975
818
  }
@@ -977,8 +820,6 @@ export class AvfVideo {
977
820
  * @returns {number}
978
821
  */
979
822
  get get_ce_s() {
980
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
981
- _assertNum(this.__wbg_ptr);
982
823
  const ret = wasm.avfvideo_get_ce_s(this.__wbg_ptr);
983
824
  return ret;
984
825
  }
@@ -986,8 +827,6 @@ export class AvfVideo {
986
827
  * @returns {number}
987
828
  */
988
829
  get get_ioe() {
989
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
990
- _assertNum(this.__wbg_ptr);
991
830
  const ret = wasm.avfvideo_get_ioe(this.__wbg_ptr);
992
831
  return ret;
993
832
  }
@@ -995,8 +834,6 @@ export class AvfVideo {
995
834
  * @returns {number}
996
835
  */
997
836
  get get_thrp() {
998
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
999
- _assertNum(this.__wbg_ptr);
1000
837
  const ret = wasm.avfvideo_get_thrp(this.__wbg_ptr);
1001
838
  return ret;
1002
839
  }
@@ -1004,8 +841,6 @@ export class AvfVideo {
1004
841
  * @returns {number}
1005
842
  */
1006
843
  get get_corr() {
1007
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1008
- _assertNum(this.__wbg_ptr);
1009
844
  const ret = wasm.avfvideo_get_corr(this.__wbg_ptr);
1010
845
  return ret;
1011
846
  }
@@ -1013,8 +848,6 @@ export class AvfVideo {
1013
848
  * @returns {number}
1014
849
  */
1015
850
  get get_events_len() {
1016
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1017
- _assertNum(this.__wbg_ptr);
1018
851
  const ret = wasm.avfvideo_get_events_len(this.__wbg_ptr);
1019
852
  return ret >>> 0;
1020
853
  }
@@ -1023,9 +856,6 @@ export class AvfVideo {
1023
856
  * @returns {number}
1024
857
  */
1025
858
  events_time(index) {
1026
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1027
- _assertNum(this.__wbg_ptr);
1028
- _assertNum(index);
1029
859
  const ret = wasm.avfvideo_events_time(this.__wbg_ptr, index);
1030
860
  return ret;
1031
861
  }
@@ -1037,10 +867,7 @@ export class AvfVideo {
1037
867
  let deferred1_0;
1038
868
  let deferred1_1;
1039
869
  try {
1040
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1041
870
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1042
- _assertNum(this.__wbg_ptr);
1043
- _assertNum(index);
1044
871
  wasm.avfvideo_events_mouse(retptr, this.__wbg_ptr, index);
1045
872
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1046
873
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -1057,9 +884,6 @@ export class AvfVideo {
1057
884
  * @returns {number}
1058
885
  */
1059
886
  events_x(index) {
1060
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1061
- _assertNum(this.__wbg_ptr);
1062
- _assertNum(index);
1063
887
  const ret = wasm.avfvideo_events_x(this.__wbg_ptr, index);
1064
888
  return ret;
1065
889
  }
@@ -1068,9 +892,6 @@ export class AvfVideo {
1068
892
  * @returns {number}
1069
893
  */
1070
894
  events_y(index) {
1071
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1072
- _assertNum(this.__wbg_ptr);
1073
- _assertNum(index);
1074
895
  const ret = wasm.avfvideo_events_y(this.__wbg_ptr, index);
1075
896
  return ret;
1076
897
  }
@@ -1079,9 +900,6 @@ export class AvfVideo {
1079
900
  * @returns {number}
1080
901
  */
1081
902
  events_useful_level(index) {
1082
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1083
- _assertNum(this.__wbg_ptr);
1084
- _assertNum(index);
1085
903
  const ret = wasm.avfvideo_events_useful_level(this.__wbg_ptr, index);
1086
904
  return ret;
1087
905
  }
@@ -1090,9 +908,6 @@ export class AvfVideo {
1090
908
  * @returns {number}
1091
909
  */
1092
910
  events_mouse_state(index) {
1093
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1094
- _assertNum(this.__wbg_ptr);
1095
- _assertNum(index);
1096
911
  const ret = wasm.avfvideo_events_mouse_state(this.__wbg_ptr, index);
1097
912
  return ret >>> 0;
1098
913
  }
@@ -1100,8 +915,6 @@ export class AvfVideo {
1100
915
  * @returns {number}
1101
916
  */
1102
917
  get get_current_event_id() {
1103
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1104
- _assertNum(this.__wbg_ptr);
1105
918
  const ret = wasm.avfvideo_get_current_event_id(this.__wbg_ptr);
1106
919
  return ret >>> 0;
1107
920
  }
@@ -1109,9 +922,6 @@ export class AvfVideo {
1109
922
  * @param {number} id
1110
923
  */
1111
924
  set current_event_id(id) {
1112
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1113
- _assertNum(this.__wbg_ptr);
1114
- _assertNum(id);
1115
925
  wasm.avfvideo_set_current_event_id(this.__wbg_ptr, id);
1116
926
  }
1117
927
  /**
@@ -1121,9 +931,7 @@ export class AvfVideo {
1121
931
  let deferred1_0;
1122
932
  let deferred1_1;
1123
933
  try {
1124
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1125
934
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1126
- _assertNum(this.__wbg_ptr);
1127
935
  wasm.avfvideo_get_game_board(retptr, this.__wbg_ptr);
1128
936
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1129
937
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -1142,9 +950,7 @@ export class AvfVideo {
1142
950
  let deferred1_0;
1143
951
  let deferred1_1;
1144
952
  try {
1145
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1146
953
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1147
- _assertNum(this.__wbg_ptr);
1148
954
  wasm.avfvideo_get_game_board_poss(retptr, this.__wbg_ptr);
1149
955
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1150
956
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -1160,8 +966,6 @@ export class AvfVideo {
1160
966
  * @returns {number}
1161
967
  */
1162
968
  get get_mouse_state() {
1163
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1164
- _assertNum(this.__wbg_ptr);
1165
969
  const ret = wasm.avfvideo_get_mouse_state(this.__wbg_ptr);
1166
970
  return ret >>> 0;
1167
971
  }
@@ -1170,8 +974,6 @@ export class AvfVideo {
1170
974
  * @returns {number}
1171
975
  */
1172
976
  get get_game_board_state() {
1173
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1174
- _assertNum(this.__wbg_ptr);
1175
977
  const ret = wasm.avfvideo_get_game_board_state(this.__wbg_ptr);
1176
978
  return ret >>> 0;
1177
979
  }
@@ -1180,8 +982,6 @@ export class AvfVideo {
1180
982
  * @returns {CursorPos}
1181
983
  */
1182
984
  get get_x_y() {
1183
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1184
- _assertNum(this.__wbg_ptr);
1185
985
  const ret = wasm.avfvideo_get_x_y(this.__wbg_ptr);
1186
986
  return CursorPos.__wrap(ret);
1187
987
  }
@@ -1190,9 +990,7 @@ export class AvfVideo {
1190
990
  */
1191
991
  get get_checksum() {
1192
992
  try {
1193
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1194
993
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1195
- _assertNum(this.__wbg_ptr);
1196
994
  wasm.avfvideo_get_checksum(retptr, this.__wbg_ptr);
1197
995
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1198
996
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -1207,8 +1005,6 @@ export class AvfVideo {
1207
1005
  * @returns {number}
1208
1006
  */
1209
1007
  get get_pix_size() {
1210
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1211
- _assertNum(this.__wbg_ptr);
1212
1008
  const ret = wasm.avfvideo_get_pix_size(this.__wbg_ptr);
1213
1009
  return ret;
1214
1010
  }
@@ -1216,16 +1012,12 @@ export class AvfVideo {
1216
1012
  * @param {number} time
1217
1013
  */
1218
1014
  set current_time(time) {
1219
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1220
- _assertNum(this.__wbg_ptr);
1221
1015
  wasm.avfvideo_set_current_time(this.__wbg_ptr, time);
1222
1016
  }
1223
1017
  /**
1224
1018
  * @returns {number}
1225
1019
  */
1226
1020
  is_valid() {
1227
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1228
- _assertNum(this.__wbg_ptr);
1229
1021
  const ret = wasm.avfvideo_is_valid(this.__wbg_ptr);
1230
1022
  return ret;
1231
1023
  }
@@ -1234,10 +1026,6 @@ export class AvfVideo {
1234
1026
  */
1235
1027
  export class CursorPos {
1236
1028
 
1237
- constructor() {
1238
- throw new Error('cannot invoke `new` directly');
1239
- }
1240
-
1241
1029
  static __wrap(ptr) {
1242
1030
  ptr = ptr >>> 0;
1243
1031
  const obj = Object.create(CursorPos.prototype);
@@ -1261,8 +1049,6 @@ export class CursorPos {
1261
1049
  * @returns {number}
1262
1050
  */
1263
1051
  get 0() {
1264
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1265
- _assertNum(this.__wbg_ptr);
1266
1052
  const ret = wasm.__wbg_get_cursorpos_0(this.__wbg_ptr);
1267
1053
  return ret;
1268
1054
  }
@@ -1270,17 +1056,12 @@ export class CursorPos {
1270
1056
  * @param {number} arg0
1271
1057
  */
1272
1058
  set 0(arg0) {
1273
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1274
- _assertNum(this.__wbg_ptr);
1275
- _assertNum(arg0);
1276
1059
  wasm.__wbg_set_cursorpos_0(this.__wbg_ptr, arg0);
1277
1060
  }
1278
1061
  /**
1279
1062
  * @returns {number}
1280
1063
  */
1281
1064
  get 1() {
1282
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1283
- _assertNum(this.__wbg_ptr);
1284
1065
  const ret = wasm.__wbg_get_cursorpos_1(this.__wbg_ptr);
1285
1066
  return ret;
1286
1067
  }
@@ -1288,9 +1069,6 @@ export class CursorPos {
1288
1069
  * @param {number} arg0
1289
1070
  */
1290
1071
  set 1(arg0) {
1291
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1292
- _assertNum(this.__wbg_ptr);
1293
- _assertNum(arg0);
1294
1072
  wasm.__wbg_set_cursorpos_1(this.__wbg_ptr, arg0);
1295
1073
  }
1296
1074
  }
@@ -1298,10 +1076,6 @@ export class CursorPos {
1298
1076
  */
1299
1077
  export class EvfVideo {
1300
1078
 
1301
- constructor() {
1302
- throw new Error('cannot invoke `new` directly');
1303
- }
1304
-
1305
1079
  static __wrap(ptr) {
1306
1080
  ptr = ptr >>> 0;
1307
1081
  const obj = Object.create(EvfVideo.prototype);
@@ -1410,26 +1184,20 @@ export class EvfVideo {
1410
1184
  /**
1411
1185
  */
1412
1186
  parse_video() {
1413
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1414
- _assertNum(this.__wbg_ptr);
1415
1187
  wasm.evfvideo_parse_video(this.__wbg_ptr);
1416
1188
  }
1417
1189
  /**
1418
1190
  */
1419
1191
  analyse() {
1420
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1421
- _assertNum(this.__wbg_ptr);
1422
- wasm.evfvideo_analyse(this.__wbg_ptr);
1192
+ wasm.avfvideo_analyse(this.__wbg_ptr);
1423
1193
  }
1424
1194
  /**
1425
1195
  * @returns {Uint8Array}
1426
1196
  */
1427
1197
  get get_raw_data() {
1428
1198
  try {
1429
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1430
1199
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1431
- _assertNum(this.__wbg_ptr);
1432
- wasm.evfvideo_get_raw_data(retptr, this.__wbg_ptr);
1200
+ wasm.avfvideo_get_raw_data(retptr, this.__wbg_ptr);
1433
1201
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1434
1202
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1435
1203
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1444,10 +1212,8 @@ export class EvfVideo {
1444
1212
  */
1445
1213
  get get_software() {
1446
1214
  try {
1447
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1448
1215
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1449
- _assertNum(this.__wbg_ptr);
1450
- wasm.evfvideo_get_software(retptr, this.__wbg_ptr);
1216
+ wasm.avfvideo_get_software(retptr, this.__wbg_ptr);
1451
1217
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1452
1218
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1453
1219
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1461,72 +1227,56 @@ export class EvfVideo {
1461
1227
  * @returns {number}
1462
1228
  */
1463
1229
  get get_row() {
1464
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1465
- _assertNum(this.__wbg_ptr);
1466
- const ret = wasm.evfvideo_get_row(this.__wbg_ptr);
1230
+ const ret = wasm.avfvideo_get_row(this.__wbg_ptr);
1467
1231
  return ret >>> 0;
1468
1232
  }
1469
1233
  /**
1470
1234
  * @returns {number}
1471
1235
  */
1472
1236
  get get_column() {
1473
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1474
- _assertNum(this.__wbg_ptr);
1475
- const ret = wasm.evfvideo_get_column(this.__wbg_ptr);
1237
+ const ret = wasm.avfvideo_get_column(this.__wbg_ptr);
1476
1238
  return ret >>> 0;
1477
1239
  }
1478
1240
  /**
1479
1241
  * @returns {number}
1480
1242
  */
1481
1243
  get get_level() {
1482
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1483
- _assertNum(this.__wbg_ptr);
1484
- const ret = wasm.evfvideo_get_level(this.__wbg_ptr);
1244
+ const ret = wasm.avfvideo_get_level(this.__wbg_ptr);
1485
1245
  return ret;
1486
1246
  }
1487
1247
  /**
1488
1248
  * @returns {number}
1489
1249
  */
1490
1250
  get get_mode() {
1491
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1492
- _assertNum(this.__wbg_ptr);
1493
- const ret = wasm.evfvideo_get_mode(this.__wbg_ptr);
1251
+ const ret = wasm.avfvideo_get_mode(this.__wbg_ptr);
1494
1252
  return ret;
1495
1253
  }
1496
1254
  /**
1497
1255
  * @returns {boolean}
1498
1256
  */
1499
1257
  get get_is_completed() {
1500
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1501
- _assertNum(this.__wbg_ptr);
1502
- const ret = wasm.evfvideo_get_is_completed(this.__wbg_ptr);
1258
+ const ret = wasm.avfvideo_get_is_completed(this.__wbg_ptr);
1503
1259
  return ret !== 0;
1504
1260
  }
1505
1261
  /**
1506
1262
  * @returns {boolean}
1507
1263
  */
1508
1264
  get get_is_official() {
1509
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1510
- _assertNum(this.__wbg_ptr);
1511
- const ret = wasm.evfvideo_get_is_official(this.__wbg_ptr);
1265
+ const ret = wasm.avfvideo_get_is_official(this.__wbg_ptr);
1512
1266
  return ret !== 0;
1513
1267
  }
1514
1268
  /**
1515
1269
  * @returns {boolean}
1516
1270
  */
1517
1271
  get get_is_fair() {
1518
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1519
- _assertNum(this.__wbg_ptr);
1520
- const ret = wasm.evfvideo_get_is_fair(this.__wbg_ptr);
1272
+ const ret = wasm.avfvideo_get_is_fair(this.__wbg_ptr);
1521
1273
  return ret !== 0;
1522
1274
  }
1523
1275
  /**
1524
1276
  * @returns {number}
1525
1277
  */
1526
1278
  get get_mine_num() {
1527
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1528
- _assertNum(this.__wbg_ptr);
1529
- const ret = wasm.evfvideo_get_mine_num(this.__wbg_ptr);
1279
+ const ret = wasm.avfvideo_get_mine_num(this.__wbg_ptr);
1530
1280
  return ret >>> 0;
1531
1281
  }
1532
1282
  /**
@@ -1534,10 +1284,8 @@ export class EvfVideo {
1534
1284
  */
1535
1285
  get get_player_identifier() {
1536
1286
  try {
1537
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1538
1287
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1539
- _assertNum(this.__wbg_ptr);
1540
- wasm.evfvideo_get_player_identifier(retptr, this.__wbg_ptr);
1288
+ wasm.avfvideo_get_player_identifier(retptr, this.__wbg_ptr);
1541
1289
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1542
1290
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1543
1291
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1552,10 +1300,8 @@ export class EvfVideo {
1552
1300
  */
1553
1301
  get get_race_identifier() {
1554
1302
  try {
1555
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1556
1303
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1557
- _assertNum(this.__wbg_ptr);
1558
- wasm.evfvideo_get_race_identifier(retptr, this.__wbg_ptr);
1304
+ wasm.avfvideo_get_race_identifier(retptr, this.__wbg_ptr);
1559
1305
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1560
1306
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1561
1307
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1570,10 +1316,8 @@ export class EvfVideo {
1570
1316
  */
1571
1317
  get get_uniqueness_identifier() {
1572
1318
  try {
1573
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1574
1319
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1575
- _assertNum(this.__wbg_ptr);
1576
- wasm.evfvideo_get_uniqueness_identifier(retptr, this.__wbg_ptr);
1320
+ wasm.avfvideo_get_uniqueness_identifier(retptr, this.__wbg_ptr);
1577
1321
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1578
1322
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1579
1323
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1588,10 +1332,8 @@ export class EvfVideo {
1588
1332
  */
1589
1333
  get get_country() {
1590
1334
  try {
1591
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1592
1335
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1593
- _assertNum(this.__wbg_ptr);
1594
- wasm.evfvideo_get_country(retptr, this.__wbg_ptr);
1336
+ wasm.avfvideo_get_country(retptr, this.__wbg_ptr);
1595
1337
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1596
1338
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1597
1339
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1606,10 +1348,8 @@ export class EvfVideo {
1606
1348
  */
1607
1349
  get get_device_uuid() {
1608
1350
  try {
1609
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1610
1351
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1611
- _assertNum(this.__wbg_ptr);
1612
- wasm.evfvideo_get_device_uuid(retptr, this.__wbg_ptr);
1352
+ wasm.avfvideo_get_device_uuid(retptr, this.__wbg_ptr);
1613
1353
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1614
1354
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1615
1355
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1623,9 +1363,7 @@ export class EvfVideo {
1623
1363
  * @returns {number}
1624
1364
  */
1625
1365
  get get_bbbv() {
1626
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1627
- _assertNum(this.__wbg_ptr);
1628
- const ret = wasm.evfvideo_get_bbbv(this.__wbg_ptr);
1366
+ const ret = wasm.avfvideo_get_bbbv(this.__wbg_ptr);
1629
1367
  return ret >>> 0;
1630
1368
  }
1631
1369
  /**
@@ -1633,10 +1371,8 @@ export class EvfVideo {
1633
1371
  */
1634
1372
  get get_start_time() {
1635
1373
  try {
1636
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1637
1374
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1638
- _assertNum(this.__wbg_ptr);
1639
- wasm.evfvideo_get_start_time(retptr, this.__wbg_ptr);
1375
+ wasm.avfvideo_get_start_time(retptr, this.__wbg_ptr);
1640
1376
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1641
1377
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1642
1378
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1651,10 +1387,8 @@ export class EvfVideo {
1651
1387
  */
1652
1388
  get get_end_time() {
1653
1389
  try {
1654
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1655
1390
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1656
- _assertNum(this.__wbg_ptr);
1657
- wasm.evfvideo_get_end_time(retptr, this.__wbg_ptr);
1391
+ wasm.avfvideo_get_end_time(retptr, this.__wbg_ptr);
1658
1392
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1659
1393
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1660
1394
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1668,342 +1402,266 @@ export class EvfVideo {
1668
1402
  * @returns {number}
1669
1403
  */
1670
1404
  get get_op() {
1671
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1672
- _assertNum(this.__wbg_ptr);
1673
- const ret = wasm.evfvideo_get_op(this.__wbg_ptr);
1405
+ const ret = wasm.avfvideo_get_op(this.__wbg_ptr);
1674
1406
  return ret >>> 0;
1675
1407
  }
1676
1408
  /**
1677
1409
  * @returns {number}
1678
1410
  */
1679
1411
  get get_isl() {
1680
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1681
- _assertNum(this.__wbg_ptr);
1682
- const ret = wasm.evfvideo_get_isl(this.__wbg_ptr);
1412
+ const ret = wasm.avfvideo_get_isl(this.__wbg_ptr);
1683
1413
  return ret >>> 0;
1684
1414
  }
1685
1415
  /**
1686
1416
  * @returns {number}
1687
1417
  */
1688
1418
  get get_hizi() {
1689
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1690
- _assertNum(this.__wbg_ptr);
1691
- const ret = wasm.evfvideo_get_hizi(this.__wbg_ptr);
1419
+ const ret = wasm.avfvideo_get_hizi(this.__wbg_ptr);
1692
1420
  return ret >>> 0;
1693
1421
  }
1694
1422
  /**
1695
1423
  * @returns {number}
1696
1424
  */
1697
1425
  get get_cell0() {
1698
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1699
- _assertNum(this.__wbg_ptr);
1700
- const ret = wasm.evfvideo_get_cell0(this.__wbg_ptr);
1426
+ const ret = wasm.avfvideo_get_cell0(this.__wbg_ptr);
1701
1427
  return ret >>> 0;
1702
1428
  }
1703
1429
  /**
1704
1430
  * @returns {number}
1705
1431
  */
1706
1432
  get get_cell1() {
1707
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1708
- _assertNum(this.__wbg_ptr);
1709
- const ret = wasm.evfvideo_get_cell1(this.__wbg_ptr);
1433
+ const ret = wasm.avfvideo_get_cell1(this.__wbg_ptr);
1710
1434
  return ret >>> 0;
1711
1435
  }
1712
1436
  /**
1713
1437
  * @returns {number}
1714
1438
  */
1715
1439
  get get_cell2() {
1716
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1717
- _assertNum(this.__wbg_ptr);
1718
- const ret = wasm.evfvideo_get_cell2(this.__wbg_ptr);
1440
+ const ret = wasm.avfvideo_get_cell2(this.__wbg_ptr);
1719
1441
  return ret >>> 0;
1720
1442
  }
1721
1443
  /**
1722
1444
  * @returns {number}
1723
1445
  */
1724
1446
  get get_cell3() {
1725
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1726
- _assertNum(this.__wbg_ptr);
1727
- const ret = wasm.evfvideo_get_cell3(this.__wbg_ptr);
1447
+ const ret = wasm.avfvideo_get_cell3(this.__wbg_ptr);
1728
1448
  return ret >>> 0;
1729
1449
  }
1730
1450
  /**
1731
1451
  * @returns {number}
1732
1452
  */
1733
1453
  get get_cell4() {
1734
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1735
- _assertNum(this.__wbg_ptr);
1736
- const ret = wasm.evfvideo_get_cell4(this.__wbg_ptr);
1454
+ const ret = wasm.avfvideo_get_cell4(this.__wbg_ptr);
1737
1455
  return ret >>> 0;
1738
1456
  }
1739
1457
  /**
1740
1458
  * @returns {number}
1741
1459
  */
1742
1460
  get get_cell5() {
1743
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1744
- _assertNum(this.__wbg_ptr);
1745
- const ret = wasm.evfvideo_get_cell5(this.__wbg_ptr);
1461
+ const ret = wasm.avfvideo_get_cell5(this.__wbg_ptr);
1746
1462
  return ret >>> 0;
1747
1463
  }
1748
1464
  /**
1749
1465
  * @returns {number}
1750
1466
  */
1751
1467
  get get_cell6() {
1752
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1753
- _assertNum(this.__wbg_ptr);
1754
- const ret = wasm.evfvideo_get_cell6(this.__wbg_ptr);
1468
+ const ret = wasm.avfvideo_get_cell6(this.__wbg_ptr);
1755
1469
  return ret >>> 0;
1756
1470
  }
1757
1471
  /**
1758
1472
  * @returns {number}
1759
1473
  */
1760
1474
  get get_cell7() {
1761
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1762
- _assertNum(this.__wbg_ptr);
1763
- const ret = wasm.evfvideo_get_cell7(this.__wbg_ptr);
1475
+ const ret = wasm.avfvideo_get_cell7(this.__wbg_ptr);
1764
1476
  return ret >>> 0;
1765
1477
  }
1766
1478
  /**
1767
1479
  * @returns {number}
1768
1480
  */
1769
1481
  get get_cell8() {
1770
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1771
- _assertNum(this.__wbg_ptr);
1772
- const ret = wasm.evfvideo_get_cell8(this.__wbg_ptr);
1482
+ const ret = wasm.avfvideo_get_cell8(this.__wbg_ptr);
1773
1483
  return ret >>> 0;
1774
1484
  }
1775
1485
  /**
1776
1486
  * @returns {number}
1777
1487
  */
1778
1488
  get get_rtime() {
1779
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1780
- _assertNum(this.__wbg_ptr);
1781
- const ret = wasm.evfvideo_get_rtime(this.__wbg_ptr);
1489
+ const ret = wasm.avfvideo_get_rtime(this.__wbg_ptr);
1782
1490
  return ret;
1783
1491
  }
1784
1492
  /**
1785
1493
  * @returns {number}
1786
1494
  */
1787
1495
  get get_rtime_ms() {
1788
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1789
- _assertNum(this.__wbg_ptr);
1790
- const ret = wasm.evfvideo_get_rtime_ms(this.__wbg_ptr);
1496
+ const ret = wasm.avfvideo_get_rtime_ms(this.__wbg_ptr);
1791
1497
  return ret >>> 0;
1792
1498
  }
1793
1499
  /**
1794
1500
  * @returns {number}
1795
1501
  */
1796
1502
  get get_etime() {
1797
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1798
- _assertNum(this.__wbg_ptr);
1799
- const ret = wasm.evfvideo_get_etime(this.__wbg_ptr);
1503
+ const ret = wasm.avfvideo_get_etime(this.__wbg_ptr);
1800
1504
  return ret;
1801
1505
  }
1802
1506
  /**
1803
1507
  * @returns {number}
1804
1508
  */
1805
1509
  get get_video_start_time() {
1806
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1807
- _assertNum(this.__wbg_ptr);
1808
- const ret = wasm.evfvideo_get_video_start_time(this.__wbg_ptr);
1510
+ const ret = wasm.avfvideo_get_video_start_time(this.__wbg_ptr);
1809
1511
  return ret;
1810
1512
  }
1811
1513
  /**
1812
1514
  * @returns {number}
1813
1515
  */
1814
1516
  get get_video_end_time() {
1815
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1816
- _assertNum(this.__wbg_ptr);
1817
- const ret = wasm.evfvideo_get_video_end_time(this.__wbg_ptr);
1517
+ const ret = wasm.avfvideo_get_video_end_time(this.__wbg_ptr);
1818
1518
  return ret;
1819
1519
  }
1820
1520
  /**
1821
1521
  * @returns {number}
1822
1522
  */
1823
1523
  get get_bbbv_s() {
1824
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1825
- _assertNum(this.__wbg_ptr);
1826
- const ret = wasm.evfvideo_get_bbbv_s(this.__wbg_ptr);
1524
+ const ret = wasm.avfvideo_get_bbbv_s(this.__wbg_ptr);
1827
1525
  return ret;
1828
1526
  }
1829
1527
  /**
1830
1528
  * @returns {number}
1831
1529
  */
1832
1530
  get get_stnb() {
1833
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1834
- _assertNum(this.__wbg_ptr);
1835
- const ret = wasm.evfvideo_get_stnb(this.__wbg_ptr);
1531
+ const ret = wasm.avfvideo_get_stnb(this.__wbg_ptr);
1836
1532
  return ret;
1837
1533
  }
1838
1534
  /**
1839
1535
  * @returns {number}
1840
1536
  */
1841
1537
  get get_rqp() {
1842
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1843
- _assertNum(this.__wbg_ptr);
1844
- const ret = wasm.evfvideo_get_rqp(this.__wbg_ptr);
1538
+ const ret = wasm.avfvideo_get_rqp(this.__wbg_ptr);
1845
1539
  return ret;
1846
1540
  }
1847
1541
  /**
1848
1542
  * @returns {number}
1849
1543
  */
1850
1544
  get get_left() {
1851
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1852
- _assertNum(this.__wbg_ptr);
1853
- const ret = wasm.evfvideo_get_left(this.__wbg_ptr);
1545
+ const ret = wasm.avfvideo_get_left(this.__wbg_ptr);
1854
1546
  return ret >>> 0;
1855
1547
  }
1856
1548
  /**
1857
1549
  * @returns {number}
1858
1550
  */
1859
1551
  get get_right() {
1860
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1861
- _assertNum(this.__wbg_ptr);
1862
- const ret = wasm.evfvideo_get_right(this.__wbg_ptr);
1552
+ const ret = wasm.avfvideo_get_right(this.__wbg_ptr);
1863
1553
  return ret >>> 0;
1864
1554
  }
1865
1555
  /**
1866
1556
  * @returns {number}
1867
1557
  */
1868
1558
  get get_double() {
1869
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1870
- _assertNum(this.__wbg_ptr);
1871
- const ret = wasm.evfvideo_get_double(this.__wbg_ptr);
1559
+ const ret = wasm.avfvideo_get_double(this.__wbg_ptr);
1872
1560
  return ret >>> 0;
1873
1561
  }
1874
1562
  /**
1875
1563
  * @returns {number}
1876
1564
  */
1877
1565
  get get_cl() {
1878
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1879
- _assertNum(this.__wbg_ptr);
1880
- const ret = wasm.evfvideo_get_cl(this.__wbg_ptr);
1566
+ const ret = wasm.avfvideo_get_cl(this.__wbg_ptr);
1881
1567
  return ret >>> 0;
1882
1568
  }
1883
1569
  /**
1884
1570
  * @returns {number}
1885
1571
  */
1886
1572
  get get_flag() {
1887
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1888
- _assertNum(this.__wbg_ptr);
1889
- const ret = wasm.evfvideo_get_flag(this.__wbg_ptr);
1573
+ const ret = wasm.avfvideo_get_flag(this.__wbg_ptr);
1890
1574
  return ret >>> 0;
1891
1575
  }
1892
1576
  /**
1893
1577
  * @returns {number}
1894
1578
  */
1895
1579
  get get_bbbv_solved() {
1896
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1897
- _assertNum(this.__wbg_ptr);
1898
- const ret = wasm.evfvideo_get_bbbv_solved(this.__wbg_ptr);
1580
+ const ret = wasm.avfvideo_get_bbbv_solved(this.__wbg_ptr);
1899
1581
  return ret >>> 0;
1900
1582
  }
1901
1583
  /**
1902
1584
  * @returns {number}
1903
1585
  */
1904
1586
  get get_ce() {
1905
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1906
- _assertNum(this.__wbg_ptr);
1907
- const ret = wasm.evfvideo_get_ce(this.__wbg_ptr);
1587
+ const ret = wasm.avfvideo_get_ce(this.__wbg_ptr);
1908
1588
  return ret >>> 0;
1909
1589
  }
1910
1590
  /**
1911
1591
  * @returns {number}
1912
1592
  */
1913
1593
  get get_left_s() {
1914
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1915
- _assertNum(this.__wbg_ptr);
1916
- const ret = wasm.evfvideo_get_left_s(this.__wbg_ptr);
1594
+ const ret = wasm.avfvideo_get_left_s(this.__wbg_ptr);
1917
1595
  return ret;
1918
1596
  }
1919
1597
  /**
1920
1598
  * @returns {number}
1921
1599
  */
1922
1600
  get get_right_s() {
1923
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1924
- _assertNum(this.__wbg_ptr);
1925
- const ret = wasm.evfvideo_get_right_s(this.__wbg_ptr);
1601
+ const ret = wasm.avfvideo_get_right_s(this.__wbg_ptr);
1926
1602
  return ret;
1927
1603
  }
1928
1604
  /**
1929
1605
  * @returns {number}
1930
1606
  */
1931
1607
  get get_double_s() {
1932
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1933
- _assertNum(this.__wbg_ptr);
1934
- const ret = wasm.evfvideo_get_double_s(this.__wbg_ptr);
1608
+ const ret = wasm.avfvideo_get_double_s(this.__wbg_ptr);
1935
1609
  return ret;
1936
1610
  }
1937
1611
  /**
1938
1612
  * @returns {number}
1939
1613
  */
1940
1614
  get get_cl_s() {
1941
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1942
- _assertNum(this.__wbg_ptr);
1943
- const ret = wasm.evfvideo_get_cl_s(this.__wbg_ptr);
1615
+ const ret = wasm.avfvideo_get_cl_s(this.__wbg_ptr);
1944
1616
  return ret;
1945
1617
  }
1946
1618
  /**
1947
1619
  * @returns {number}
1948
1620
  */
1949
1621
  get get_flag_s() {
1950
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1951
- _assertNum(this.__wbg_ptr);
1952
- const ret = wasm.evfvideo_get_flag_s(this.__wbg_ptr);
1622
+ const ret = wasm.avfvideo_get_flag_s(this.__wbg_ptr);
1953
1623
  return ret;
1954
1624
  }
1955
1625
  /**
1956
1626
  * @returns {number}
1957
1627
  */
1958
1628
  get get_path() {
1959
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1960
- _assertNum(this.__wbg_ptr);
1961
- const ret = wasm.evfvideo_get_path(this.__wbg_ptr);
1629
+ const ret = wasm.avfvideo_get_path(this.__wbg_ptr);
1962
1630
  return ret;
1963
1631
  }
1964
1632
  /**
1965
1633
  * @returns {number}
1966
1634
  */
1967
1635
  get get_ce_s() {
1968
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1969
- _assertNum(this.__wbg_ptr);
1970
- const ret = wasm.evfvideo_get_ce_s(this.__wbg_ptr);
1636
+ const ret = wasm.avfvideo_get_ce_s(this.__wbg_ptr);
1971
1637
  return ret;
1972
1638
  }
1973
1639
  /**
1974
1640
  * @returns {number}
1975
1641
  */
1976
1642
  get get_ioe() {
1977
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1978
- _assertNum(this.__wbg_ptr);
1979
- const ret = wasm.evfvideo_get_ioe(this.__wbg_ptr);
1643
+ const ret = wasm.avfvideo_get_ioe(this.__wbg_ptr);
1980
1644
  return ret;
1981
1645
  }
1982
1646
  /**
1983
1647
  * @returns {number}
1984
1648
  */
1985
1649
  get get_thrp() {
1986
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1987
- _assertNum(this.__wbg_ptr);
1988
- const ret = wasm.evfvideo_get_thrp(this.__wbg_ptr);
1650
+ const ret = wasm.avfvideo_get_thrp(this.__wbg_ptr);
1989
1651
  return ret;
1990
1652
  }
1991
1653
  /**
1992
1654
  * @returns {number}
1993
1655
  */
1994
1656
  get get_corr() {
1995
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
1996
- _assertNum(this.__wbg_ptr);
1997
- const ret = wasm.evfvideo_get_corr(this.__wbg_ptr);
1657
+ const ret = wasm.avfvideo_get_corr(this.__wbg_ptr);
1998
1658
  return ret;
1999
1659
  }
2000
1660
  /**
2001
1661
  * @returns {number}
2002
1662
  */
2003
1663
  get get_events_len() {
2004
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2005
- _assertNum(this.__wbg_ptr);
2006
- const ret = wasm.evfvideo_get_events_len(this.__wbg_ptr);
1664
+ const ret = wasm.avfvideo_get_events_len(this.__wbg_ptr);
2007
1665
  return ret >>> 0;
2008
1666
  }
2009
1667
  /**
@@ -2011,10 +1669,7 @@ export class EvfVideo {
2011
1669
  * @returns {number}
2012
1670
  */
2013
1671
  events_time(index) {
2014
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2015
- _assertNum(this.__wbg_ptr);
2016
- _assertNum(index);
2017
- const ret = wasm.evfvideo_events_time(this.__wbg_ptr, index);
1672
+ const ret = wasm.avfvideo_events_time(this.__wbg_ptr, index);
2018
1673
  return ret;
2019
1674
  }
2020
1675
  /**
@@ -2025,11 +1680,8 @@ export class EvfVideo {
2025
1680
  let deferred1_0;
2026
1681
  let deferred1_1;
2027
1682
  try {
2028
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2029
1683
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2030
- _assertNum(this.__wbg_ptr);
2031
- _assertNum(index);
2032
- wasm.evfvideo_events_mouse(retptr, this.__wbg_ptr, index);
1684
+ wasm.avfvideo_events_mouse(retptr, this.__wbg_ptr, index);
2033
1685
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2034
1686
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2035
1687
  deferred1_0 = r0;
@@ -2045,10 +1697,7 @@ export class EvfVideo {
2045
1697
  * @returns {number}
2046
1698
  */
2047
1699
  events_x(index) {
2048
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2049
- _assertNum(this.__wbg_ptr);
2050
- _assertNum(index);
2051
- const ret = wasm.evfvideo_events_x(this.__wbg_ptr, index);
1700
+ const ret = wasm.avfvideo_events_x(this.__wbg_ptr, index);
2052
1701
  return ret;
2053
1702
  }
2054
1703
  /**
@@ -2056,10 +1705,7 @@ export class EvfVideo {
2056
1705
  * @returns {number}
2057
1706
  */
2058
1707
  events_y(index) {
2059
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2060
- _assertNum(this.__wbg_ptr);
2061
- _assertNum(index);
2062
- const ret = wasm.evfvideo_events_y(this.__wbg_ptr, index);
1708
+ const ret = wasm.avfvideo_events_y(this.__wbg_ptr, index);
2063
1709
  return ret;
2064
1710
  }
2065
1711
  /**
@@ -2067,10 +1713,7 @@ export class EvfVideo {
2067
1713
  * @returns {number}
2068
1714
  */
2069
1715
  events_useful_level(index) {
2070
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2071
- _assertNum(this.__wbg_ptr);
2072
- _assertNum(index);
2073
- const ret = wasm.evfvideo_events_useful_level(this.__wbg_ptr, index);
1716
+ const ret = wasm.avfvideo_events_useful_level(this.__wbg_ptr, index);
2074
1717
  return ret;
2075
1718
  }
2076
1719
  /**
@@ -2078,29 +1721,21 @@ export class EvfVideo {
2078
1721
  * @returns {number}
2079
1722
  */
2080
1723
  events_mouse_state(index) {
2081
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2082
- _assertNum(this.__wbg_ptr);
2083
- _assertNum(index);
2084
- const ret = wasm.evfvideo_events_mouse_state(this.__wbg_ptr, index);
1724
+ const ret = wasm.avfvideo_events_mouse_state(this.__wbg_ptr, index);
2085
1725
  return ret >>> 0;
2086
1726
  }
2087
1727
  /**
2088
1728
  * @returns {number}
2089
1729
  */
2090
1730
  get get_current_event_id() {
2091
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2092
- _assertNum(this.__wbg_ptr);
2093
- const ret = wasm.evfvideo_get_current_event_id(this.__wbg_ptr);
1731
+ const ret = wasm.avfvideo_get_current_event_id(this.__wbg_ptr);
2094
1732
  return ret >>> 0;
2095
1733
  }
2096
1734
  /**
2097
1735
  * @param {number} id
2098
1736
  */
2099
1737
  set current_event_id(id) {
2100
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2101
- _assertNum(this.__wbg_ptr);
2102
- _assertNum(id);
2103
- wasm.evfvideo_set_current_event_id(this.__wbg_ptr, id);
1738
+ wasm.avfvideo_set_current_event_id(this.__wbg_ptr, id);
2104
1739
  }
2105
1740
  /**
2106
1741
  * @returns {string}
@@ -2109,10 +1744,8 @@ export class EvfVideo {
2109
1744
  let deferred1_0;
2110
1745
  let deferred1_1;
2111
1746
  try {
2112
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2113
1747
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2114
- _assertNum(this.__wbg_ptr);
2115
- wasm.evfvideo_get_game_board(retptr, this.__wbg_ptr);
1748
+ wasm.avfvideo_get_game_board(retptr, this.__wbg_ptr);
2116
1749
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2117
1750
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2118
1751
  deferred1_0 = r0;
@@ -2130,10 +1763,8 @@ export class EvfVideo {
2130
1763
  let deferred1_0;
2131
1764
  let deferred1_1;
2132
1765
  try {
2133
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2134
1766
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2135
- _assertNum(this.__wbg_ptr);
2136
- wasm.evfvideo_get_game_board_poss(retptr, this.__wbg_ptr);
1767
+ wasm.avfvideo_get_game_board_poss(retptr, this.__wbg_ptr);
2137
1768
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2138
1769
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2139
1770
  deferred1_0 = r0;
@@ -2148,9 +1779,7 @@ export class EvfVideo {
2148
1779
  * @returns {number}
2149
1780
  */
2150
1781
  get get_mouse_state() {
2151
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2152
- _assertNum(this.__wbg_ptr);
2153
- const ret = wasm.evfvideo_get_mouse_state(this.__wbg_ptr);
1782
+ const ret = wasm.avfvideo_get_mouse_state(this.__wbg_ptr);
2154
1783
  return ret >>> 0;
2155
1784
  }
2156
1785
  /**
@@ -2158,8 +1787,6 @@ export class EvfVideo {
2158
1787
  * @returns {number}
2159
1788
  */
2160
1789
  get get_game_board_state() {
2161
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2162
- _assertNum(this.__wbg_ptr);
2163
1790
  const ret = wasm.evfvideo_get_game_board_state(this.__wbg_ptr);
2164
1791
  return ret >>> 0;
2165
1792
  }
@@ -2168,9 +1795,7 @@ export class EvfVideo {
2168
1795
  * @returns {CursorPos}
2169
1796
  */
2170
1797
  get get_x_y() {
2171
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2172
- _assertNum(this.__wbg_ptr);
2173
- const ret = wasm.evfvideo_get_x_y(this.__wbg_ptr);
1798
+ const ret = wasm.avfvideo_get_x_y(this.__wbg_ptr);
2174
1799
  return CursorPos.__wrap(ret);
2175
1800
  }
2176
1801
  /**
@@ -2178,10 +1803,8 @@ export class EvfVideo {
2178
1803
  */
2179
1804
  get get_checksum() {
2180
1805
  try {
2181
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2182
1806
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2183
- _assertNum(this.__wbg_ptr);
2184
- wasm.evfvideo_get_checksum(retptr, this.__wbg_ptr);
1807
+ wasm.avfvideo_get_checksum(retptr, this.__wbg_ptr);
2185
1808
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2186
1809
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2187
1810
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2195,26 +1818,20 @@ export class EvfVideo {
2195
1818
  * @returns {number}
2196
1819
  */
2197
1820
  get get_pix_size() {
2198
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2199
- _assertNum(this.__wbg_ptr);
2200
- const ret = wasm.evfvideo_get_pix_size(this.__wbg_ptr);
1821
+ const ret = wasm.avfvideo_get_pix_size(this.__wbg_ptr);
2201
1822
  return ret;
2202
1823
  }
2203
1824
  /**
2204
1825
  * @param {number} time
2205
1826
  */
2206
1827
  set current_time(time) {
2207
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2208
- _assertNum(this.__wbg_ptr);
2209
- wasm.evfvideo_set_current_time(this.__wbg_ptr, time);
1828
+ wasm.avfvideo_set_current_time(this.__wbg_ptr, time);
2210
1829
  }
2211
1830
  /**
2212
1831
  * @returns {number}
2213
1832
  */
2214
1833
  is_valid() {
2215
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2216
- _assertNum(this.__wbg_ptr);
2217
- const ret = wasm.evfvideo_is_valid(this.__wbg_ptr);
1834
+ const ret = wasm.avfvideo_is_valid(this.__wbg_ptr);
2218
1835
  return ret;
2219
1836
  }
2220
1837
  }
@@ -2222,10 +1839,6 @@ export class EvfVideo {
2222
1839
  */
2223
1840
  export class MinesweeperBoard {
2224
1841
 
2225
- constructor() {
2226
- throw new Error('cannot invoke `new` directly');
2227
- }
2228
-
2229
1842
  static __wrap(ptr) {
2230
1843
  ptr = ptr >>> 0;
2231
1844
  const obj = Object.create(MinesweeperBoard.prototype);
@@ -2282,20 +1895,14 @@ export class MinesweeperBoard {
2282
1895
  * @param {number} y
2283
1896
  */
2284
1897
  step(e, x, y) {
2285
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2286
- _assertNum(this.__wbg_ptr);
2287
1898
  const ptr0 = passStringToWasm0(e, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2288
1899
  const len0 = WASM_VECTOR_LEN;
2289
- _assertNum(x);
2290
- _assertNum(y);
2291
1900
  wasm.minesweeperboard_step(this.__wbg_ptr, ptr0, len0, x, y);
2292
1901
  }
2293
1902
  /**
2294
1903
  * @param {string} operation
2295
1904
  */
2296
1905
  step_flow(operation) {
2297
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2298
- _assertNum(this.__wbg_ptr);
2299
1906
  const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2300
1907
  const len0 = WASM_VECTOR_LEN;
2301
1908
  wasm.minesweeperboard_step_flow(this.__wbg_ptr, ptr0, len0);
@@ -2304,8 +1911,6 @@ export class MinesweeperBoard {
2304
1911
  * @param {string} board
2305
1912
  */
2306
1913
  set board(board) {
2307
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2308
- _assertNum(this.__wbg_ptr);
2309
1914
  const ptr0 = passStringToWasm0(board, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2310
1915
  const len0 = WASM_VECTOR_LEN;
2311
1916
  wasm.minesweeperboard_set_board(this.__wbg_ptr, ptr0, len0);
@@ -2314,8 +1919,6 @@ export class MinesweeperBoard {
2314
1919
  * @param {string} game_board
2315
1920
  */
2316
1921
  set game_board(game_board) {
2317
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2318
- _assertNum(this.__wbg_ptr);
2319
1922
  const ptr0 = passStringToWasm0(game_board, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2320
1923
  const len0 = WASM_VECTOR_LEN;
2321
1924
  wasm.minesweeperboard_set_game_board(this.__wbg_ptr, ptr0, len0);
@@ -2327,9 +1930,7 @@ export class MinesweeperBoard {
2327
1930
  let deferred1_0;
2328
1931
  let deferred1_1;
2329
1932
  try {
2330
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2331
1933
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2332
- _assertNum(this.__wbg_ptr);
2333
1934
  wasm.minesweeperboard_get_board(retptr, this.__wbg_ptr);
2334
1935
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2335
1936
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -2348,9 +1949,7 @@ export class MinesweeperBoard {
2348
1949
  let deferred1_0;
2349
1950
  let deferred1_1;
2350
1951
  try {
2351
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2352
1952
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2353
- _assertNum(this.__wbg_ptr);
2354
1953
  wasm.minesweeperboard_get_game_board(retptr, this.__wbg_ptr);
2355
1954
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2356
1955
  var r1 = getInt32Memory0()[retptr / 4 + 1];
@@ -2366,8 +1965,6 @@ export class MinesweeperBoard {
2366
1965
  * @returns {number}
2367
1966
  */
2368
1967
  get get_left() {
2369
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2370
- _assertNum(this.__wbg_ptr);
2371
1968
  const ret = wasm.minesweeperboard_get_left(this.__wbg_ptr);
2372
1969
  return ret >>> 0;
2373
1970
  }
@@ -2375,8 +1972,6 @@ export class MinesweeperBoard {
2375
1972
  * @returns {number}
2376
1973
  */
2377
1974
  get get_right() {
2378
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2379
- _assertNum(this.__wbg_ptr);
2380
1975
  const ret = wasm.minesweeperboard_get_right(this.__wbg_ptr);
2381
1976
  return ret >>> 0;
2382
1977
  }
@@ -2384,8 +1979,6 @@ export class MinesweeperBoard {
2384
1979
  * @returns {number}
2385
1980
  */
2386
1981
  get get_double() {
2387
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2388
- _assertNum(this.__wbg_ptr);
2389
1982
  const ret = wasm.minesweeperboard_get_double(this.__wbg_ptr);
2390
1983
  return ret >>> 0;
2391
1984
  }
@@ -2393,8 +1986,6 @@ export class MinesweeperBoard {
2393
1986
  * @returns {number}
2394
1987
  */
2395
1988
  get get_ce() {
2396
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2397
- _assertNum(this.__wbg_ptr);
2398
1989
  const ret = wasm.minesweeperboard_get_ce(this.__wbg_ptr);
2399
1990
  return ret >>> 0;
2400
1991
  }
@@ -2402,8 +1993,6 @@ export class MinesweeperBoard {
2402
1993
  * @returns {number}
2403
1994
  */
2404
1995
  get get_flag() {
2405
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2406
- _assertNum(this.__wbg_ptr);
2407
1996
  const ret = wasm.minesweeperboard_get_flag(this.__wbg_ptr);
2408
1997
  return ret >>> 0;
2409
1998
  }
@@ -2411,8 +2000,6 @@ export class MinesweeperBoard {
2411
2000
  * @returns {number}
2412
2001
  */
2413
2002
  get get_bbbv_solved() {
2414
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2415
- _assertNum(this.__wbg_ptr);
2416
2003
  const ret = wasm.minesweeperboard_get_bbbv_solved(this.__wbg_ptr);
2417
2004
  return ret >>> 0;
2418
2005
  }
@@ -2420,8 +2007,6 @@ export class MinesweeperBoard {
2420
2007
  * @returns {number}
2421
2008
  */
2422
2009
  get get_row() {
2423
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2424
- _assertNum(this.__wbg_ptr);
2425
2010
  const ret = wasm.minesweeperboard_get_row(this.__wbg_ptr);
2426
2011
  return ret >>> 0;
2427
2012
  }
@@ -2429,8 +2014,6 @@ export class MinesweeperBoard {
2429
2014
  * @returns {number}
2430
2015
  */
2431
2016
  get get_column() {
2432
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2433
- _assertNum(this.__wbg_ptr);
2434
2017
  const ret = wasm.minesweeperboard_get_column(this.__wbg_ptr);
2435
2018
  return ret >>> 0;
2436
2019
  }
@@ -2438,8 +2021,6 @@ export class MinesweeperBoard {
2438
2021
  * @returns {number}
2439
2022
  */
2440
2023
  get get_game_board_state() {
2441
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2442
- _assertNum(this.__wbg_ptr);
2443
2024
  const ret = wasm.minesweeperboard_get_game_board_state(this.__wbg_ptr);
2444
2025
  return ret >>> 0;
2445
2026
  }
@@ -2447,8 +2028,6 @@ export class MinesweeperBoard {
2447
2028
  * @returns {number}
2448
2029
  */
2449
2030
  get get_mouse_state() {
2450
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2451
- _assertNum(this.__wbg_ptr);
2452
2031
  const ret = wasm.minesweeperboard_get_mouse_state(this.__wbg_ptr);
2453
2032
  return ret >>> 0;
2454
2033
  }
@@ -2457,10 +2036,6 @@ export class MinesweeperBoard {
2457
2036
  */
2458
2037
  export class MvfVideo {
2459
2038
 
2460
- constructor() {
2461
- throw new Error('cannot invoke `new` directly');
2462
- }
2463
-
2464
2039
  static __wrap(ptr) {
2465
2040
  ptr = ptr >>> 0;
2466
2041
  const obj = Object.create(MvfVideo.prototype);
@@ -2569,26 +2144,20 @@ export class MvfVideo {
2569
2144
  /**
2570
2145
  */
2571
2146
  parse_video() {
2572
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2573
- _assertNum(this.__wbg_ptr);
2574
2147
  wasm.mvfvideo_parse_video(this.__wbg_ptr);
2575
2148
  }
2576
2149
  /**
2577
2150
  */
2578
2151
  analyse() {
2579
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2580
- _assertNum(this.__wbg_ptr);
2581
- wasm.mvfvideo_analyse(this.__wbg_ptr);
2152
+ wasm.avfvideo_analyse(this.__wbg_ptr);
2582
2153
  }
2583
2154
  /**
2584
2155
  * @returns {Uint8Array}
2585
2156
  */
2586
2157
  get get_raw_data() {
2587
2158
  try {
2588
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2589
2159
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2590
- _assertNum(this.__wbg_ptr);
2591
- wasm.mvfvideo_get_raw_data(retptr, this.__wbg_ptr);
2160
+ wasm.avfvideo_get_raw_data(retptr, this.__wbg_ptr);
2592
2161
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2593
2162
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2594
2163
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2603,10 +2172,8 @@ export class MvfVideo {
2603
2172
  */
2604
2173
  get get_software() {
2605
2174
  try {
2606
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2607
2175
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2608
- _assertNum(this.__wbg_ptr);
2609
- wasm.mvfvideo_get_software(retptr, this.__wbg_ptr);
2176
+ wasm.avfvideo_get_software(retptr, this.__wbg_ptr);
2610
2177
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2611
2178
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2612
2179
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2620,72 +2187,56 @@ export class MvfVideo {
2620
2187
  * @returns {number}
2621
2188
  */
2622
2189
  get get_row() {
2623
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2624
- _assertNum(this.__wbg_ptr);
2625
- const ret = wasm.mvfvideo_get_row(this.__wbg_ptr);
2190
+ const ret = wasm.avfvideo_get_row(this.__wbg_ptr);
2626
2191
  return ret >>> 0;
2627
2192
  }
2628
2193
  /**
2629
2194
  * @returns {number}
2630
2195
  */
2631
2196
  get get_column() {
2632
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2633
- _assertNum(this.__wbg_ptr);
2634
- const ret = wasm.mvfvideo_get_column(this.__wbg_ptr);
2197
+ const ret = wasm.avfvideo_get_column(this.__wbg_ptr);
2635
2198
  return ret >>> 0;
2636
2199
  }
2637
2200
  /**
2638
2201
  * @returns {number}
2639
2202
  */
2640
2203
  get get_level() {
2641
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2642
- _assertNum(this.__wbg_ptr);
2643
- const ret = wasm.mvfvideo_get_level(this.__wbg_ptr);
2204
+ const ret = wasm.avfvideo_get_level(this.__wbg_ptr);
2644
2205
  return ret;
2645
2206
  }
2646
2207
  /**
2647
2208
  * @returns {number}
2648
2209
  */
2649
2210
  get get_mode() {
2650
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2651
- _assertNum(this.__wbg_ptr);
2652
- const ret = wasm.mvfvideo_get_mode(this.__wbg_ptr);
2211
+ const ret = wasm.avfvideo_get_mode(this.__wbg_ptr);
2653
2212
  return ret;
2654
2213
  }
2655
2214
  /**
2656
2215
  * @returns {boolean}
2657
2216
  */
2658
2217
  get get_is_completed() {
2659
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2660
- _assertNum(this.__wbg_ptr);
2661
- const ret = wasm.mvfvideo_get_is_completed(this.__wbg_ptr);
2218
+ const ret = wasm.avfvideo_get_is_completed(this.__wbg_ptr);
2662
2219
  return ret !== 0;
2663
2220
  }
2664
2221
  /**
2665
2222
  * @returns {boolean}
2666
2223
  */
2667
2224
  get get_is_official() {
2668
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2669
- _assertNum(this.__wbg_ptr);
2670
- const ret = wasm.mvfvideo_get_is_official(this.__wbg_ptr);
2225
+ const ret = wasm.avfvideo_get_is_official(this.__wbg_ptr);
2671
2226
  return ret !== 0;
2672
2227
  }
2673
2228
  /**
2674
2229
  * @returns {boolean}
2675
2230
  */
2676
2231
  get get_is_fair() {
2677
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2678
- _assertNum(this.__wbg_ptr);
2679
- const ret = wasm.mvfvideo_get_is_fair(this.__wbg_ptr);
2232
+ const ret = wasm.avfvideo_get_is_fair(this.__wbg_ptr);
2680
2233
  return ret !== 0;
2681
2234
  }
2682
2235
  /**
2683
2236
  * @returns {number}
2684
2237
  */
2685
2238
  get get_mine_num() {
2686
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2687
- _assertNum(this.__wbg_ptr);
2688
- const ret = wasm.mvfvideo_get_mine_num(this.__wbg_ptr);
2239
+ const ret = wasm.avfvideo_get_mine_num(this.__wbg_ptr);
2689
2240
  return ret >>> 0;
2690
2241
  }
2691
2242
  /**
@@ -2693,10 +2244,8 @@ export class MvfVideo {
2693
2244
  */
2694
2245
  get get_player_identifier() {
2695
2246
  try {
2696
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2697
2247
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2698
- _assertNum(this.__wbg_ptr);
2699
- wasm.mvfvideo_get_player_identifier(retptr, this.__wbg_ptr);
2248
+ wasm.avfvideo_get_player_identifier(retptr, this.__wbg_ptr);
2700
2249
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2701
2250
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2702
2251
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2711,10 +2260,8 @@ export class MvfVideo {
2711
2260
  */
2712
2261
  get get_race_identifier() {
2713
2262
  try {
2714
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2715
2263
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2716
- _assertNum(this.__wbg_ptr);
2717
- wasm.mvfvideo_get_race_identifier(retptr, this.__wbg_ptr);
2264
+ wasm.avfvideo_get_race_identifier(retptr, this.__wbg_ptr);
2718
2265
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2719
2266
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2720
2267
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2729,10 +2276,8 @@ export class MvfVideo {
2729
2276
  */
2730
2277
  get get_uniqueness_identifier() {
2731
2278
  try {
2732
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2733
2279
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2734
- _assertNum(this.__wbg_ptr);
2735
- wasm.mvfvideo_get_uniqueness_identifier(retptr, this.__wbg_ptr);
2280
+ wasm.avfvideo_get_uniqueness_identifier(retptr, this.__wbg_ptr);
2736
2281
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2737
2282
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2738
2283
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2747,10 +2292,8 @@ export class MvfVideo {
2747
2292
  */
2748
2293
  get get_country() {
2749
2294
  try {
2750
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2751
2295
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2752
- _assertNum(this.__wbg_ptr);
2753
- wasm.mvfvideo_get_country(retptr, this.__wbg_ptr);
2296
+ wasm.avfvideo_get_country(retptr, this.__wbg_ptr);
2754
2297
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2755
2298
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2756
2299
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2765,10 +2308,8 @@ export class MvfVideo {
2765
2308
  */
2766
2309
  get get_device_uuid() {
2767
2310
  try {
2768
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2769
2311
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2770
- _assertNum(this.__wbg_ptr);
2771
- wasm.mvfvideo_get_device_uuid(retptr, this.__wbg_ptr);
2312
+ wasm.avfvideo_get_device_uuid(retptr, this.__wbg_ptr);
2772
2313
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2773
2314
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2774
2315
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2782,9 +2323,7 @@ export class MvfVideo {
2782
2323
  * @returns {number}
2783
2324
  */
2784
2325
  get get_bbbv() {
2785
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2786
- _assertNum(this.__wbg_ptr);
2787
- const ret = wasm.mvfvideo_get_bbbv(this.__wbg_ptr);
2326
+ const ret = wasm.avfvideo_get_bbbv(this.__wbg_ptr);
2788
2327
  return ret >>> 0;
2789
2328
  }
2790
2329
  /**
@@ -2792,10 +2331,8 @@ export class MvfVideo {
2792
2331
  */
2793
2332
  get get_start_time() {
2794
2333
  try {
2795
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2796
2334
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2797
- _assertNum(this.__wbg_ptr);
2798
- wasm.mvfvideo_get_start_time(retptr, this.__wbg_ptr);
2335
+ wasm.avfvideo_get_start_time(retptr, this.__wbg_ptr);
2799
2336
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2800
2337
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2801
2338
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2810,10 +2347,8 @@ export class MvfVideo {
2810
2347
  */
2811
2348
  get get_end_time() {
2812
2349
  try {
2813
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2814
2350
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2815
- _assertNum(this.__wbg_ptr);
2816
- wasm.mvfvideo_get_end_time(retptr, this.__wbg_ptr);
2351
+ wasm.avfvideo_get_end_time(retptr, this.__wbg_ptr);
2817
2352
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2818
2353
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2819
2354
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -2827,342 +2362,266 @@ export class MvfVideo {
2827
2362
  * @returns {number}
2828
2363
  */
2829
2364
  get get_op() {
2830
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2831
- _assertNum(this.__wbg_ptr);
2832
- const ret = wasm.mvfvideo_get_op(this.__wbg_ptr);
2365
+ const ret = wasm.avfvideo_get_op(this.__wbg_ptr);
2833
2366
  return ret >>> 0;
2834
2367
  }
2835
2368
  /**
2836
2369
  * @returns {number}
2837
2370
  */
2838
2371
  get get_isl() {
2839
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2840
- _assertNum(this.__wbg_ptr);
2841
- const ret = wasm.mvfvideo_get_isl(this.__wbg_ptr);
2372
+ const ret = wasm.avfvideo_get_isl(this.__wbg_ptr);
2842
2373
  return ret >>> 0;
2843
2374
  }
2844
2375
  /**
2845
2376
  * @returns {number}
2846
2377
  */
2847
2378
  get get_hizi() {
2848
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2849
- _assertNum(this.__wbg_ptr);
2850
- const ret = wasm.mvfvideo_get_hizi(this.__wbg_ptr);
2379
+ const ret = wasm.avfvideo_get_hizi(this.__wbg_ptr);
2851
2380
  return ret >>> 0;
2852
2381
  }
2853
2382
  /**
2854
2383
  * @returns {number}
2855
2384
  */
2856
2385
  get get_cell0() {
2857
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2858
- _assertNum(this.__wbg_ptr);
2859
- const ret = wasm.mvfvideo_get_cell0(this.__wbg_ptr);
2386
+ const ret = wasm.avfvideo_get_cell0(this.__wbg_ptr);
2860
2387
  return ret >>> 0;
2861
2388
  }
2862
2389
  /**
2863
2390
  * @returns {number}
2864
2391
  */
2865
2392
  get get_cell1() {
2866
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2867
- _assertNum(this.__wbg_ptr);
2868
- const ret = wasm.mvfvideo_get_cell1(this.__wbg_ptr);
2393
+ const ret = wasm.avfvideo_get_cell1(this.__wbg_ptr);
2869
2394
  return ret >>> 0;
2870
2395
  }
2871
2396
  /**
2872
2397
  * @returns {number}
2873
2398
  */
2874
2399
  get get_cell2() {
2875
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2876
- _assertNum(this.__wbg_ptr);
2877
- const ret = wasm.mvfvideo_get_cell2(this.__wbg_ptr);
2400
+ const ret = wasm.avfvideo_get_cell2(this.__wbg_ptr);
2878
2401
  return ret >>> 0;
2879
2402
  }
2880
2403
  /**
2881
2404
  * @returns {number}
2882
2405
  */
2883
2406
  get get_cell3() {
2884
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2885
- _assertNum(this.__wbg_ptr);
2886
- const ret = wasm.mvfvideo_get_cell3(this.__wbg_ptr);
2407
+ const ret = wasm.avfvideo_get_cell3(this.__wbg_ptr);
2887
2408
  return ret >>> 0;
2888
2409
  }
2889
2410
  /**
2890
2411
  * @returns {number}
2891
2412
  */
2892
2413
  get get_cell4() {
2893
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2894
- _assertNum(this.__wbg_ptr);
2895
- const ret = wasm.mvfvideo_get_cell4(this.__wbg_ptr);
2414
+ const ret = wasm.avfvideo_get_cell4(this.__wbg_ptr);
2896
2415
  return ret >>> 0;
2897
2416
  }
2898
2417
  /**
2899
2418
  * @returns {number}
2900
2419
  */
2901
2420
  get get_cell5() {
2902
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2903
- _assertNum(this.__wbg_ptr);
2904
- const ret = wasm.mvfvideo_get_cell5(this.__wbg_ptr);
2421
+ const ret = wasm.avfvideo_get_cell5(this.__wbg_ptr);
2905
2422
  return ret >>> 0;
2906
2423
  }
2907
2424
  /**
2908
2425
  * @returns {number}
2909
2426
  */
2910
2427
  get get_cell6() {
2911
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2912
- _assertNum(this.__wbg_ptr);
2913
- const ret = wasm.mvfvideo_get_cell6(this.__wbg_ptr);
2428
+ const ret = wasm.avfvideo_get_cell6(this.__wbg_ptr);
2914
2429
  return ret >>> 0;
2915
2430
  }
2916
2431
  /**
2917
2432
  * @returns {number}
2918
2433
  */
2919
2434
  get get_cell7() {
2920
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2921
- _assertNum(this.__wbg_ptr);
2922
- const ret = wasm.mvfvideo_get_cell7(this.__wbg_ptr);
2435
+ const ret = wasm.avfvideo_get_cell7(this.__wbg_ptr);
2923
2436
  return ret >>> 0;
2924
2437
  }
2925
2438
  /**
2926
2439
  * @returns {number}
2927
2440
  */
2928
2441
  get get_cell8() {
2929
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2930
- _assertNum(this.__wbg_ptr);
2931
- const ret = wasm.mvfvideo_get_cell8(this.__wbg_ptr);
2442
+ const ret = wasm.avfvideo_get_cell8(this.__wbg_ptr);
2932
2443
  return ret >>> 0;
2933
2444
  }
2934
2445
  /**
2935
2446
  * @returns {number}
2936
2447
  */
2937
2448
  get get_rtime() {
2938
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2939
- _assertNum(this.__wbg_ptr);
2940
- const ret = wasm.mvfvideo_get_rtime(this.__wbg_ptr);
2449
+ const ret = wasm.avfvideo_get_rtime(this.__wbg_ptr);
2941
2450
  return ret;
2942
2451
  }
2943
2452
  /**
2944
2453
  * @returns {number}
2945
2454
  */
2946
2455
  get get_rtime_ms() {
2947
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2948
- _assertNum(this.__wbg_ptr);
2949
- const ret = wasm.mvfvideo_get_rtime_ms(this.__wbg_ptr);
2456
+ const ret = wasm.avfvideo_get_rtime_ms(this.__wbg_ptr);
2950
2457
  return ret >>> 0;
2951
2458
  }
2952
2459
  /**
2953
2460
  * @returns {number}
2954
2461
  */
2955
2462
  get get_etime() {
2956
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2957
- _assertNum(this.__wbg_ptr);
2958
- const ret = wasm.mvfvideo_get_etime(this.__wbg_ptr);
2463
+ const ret = wasm.avfvideo_get_etime(this.__wbg_ptr);
2959
2464
  return ret;
2960
2465
  }
2961
2466
  /**
2962
2467
  * @returns {number}
2963
2468
  */
2964
2469
  get get_video_start_time() {
2965
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2966
- _assertNum(this.__wbg_ptr);
2967
- const ret = wasm.mvfvideo_get_video_start_time(this.__wbg_ptr);
2470
+ const ret = wasm.avfvideo_get_video_start_time(this.__wbg_ptr);
2968
2471
  return ret;
2969
2472
  }
2970
2473
  /**
2971
2474
  * @returns {number}
2972
2475
  */
2973
2476
  get get_video_end_time() {
2974
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2975
- _assertNum(this.__wbg_ptr);
2976
- const ret = wasm.mvfvideo_get_video_end_time(this.__wbg_ptr);
2477
+ const ret = wasm.avfvideo_get_video_end_time(this.__wbg_ptr);
2977
2478
  return ret;
2978
2479
  }
2979
2480
  /**
2980
2481
  * @returns {number}
2981
2482
  */
2982
2483
  get get_bbbv_s() {
2983
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2984
- _assertNum(this.__wbg_ptr);
2985
- const ret = wasm.mvfvideo_get_bbbv_s(this.__wbg_ptr);
2484
+ const ret = wasm.avfvideo_get_bbbv_s(this.__wbg_ptr);
2986
2485
  return ret;
2987
2486
  }
2988
2487
  /**
2989
2488
  * @returns {number}
2990
2489
  */
2991
2490
  get get_stnb() {
2992
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
2993
- _assertNum(this.__wbg_ptr);
2994
- const ret = wasm.mvfvideo_get_stnb(this.__wbg_ptr);
2491
+ const ret = wasm.avfvideo_get_stnb(this.__wbg_ptr);
2995
2492
  return ret;
2996
2493
  }
2997
2494
  /**
2998
2495
  * @returns {number}
2999
2496
  */
3000
2497
  get get_rqp() {
3001
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3002
- _assertNum(this.__wbg_ptr);
3003
- const ret = wasm.mvfvideo_get_rqp(this.__wbg_ptr);
2498
+ const ret = wasm.avfvideo_get_rqp(this.__wbg_ptr);
3004
2499
  return ret;
3005
2500
  }
3006
2501
  /**
3007
2502
  * @returns {number}
3008
2503
  */
3009
2504
  get get_left() {
3010
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3011
- _assertNum(this.__wbg_ptr);
3012
- const ret = wasm.mvfvideo_get_left(this.__wbg_ptr);
2505
+ const ret = wasm.avfvideo_get_left(this.__wbg_ptr);
3013
2506
  return ret >>> 0;
3014
2507
  }
3015
2508
  /**
3016
2509
  * @returns {number}
3017
2510
  */
3018
2511
  get get_right() {
3019
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3020
- _assertNum(this.__wbg_ptr);
3021
- const ret = wasm.mvfvideo_get_right(this.__wbg_ptr);
2512
+ const ret = wasm.avfvideo_get_right(this.__wbg_ptr);
3022
2513
  return ret >>> 0;
3023
2514
  }
3024
2515
  /**
3025
2516
  * @returns {number}
3026
2517
  */
3027
2518
  get get_double() {
3028
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3029
- _assertNum(this.__wbg_ptr);
3030
- const ret = wasm.mvfvideo_get_double(this.__wbg_ptr);
2519
+ const ret = wasm.avfvideo_get_double(this.__wbg_ptr);
3031
2520
  return ret >>> 0;
3032
2521
  }
3033
2522
  /**
3034
2523
  * @returns {number}
3035
2524
  */
3036
2525
  get get_cl() {
3037
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3038
- _assertNum(this.__wbg_ptr);
3039
- const ret = wasm.mvfvideo_get_cl(this.__wbg_ptr);
2526
+ const ret = wasm.avfvideo_get_cl(this.__wbg_ptr);
3040
2527
  return ret >>> 0;
3041
2528
  }
3042
2529
  /**
3043
2530
  * @returns {number}
3044
2531
  */
3045
2532
  get get_flag() {
3046
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3047
- _assertNum(this.__wbg_ptr);
3048
- const ret = wasm.mvfvideo_get_flag(this.__wbg_ptr);
2533
+ const ret = wasm.avfvideo_get_flag(this.__wbg_ptr);
3049
2534
  return ret >>> 0;
3050
2535
  }
3051
2536
  /**
3052
2537
  * @returns {number}
3053
2538
  */
3054
2539
  get get_bbbv_solved() {
3055
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3056
- _assertNum(this.__wbg_ptr);
3057
- const ret = wasm.mvfvideo_get_bbbv_solved(this.__wbg_ptr);
2540
+ const ret = wasm.avfvideo_get_bbbv_solved(this.__wbg_ptr);
3058
2541
  return ret >>> 0;
3059
2542
  }
3060
2543
  /**
3061
2544
  * @returns {number}
3062
2545
  */
3063
2546
  get get_ce() {
3064
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3065
- _assertNum(this.__wbg_ptr);
3066
- const ret = wasm.mvfvideo_get_ce(this.__wbg_ptr);
2547
+ const ret = wasm.avfvideo_get_ce(this.__wbg_ptr);
3067
2548
  return ret >>> 0;
3068
2549
  }
3069
2550
  /**
3070
2551
  * @returns {number}
3071
2552
  */
3072
2553
  get get_left_s() {
3073
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3074
- _assertNum(this.__wbg_ptr);
3075
- const ret = wasm.mvfvideo_get_left_s(this.__wbg_ptr);
2554
+ const ret = wasm.avfvideo_get_left_s(this.__wbg_ptr);
3076
2555
  return ret;
3077
2556
  }
3078
2557
  /**
3079
2558
  * @returns {number}
3080
2559
  */
3081
2560
  get get_right_s() {
3082
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3083
- _assertNum(this.__wbg_ptr);
3084
- const ret = wasm.mvfvideo_get_right_s(this.__wbg_ptr);
2561
+ const ret = wasm.avfvideo_get_right_s(this.__wbg_ptr);
3085
2562
  return ret;
3086
2563
  }
3087
2564
  /**
3088
2565
  * @returns {number}
3089
2566
  */
3090
2567
  get get_double_s() {
3091
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3092
- _assertNum(this.__wbg_ptr);
3093
- const ret = wasm.mvfvideo_get_double_s(this.__wbg_ptr);
2568
+ const ret = wasm.avfvideo_get_double_s(this.__wbg_ptr);
3094
2569
  return ret;
3095
2570
  }
3096
2571
  /**
3097
2572
  * @returns {number}
3098
2573
  */
3099
2574
  get get_cl_s() {
3100
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3101
- _assertNum(this.__wbg_ptr);
3102
- const ret = wasm.mvfvideo_get_cl_s(this.__wbg_ptr);
2575
+ const ret = wasm.avfvideo_get_cl_s(this.__wbg_ptr);
3103
2576
  return ret;
3104
2577
  }
3105
2578
  /**
3106
2579
  * @returns {number}
3107
2580
  */
3108
2581
  get get_flag_s() {
3109
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3110
- _assertNum(this.__wbg_ptr);
3111
- const ret = wasm.mvfvideo_get_flag_s(this.__wbg_ptr);
2582
+ const ret = wasm.avfvideo_get_flag_s(this.__wbg_ptr);
3112
2583
  return ret;
3113
2584
  }
3114
2585
  /**
3115
2586
  * @returns {number}
3116
2587
  */
3117
2588
  get get_path() {
3118
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3119
- _assertNum(this.__wbg_ptr);
3120
- const ret = wasm.mvfvideo_get_path(this.__wbg_ptr);
2589
+ const ret = wasm.avfvideo_get_path(this.__wbg_ptr);
3121
2590
  return ret;
3122
2591
  }
3123
2592
  /**
3124
2593
  * @returns {number}
3125
2594
  */
3126
2595
  get get_ce_s() {
3127
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3128
- _assertNum(this.__wbg_ptr);
3129
- const ret = wasm.mvfvideo_get_ce_s(this.__wbg_ptr);
2596
+ const ret = wasm.avfvideo_get_ce_s(this.__wbg_ptr);
3130
2597
  return ret;
3131
2598
  }
3132
2599
  /**
3133
2600
  * @returns {number}
3134
2601
  */
3135
2602
  get get_ioe() {
3136
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3137
- _assertNum(this.__wbg_ptr);
3138
- const ret = wasm.mvfvideo_get_ioe(this.__wbg_ptr);
2603
+ const ret = wasm.avfvideo_get_ioe(this.__wbg_ptr);
3139
2604
  return ret;
3140
2605
  }
3141
2606
  /**
3142
2607
  * @returns {number}
3143
2608
  */
3144
2609
  get get_thrp() {
3145
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3146
- _assertNum(this.__wbg_ptr);
3147
- const ret = wasm.mvfvideo_get_thrp(this.__wbg_ptr);
2610
+ const ret = wasm.avfvideo_get_thrp(this.__wbg_ptr);
3148
2611
  return ret;
3149
2612
  }
3150
2613
  /**
3151
2614
  * @returns {number}
3152
2615
  */
3153
2616
  get get_corr() {
3154
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3155
- _assertNum(this.__wbg_ptr);
3156
- const ret = wasm.mvfvideo_get_corr(this.__wbg_ptr);
2617
+ const ret = wasm.avfvideo_get_corr(this.__wbg_ptr);
3157
2618
  return ret;
3158
2619
  }
3159
2620
  /**
3160
2621
  * @returns {number}
3161
2622
  */
3162
2623
  get get_events_len() {
3163
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3164
- _assertNum(this.__wbg_ptr);
3165
- const ret = wasm.mvfvideo_get_events_len(this.__wbg_ptr);
2624
+ const ret = wasm.avfvideo_get_events_len(this.__wbg_ptr);
3166
2625
  return ret >>> 0;
3167
2626
  }
3168
2627
  /**
@@ -3170,10 +2629,7 @@ export class MvfVideo {
3170
2629
  * @returns {number}
3171
2630
  */
3172
2631
  events_time(index) {
3173
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3174
- _assertNum(this.__wbg_ptr);
3175
- _assertNum(index);
3176
- const ret = wasm.mvfvideo_events_time(this.__wbg_ptr, index);
2632
+ const ret = wasm.avfvideo_events_time(this.__wbg_ptr, index);
3177
2633
  return ret;
3178
2634
  }
3179
2635
  /**
@@ -3184,11 +2640,8 @@ export class MvfVideo {
3184
2640
  let deferred1_0;
3185
2641
  let deferred1_1;
3186
2642
  try {
3187
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3188
2643
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3189
- _assertNum(this.__wbg_ptr);
3190
- _assertNum(index);
3191
- wasm.mvfvideo_events_mouse(retptr, this.__wbg_ptr, index);
2644
+ wasm.avfvideo_events_mouse(retptr, this.__wbg_ptr, index);
3192
2645
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3193
2646
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3194
2647
  deferred1_0 = r0;
@@ -3204,10 +2657,7 @@ export class MvfVideo {
3204
2657
  * @returns {number}
3205
2658
  */
3206
2659
  events_x(index) {
3207
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3208
- _assertNum(this.__wbg_ptr);
3209
- _assertNum(index);
3210
- const ret = wasm.mvfvideo_events_x(this.__wbg_ptr, index);
2660
+ const ret = wasm.avfvideo_events_x(this.__wbg_ptr, index);
3211
2661
  return ret;
3212
2662
  }
3213
2663
  /**
@@ -3215,10 +2665,7 @@ export class MvfVideo {
3215
2665
  * @returns {number}
3216
2666
  */
3217
2667
  events_y(index) {
3218
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3219
- _assertNum(this.__wbg_ptr);
3220
- _assertNum(index);
3221
- const ret = wasm.mvfvideo_events_y(this.__wbg_ptr, index);
2668
+ const ret = wasm.avfvideo_events_y(this.__wbg_ptr, index);
3222
2669
  return ret;
3223
2670
  }
3224
2671
  /**
@@ -3226,10 +2673,7 @@ export class MvfVideo {
3226
2673
  * @returns {number}
3227
2674
  */
3228
2675
  events_useful_level(index) {
3229
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3230
- _assertNum(this.__wbg_ptr);
3231
- _assertNum(index);
3232
- const ret = wasm.mvfvideo_events_useful_level(this.__wbg_ptr, index);
2676
+ const ret = wasm.avfvideo_events_useful_level(this.__wbg_ptr, index);
3233
2677
  return ret;
3234
2678
  }
3235
2679
  /**
@@ -3237,29 +2681,21 @@ export class MvfVideo {
3237
2681
  * @returns {number}
3238
2682
  */
3239
2683
  events_mouse_state(index) {
3240
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3241
- _assertNum(this.__wbg_ptr);
3242
- _assertNum(index);
3243
- const ret = wasm.mvfvideo_events_mouse_state(this.__wbg_ptr, index);
2684
+ const ret = wasm.avfvideo_events_mouse_state(this.__wbg_ptr, index);
3244
2685
  return ret >>> 0;
3245
2686
  }
3246
2687
  /**
3247
2688
  * @returns {number}
3248
2689
  */
3249
2690
  get get_current_event_id() {
3250
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3251
- _assertNum(this.__wbg_ptr);
3252
- const ret = wasm.mvfvideo_get_current_event_id(this.__wbg_ptr);
2691
+ const ret = wasm.avfvideo_get_current_event_id(this.__wbg_ptr);
3253
2692
  return ret >>> 0;
3254
2693
  }
3255
2694
  /**
3256
2695
  * @param {number} id
3257
2696
  */
3258
2697
  set current_event_id(id) {
3259
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3260
- _assertNum(this.__wbg_ptr);
3261
- _assertNum(id);
3262
- wasm.mvfvideo_set_current_event_id(this.__wbg_ptr, id);
2698
+ wasm.avfvideo_set_current_event_id(this.__wbg_ptr, id);
3263
2699
  }
3264
2700
  /**
3265
2701
  * @returns {string}
@@ -3268,10 +2704,8 @@ export class MvfVideo {
3268
2704
  let deferred1_0;
3269
2705
  let deferred1_1;
3270
2706
  try {
3271
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3272
2707
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3273
- _assertNum(this.__wbg_ptr);
3274
- wasm.mvfvideo_get_game_board(retptr, this.__wbg_ptr);
2708
+ wasm.avfvideo_get_game_board(retptr, this.__wbg_ptr);
3275
2709
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3276
2710
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3277
2711
  deferred1_0 = r0;
@@ -3289,10 +2723,8 @@ export class MvfVideo {
3289
2723
  let deferred1_0;
3290
2724
  let deferred1_1;
3291
2725
  try {
3292
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3293
2726
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3294
- _assertNum(this.__wbg_ptr);
3295
- wasm.mvfvideo_get_game_board_poss(retptr, this.__wbg_ptr);
2727
+ wasm.avfvideo_get_game_board_poss(retptr, this.__wbg_ptr);
3296
2728
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3297
2729
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3298
2730
  deferred1_0 = r0;
@@ -3307,9 +2739,7 @@ export class MvfVideo {
3307
2739
  * @returns {number}
3308
2740
  */
3309
2741
  get get_mouse_state() {
3310
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3311
- _assertNum(this.__wbg_ptr);
3312
- const ret = wasm.mvfvideo_get_mouse_state(this.__wbg_ptr);
2742
+ const ret = wasm.avfvideo_get_mouse_state(this.__wbg_ptr);
3313
2743
  return ret >>> 0;
3314
2744
  }
3315
2745
  /**
@@ -3317,8 +2747,6 @@ export class MvfVideo {
3317
2747
  * @returns {number}
3318
2748
  */
3319
2749
  get get_game_board_state() {
3320
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3321
- _assertNum(this.__wbg_ptr);
3322
2750
  const ret = wasm.mvfvideo_get_game_board_state(this.__wbg_ptr);
3323
2751
  return ret >>> 0;
3324
2752
  }
@@ -3327,9 +2755,7 @@ export class MvfVideo {
3327
2755
  * @returns {CursorPos}
3328
2756
  */
3329
2757
  get get_x_y() {
3330
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3331
- _assertNum(this.__wbg_ptr);
3332
- const ret = wasm.mvfvideo_get_x_y(this.__wbg_ptr);
2758
+ const ret = wasm.avfvideo_get_x_y(this.__wbg_ptr);
3333
2759
  return CursorPos.__wrap(ret);
3334
2760
  }
3335
2761
  /**
@@ -3337,10 +2763,8 @@ export class MvfVideo {
3337
2763
  */
3338
2764
  get get_checksum() {
3339
2765
  try {
3340
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3341
2766
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3342
- _assertNum(this.__wbg_ptr);
3343
- wasm.mvfvideo_get_checksum(retptr, this.__wbg_ptr);
2767
+ wasm.avfvideo_get_checksum(retptr, this.__wbg_ptr);
3344
2768
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3345
2769
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3346
2770
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3354,26 +2778,20 @@ export class MvfVideo {
3354
2778
  * @returns {number}
3355
2779
  */
3356
2780
  get get_pix_size() {
3357
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3358
- _assertNum(this.__wbg_ptr);
3359
- const ret = wasm.mvfvideo_get_pix_size(this.__wbg_ptr);
2781
+ const ret = wasm.avfvideo_get_pix_size(this.__wbg_ptr);
3360
2782
  return ret;
3361
2783
  }
3362
2784
  /**
3363
2785
  * @param {number} time
3364
2786
  */
3365
2787
  set current_time(time) {
3366
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3367
- _assertNum(this.__wbg_ptr);
3368
- wasm.mvfvideo_set_current_time(this.__wbg_ptr, time);
2788
+ wasm.avfvideo_set_current_time(this.__wbg_ptr, time);
3369
2789
  }
3370
2790
  /**
3371
2791
  * @returns {number}
3372
2792
  */
3373
2793
  is_valid() {
3374
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3375
- _assertNum(this.__wbg_ptr);
3376
- const ret = wasm.mvfvideo_is_valid(this.__wbg_ptr);
2794
+ const ret = wasm.avfvideo_is_valid(this.__wbg_ptr);
3377
2795
  return ret;
3378
2796
  }
3379
2797
  }
@@ -3381,10 +2799,6 @@ export class MvfVideo {
3381
2799
  */
3382
2800
  export class RmvVideo {
3383
2801
 
3384
- constructor() {
3385
- throw new Error('cannot invoke `new` directly');
3386
- }
3387
-
3388
2802
  static __wrap(ptr) {
3389
2803
  ptr = ptr >>> 0;
3390
2804
  const obj = Object.create(RmvVideo.prototype);
@@ -3493,26 +2907,20 @@ export class RmvVideo {
3493
2907
  /**
3494
2908
  */
3495
2909
  parse_video() {
3496
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3497
- _assertNum(this.__wbg_ptr);
3498
2910
  wasm.rmvvideo_parse_video(this.__wbg_ptr);
3499
2911
  }
3500
2912
  /**
3501
2913
  */
3502
2914
  analyse() {
3503
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3504
- _assertNum(this.__wbg_ptr);
3505
- wasm.rmvvideo_analyse(this.__wbg_ptr);
2915
+ wasm.avfvideo_analyse(this.__wbg_ptr);
3506
2916
  }
3507
2917
  /**
3508
2918
  * @returns {Uint8Array}
3509
2919
  */
3510
2920
  get get_raw_data() {
3511
2921
  try {
3512
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3513
2922
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3514
- _assertNum(this.__wbg_ptr);
3515
- wasm.rmvvideo_get_raw_data(retptr, this.__wbg_ptr);
2923
+ wasm.avfvideo_get_raw_data(retptr, this.__wbg_ptr);
3516
2924
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3517
2925
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3518
2926
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3527,10 +2935,8 @@ export class RmvVideo {
3527
2935
  */
3528
2936
  get get_software() {
3529
2937
  try {
3530
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3531
2938
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3532
- _assertNum(this.__wbg_ptr);
3533
- wasm.rmvvideo_get_software(retptr, this.__wbg_ptr);
2939
+ wasm.avfvideo_get_software(retptr, this.__wbg_ptr);
3534
2940
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3535
2941
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3536
2942
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3544,72 +2950,56 @@ export class RmvVideo {
3544
2950
  * @returns {number}
3545
2951
  */
3546
2952
  get get_row() {
3547
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3548
- _assertNum(this.__wbg_ptr);
3549
- const ret = wasm.rmvvideo_get_row(this.__wbg_ptr);
2953
+ const ret = wasm.avfvideo_get_row(this.__wbg_ptr);
3550
2954
  return ret >>> 0;
3551
2955
  }
3552
2956
  /**
3553
2957
  * @returns {number}
3554
2958
  */
3555
2959
  get get_column() {
3556
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3557
- _assertNum(this.__wbg_ptr);
3558
- const ret = wasm.rmvvideo_get_column(this.__wbg_ptr);
2960
+ const ret = wasm.avfvideo_get_column(this.__wbg_ptr);
3559
2961
  return ret >>> 0;
3560
2962
  }
3561
2963
  /**
3562
2964
  * @returns {number}
3563
2965
  */
3564
2966
  get get_level() {
3565
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3566
- _assertNum(this.__wbg_ptr);
3567
- const ret = wasm.rmvvideo_get_level(this.__wbg_ptr);
2967
+ const ret = wasm.avfvideo_get_level(this.__wbg_ptr);
3568
2968
  return ret;
3569
2969
  }
3570
2970
  /**
3571
2971
  * @returns {number}
3572
2972
  */
3573
2973
  get get_mode() {
3574
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3575
- _assertNum(this.__wbg_ptr);
3576
- const ret = wasm.rmvvideo_get_mode(this.__wbg_ptr);
2974
+ const ret = wasm.avfvideo_get_mode(this.__wbg_ptr);
3577
2975
  return ret;
3578
2976
  }
3579
2977
  /**
3580
2978
  * @returns {boolean}
3581
2979
  */
3582
2980
  get get_is_completed() {
3583
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3584
- _assertNum(this.__wbg_ptr);
3585
- const ret = wasm.rmvvideo_get_is_completed(this.__wbg_ptr);
2981
+ const ret = wasm.avfvideo_get_is_completed(this.__wbg_ptr);
3586
2982
  return ret !== 0;
3587
2983
  }
3588
2984
  /**
3589
2985
  * @returns {boolean}
3590
2986
  */
3591
2987
  get get_is_official() {
3592
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3593
- _assertNum(this.__wbg_ptr);
3594
- const ret = wasm.rmvvideo_get_is_official(this.__wbg_ptr);
2988
+ const ret = wasm.avfvideo_get_is_official(this.__wbg_ptr);
3595
2989
  return ret !== 0;
3596
2990
  }
3597
2991
  /**
3598
2992
  * @returns {boolean}
3599
2993
  */
3600
2994
  get get_is_fair() {
3601
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3602
- _assertNum(this.__wbg_ptr);
3603
- const ret = wasm.rmvvideo_get_is_fair(this.__wbg_ptr);
2995
+ const ret = wasm.avfvideo_get_is_fair(this.__wbg_ptr);
3604
2996
  return ret !== 0;
3605
2997
  }
3606
2998
  /**
3607
2999
  * @returns {number}
3608
3000
  */
3609
3001
  get get_mine_num() {
3610
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3611
- _assertNum(this.__wbg_ptr);
3612
- const ret = wasm.rmvvideo_get_mine_num(this.__wbg_ptr);
3002
+ const ret = wasm.avfvideo_get_mine_num(this.__wbg_ptr);
3613
3003
  return ret >>> 0;
3614
3004
  }
3615
3005
  /**
@@ -3617,10 +3007,8 @@ export class RmvVideo {
3617
3007
  */
3618
3008
  get get_player_identifier() {
3619
3009
  try {
3620
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3621
3010
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3622
- _assertNum(this.__wbg_ptr);
3623
- wasm.rmvvideo_get_player_identifier(retptr, this.__wbg_ptr);
3011
+ wasm.avfvideo_get_player_identifier(retptr, this.__wbg_ptr);
3624
3012
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3625
3013
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3626
3014
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3635,10 +3023,8 @@ export class RmvVideo {
3635
3023
  */
3636
3024
  get get_race_identifier() {
3637
3025
  try {
3638
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3639
3026
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3640
- _assertNum(this.__wbg_ptr);
3641
- wasm.rmvvideo_get_race_identifier(retptr, this.__wbg_ptr);
3027
+ wasm.avfvideo_get_race_identifier(retptr, this.__wbg_ptr);
3642
3028
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3643
3029
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3644
3030
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3653,10 +3039,8 @@ export class RmvVideo {
3653
3039
  */
3654
3040
  get get_uniqueness_identifier() {
3655
3041
  try {
3656
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3657
3042
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3658
- _assertNum(this.__wbg_ptr);
3659
- wasm.rmvvideo_get_uniqueness_identifier(retptr, this.__wbg_ptr);
3043
+ wasm.avfvideo_get_uniqueness_identifier(retptr, this.__wbg_ptr);
3660
3044
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3661
3045
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3662
3046
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3671,10 +3055,8 @@ export class RmvVideo {
3671
3055
  */
3672
3056
  get get_country() {
3673
3057
  try {
3674
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3675
3058
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3676
- _assertNum(this.__wbg_ptr);
3677
- wasm.rmvvideo_get_country(retptr, this.__wbg_ptr);
3059
+ wasm.avfvideo_get_country(retptr, this.__wbg_ptr);
3678
3060
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3679
3061
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3680
3062
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3689,10 +3071,8 @@ export class RmvVideo {
3689
3071
  */
3690
3072
  get get_device_uuid() {
3691
3073
  try {
3692
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3693
3074
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3694
- _assertNum(this.__wbg_ptr);
3695
- wasm.rmvvideo_get_device_uuid(retptr, this.__wbg_ptr);
3075
+ wasm.avfvideo_get_device_uuid(retptr, this.__wbg_ptr);
3696
3076
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3697
3077
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3698
3078
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3706,9 +3086,7 @@ export class RmvVideo {
3706
3086
  * @returns {number}
3707
3087
  */
3708
3088
  get get_bbbv() {
3709
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3710
- _assertNum(this.__wbg_ptr);
3711
- const ret = wasm.rmvvideo_get_bbbv(this.__wbg_ptr);
3089
+ const ret = wasm.avfvideo_get_bbbv(this.__wbg_ptr);
3712
3090
  return ret >>> 0;
3713
3091
  }
3714
3092
  /**
@@ -3716,10 +3094,8 @@ export class RmvVideo {
3716
3094
  */
3717
3095
  get get_start_time() {
3718
3096
  try {
3719
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3720
3097
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3721
- _assertNum(this.__wbg_ptr);
3722
- wasm.rmvvideo_get_start_time(retptr, this.__wbg_ptr);
3098
+ wasm.avfvideo_get_start_time(retptr, this.__wbg_ptr);
3723
3099
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3724
3100
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3725
3101
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3734,10 +3110,8 @@ export class RmvVideo {
3734
3110
  */
3735
3111
  get get_end_time() {
3736
3112
  try {
3737
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3738
3113
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3739
- _assertNum(this.__wbg_ptr);
3740
- wasm.rmvvideo_get_end_time(retptr, this.__wbg_ptr);
3114
+ wasm.avfvideo_get_end_time(retptr, this.__wbg_ptr);
3741
3115
  var r0 = getInt32Memory0()[retptr / 4 + 0];
3742
3116
  var r1 = getInt32Memory0()[retptr / 4 + 1];
3743
3117
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -3751,342 +3125,266 @@ export class RmvVideo {
3751
3125
  * @returns {number}
3752
3126
  */
3753
3127
  get get_op() {
3754
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3755
- _assertNum(this.__wbg_ptr);
3756
- const ret = wasm.rmvvideo_get_op(this.__wbg_ptr);
3128
+ const ret = wasm.avfvideo_get_op(this.__wbg_ptr);
3757
3129
  return ret >>> 0;
3758
3130
  }
3759
3131
  /**
3760
3132
  * @returns {number}
3761
3133
  */
3762
3134
  get get_isl() {
3763
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3764
- _assertNum(this.__wbg_ptr);
3765
- const ret = wasm.rmvvideo_get_isl(this.__wbg_ptr);
3135
+ const ret = wasm.avfvideo_get_isl(this.__wbg_ptr);
3766
3136
  return ret >>> 0;
3767
3137
  }
3768
3138
  /**
3769
3139
  * @returns {number}
3770
3140
  */
3771
3141
  get get_hizi() {
3772
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3773
- _assertNum(this.__wbg_ptr);
3774
- const ret = wasm.rmvvideo_get_hizi(this.__wbg_ptr);
3142
+ const ret = wasm.avfvideo_get_hizi(this.__wbg_ptr);
3775
3143
  return ret >>> 0;
3776
3144
  }
3777
3145
  /**
3778
3146
  * @returns {number}
3779
3147
  */
3780
3148
  get get_cell0() {
3781
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3782
- _assertNum(this.__wbg_ptr);
3783
- const ret = wasm.rmvvideo_get_cell0(this.__wbg_ptr);
3149
+ const ret = wasm.avfvideo_get_cell0(this.__wbg_ptr);
3784
3150
  return ret >>> 0;
3785
3151
  }
3786
3152
  /**
3787
3153
  * @returns {number}
3788
3154
  */
3789
3155
  get get_cell1() {
3790
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3791
- _assertNum(this.__wbg_ptr);
3792
- const ret = wasm.rmvvideo_get_cell1(this.__wbg_ptr);
3156
+ const ret = wasm.avfvideo_get_cell1(this.__wbg_ptr);
3793
3157
  return ret >>> 0;
3794
3158
  }
3795
3159
  /**
3796
3160
  * @returns {number}
3797
3161
  */
3798
3162
  get get_cell2() {
3799
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3800
- _assertNum(this.__wbg_ptr);
3801
- const ret = wasm.rmvvideo_get_cell2(this.__wbg_ptr);
3163
+ const ret = wasm.avfvideo_get_cell2(this.__wbg_ptr);
3802
3164
  return ret >>> 0;
3803
3165
  }
3804
3166
  /**
3805
3167
  * @returns {number}
3806
3168
  */
3807
3169
  get get_cell3() {
3808
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3809
- _assertNum(this.__wbg_ptr);
3810
- const ret = wasm.rmvvideo_get_cell3(this.__wbg_ptr);
3170
+ const ret = wasm.avfvideo_get_cell3(this.__wbg_ptr);
3811
3171
  return ret >>> 0;
3812
3172
  }
3813
3173
  /**
3814
3174
  * @returns {number}
3815
3175
  */
3816
3176
  get get_cell4() {
3817
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3818
- _assertNum(this.__wbg_ptr);
3819
- const ret = wasm.rmvvideo_get_cell4(this.__wbg_ptr);
3177
+ const ret = wasm.avfvideo_get_cell4(this.__wbg_ptr);
3820
3178
  return ret >>> 0;
3821
3179
  }
3822
3180
  /**
3823
3181
  * @returns {number}
3824
3182
  */
3825
3183
  get get_cell5() {
3826
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3827
- _assertNum(this.__wbg_ptr);
3828
- const ret = wasm.rmvvideo_get_cell5(this.__wbg_ptr);
3184
+ const ret = wasm.avfvideo_get_cell5(this.__wbg_ptr);
3829
3185
  return ret >>> 0;
3830
3186
  }
3831
3187
  /**
3832
3188
  * @returns {number}
3833
3189
  */
3834
3190
  get get_cell6() {
3835
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3836
- _assertNum(this.__wbg_ptr);
3837
- const ret = wasm.rmvvideo_get_cell6(this.__wbg_ptr);
3191
+ const ret = wasm.avfvideo_get_cell6(this.__wbg_ptr);
3838
3192
  return ret >>> 0;
3839
3193
  }
3840
3194
  /**
3841
3195
  * @returns {number}
3842
3196
  */
3843
3197
  get get_cell7() {
3844
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3845
- _assertNum(this.__wbg_ptr);
3846
- const ret = wasm.rmvvideo_get_cell7(this.__wbg_ptr);
3198
+ const ret = wasm.avfvideo_get_cell7(this.__wbg_ptr);
3847
3199
  return ret >>> 0;
3848
3200
  }
3849
3201
  /**
3850
3202
  * @returns {number}
3851
3203
  */
3852
3204
  get get_cell8() {
3853
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3854
- _assertNum(this.__wbg_ptr);
3855
- const ret = wasm.rmvvideo_get_cell8(this.__wbg_ptr);
3205
+ const ret = wasm.avfvideo_get_cell8(this.__wbg_ptr);
3856
3206
  return ret >>> 0;
3857
3207
  }
3858
3208
  /**
3859
3209
  * @returns {number}
3860
3210
  */
3861
3211
  get get_rtime() {
3862
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3863
- _assertNum(this.__wbg_ptr);
3864
- const ret = wasm.rmvvideo_get_rtime(this.__wbg_ptr);
3212
+ const ret = wasm.avfvideo_get_rtime(this.__wbg_ptr);
3865
3213
  return ret;
3866
3214
  }
3867
3215
  /**
3868
3216
  * @returns {number}
3869
3217
  */
3870
3218
  get get_rtime_ms() {
3871
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3872
- _assertNum(this.__wbg_ptr);
3873
- const ret = wasm.rmvvideo_get_rtime_ms(this.__wbg_ptr);
3219
+ const ret = wasm.avfvideo_get_rtime_ms(this.__wbg_ptr);
3874
3220
  return ret >>> 0;
3875
3221
  }
3876
3222
  /**
3877
3223
  * @returns {number}
3878
3224
  */
3879
3225
  get get_etime() {
3880
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3881
- _assertNum(this.__wbg_ptr);
3882
- const ret = wasm.rmvvideo_get_etime(this.__wbg_ptr);
3226
+ const ret = wasm.avfvideo_get_etime(this.__wbg_ptr);
3883
3227
  return ret;
3884
3228
  }
3885
3229
  /**
3886
3230
  * @returns {number}
3887
3231
  */
3888
3232
  get get_video_start_time() {
3889
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3890
- _assertNum(this.__wbg_ptr);
3891
- const ret = wasm.rmvvideo_get_video_start_time(this.__wbg_ptr);
3233
+ const ret = wasm.avfvideo_get_video_start_time(this.__wbg_ptr);
3892
3234
  return ret;
3893
3235
  }
3894
3236
  /**
3895
3237
  * @returns {number}
3896
3238
  */
3897
3239
  get get_video_end_time() {
3898
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3899
- _assertNum(this.__wbg_ptr);
3900
- const ret = wasm.rmvvideo_get_video_end_time(this.__wbg_ptr);
3240
+ const ret = wasm.avfvideo_get_video_end_time(this.__wbg_ptr);
3901
3241
  return ret;
3902
3242
  }
3903
3243
  /**
3904
3244
  * @returns {number}
3905
3245
  */
3906
3246
  get get_bbbv_s() {
3907
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3908
- _assertNum(this.__wbg_ptr);
3909
- const ret = wasm.rmvvideo_get_bbbv_s(this.__wbg_ptr);
3247
+ const ret = wasm.avfvideo_get_bbbv_s(this.__wbg_ptr);
3910
3248
  return ret;
3911
3249
  }
3912
3250
  /**
3913
3251
  * @returns {number}
3914
3252
  */
3915
3253
  get get_stnb() {
3916
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3917
- _assertNum(this.__wbg_ptr);
3918
- const ret = wasm.rmvvideo_get_stnb(this.__wbg_ptr);
3254
+ const ret = wasm.avfvideo_get_stnb(this.__wbg_ptr);
3919
3255
  return ret;
3920
3256
  }
3921
3257
  /**
3922
3258
  * @returns {number}
3923
3259
  */
3924
3260
  get get_rqp() {
3925
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3926
- _assertNum(this.__wbg_ptr);
3927
- const ret = wasm.rmvvideo_get_rqp(this.__wbg_ptr);
3261
+ const ret = wasm.avfvideo_get_rqp(this.__wbg_ptr);
3928
3262
  return ret;
3929
3263
  }
3930
3264
  /**
3931
3265
  * @returns {number}
3932
3266
  */
3933
3267
  get get_left() {
3934
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3935
- _assertNum(this.__wbg_ptr);
3936
- const ret = wasm.rmvvideo_get_left(this.__wbg_ptr);
3268
+ const ret = wasm.avfvideo_get_left(this.__wbg_ptr);
3937
3269
  return ret >>> 0;
3938
3270
  }
3939
3271
  /**
3940
3272
  * @returns {number}
3941
3273
  */
3942
3274
  get get_right() {
3943
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3944
- _assertNum(this.__wbg_ptr);
3945
- const ret = wasm.rmvvideo_get_right(this.__wbg_ptr);
3275
+ const ret = wasm.avfvideo_get_right(this.__wbg_ptr);
3946
3276
  return ret >>> 0;
3947
3277
  }
3948
3278
  /**
3949
3279
  * @returns {number}
3950
3280
  */
3951
3281
  get get_double() {
3952
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3953
- _assertNum(this.__wbg_ptr);
3954
- const ret = wasm.rmvvideo_get_double(this.__wbg_ptr);
3282
+ const ret = wasm.avfvideo_get_double(this.__wbg_ptr);
3955
3283
  return ret >>> 0;
3956
3284
  }
3957
3285
  /**
3958
3286
  * @returns {number}
3959
3287
  */
3960
3288
  get get_cl() {
3961
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3962
- _assertNum(this.__wbg_ptr);
3963
- const ret = wasm.rmvvideo_get_cl(this.__wbg_ptr);
3289
+ const ret = wasm.avfvideo_get_cl(this.__wbg_ptr);
3964
3290
  return ret >>> 0;
3965
3291
  }
3966
3292
  /**
3967
3293
  * @returns {number}
3968
3294
  */
3969
3295
  get get_flag() {
3970
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3971
- _assertNum(this.__wbg_ptr);
3972
- const ret = wasm.rmvvideo_get_flag(this.__wbg_ptr);
3296
+ const ret = wasm.avfvideo_get_flag(this.__wbg_ptr);
3973
3297
  return ret >>> 0;
3974
3298
  }
3975
3299
  /**
3976
3300
  * @returns {number}
3977
3301
  */
3978
3302
  get get_bbbv_solved() {
3979
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3980
- _assertNum(this.__wbg_ptr);
3981
- const ret = wasm.rmvvideo_get_bbbv_solved(this.__wbg_ptr);
3303
+ const ret = wasm.avfvideo_get_bbbv_solved(this.__wbg_ptr);
3982
3304
  return ret >>> 0;
3983
3305
  }
3984
3306
  /**
3985
3307
  * @returns {number}
3986
3308
  */
3987
3309
  get get_ce() {
3988
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3989
- _assertNum(this.__wbg_ptr);
3990
- const ret = wasm.rmvvideo_get_ce(this.__wbg_ptr);
3310
+ const ret = wasm.avfvideo_get_ce(this.__wbg_ptr);
3991
3311
  return ret >>> 0;
3992
3312
  }
3993
3313
  /**
3994
3314
  * @returns {number}
3995
3315
  */
3996
3316
  get get_left_s() {
3997
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
3998
- _assertNum(this.__wbg_ptr);
3999
- const ret = wasm.rmvvideo_get_left_s(this.__wbg_ptr);
3317
+ const ret = wasm.avfvideo_get_left_s(this.__wbg_ptr);
4000
3318
  return ret;
4001
3319
  }
4002
3320
  /**
4003
3321
  * @returns {number}
4004
3322
  */
4005
3323
  get get_right_s() {
4006
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4007
- _assertNum(this.__wbg_ptr);
4008
- const ret = wasm.rmvvideo_get_right_s(this.__wbg_ptr);
3324
+ const ret = wasm.avfvideo_get_right_s(this.__wbg_ptr);
4009
3325
  return ret;
4010
3326
  }
4011
3327
  /**
4012
3328
  * @returns {number}
4013
3329
  */
4014
3330
  get get_double_s() {
4015
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4016
- _assertNum(this.__wbg_ptr);
4017
- const ret = wasm.rmvvideo_get_double_s(this.__wbg_ptr);
3331
+ const ret = wasm.avfvideo_get_double_s(this.__wbg_ptr);
4018
3332
  return ret;
4019
3333
  }
4020
3334
  /**
4021
3335
  * @returns {number}
4022
3336
  */
4023
3337
  get get_cl_s() {
4024
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4025
- _assertNum(this.__wbg_ptr);
4026
- const ret = wasm.rmvvideo_get_cl_s(this.__wbg_ptr);
3338
+ const ret = wasm.avfvideo_get_cl_s(this.__wbg_ptr);
4027
3339
  return ret;
4028
3340
  }
4029
3341
  /**
4030
3342
  * @returns {number}
4031
3343
  */
4032
3344
  get get_flag_s() {
4033
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4034
- _assertNum(this.__wbg_ptr);
4035
- const ret = wasm.rmvvideo_get_flag_s(this.__wbg_ptr);
3345
+ const ret = wasm.avfvideo_get_flag_s(this.__wbg_ptr);
4036
3346
  return ret;
4037
3347
  }
4038
3348
  /**
4039
3349
  * @returns {number}
4040
3350
  */
4041
3351
  get get_path() {
4042
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4043
- _assertNum(this.__wbg_ptr);
4044
- const ret = wasm.rmvvideo_get_path(this.__wbg_ptr);
3352
+ const ret = wasm.avfvideo_get_path(this.__wbg_ptr);
4045
3353
  return ret;
4046
3354
  }
4047
3355
  /**
4048
3356
  * @returns {number}
4049
3357
  */
4050
3358
  get get_ce_s() {
4051
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4052
- _assertNum(this.__wbg_ptr);
4053
- const ret = wasm.rmvvideo_get_ce_s(this.__wbg_ptr);
3359
+ const ret = wasm.avfvideo_get_ce_s(this.__wbg_ptr);
4054
3360
  return ret;
4055
3361
  }
4056
3362
  /**
4057
3363
  * @returns {number}
4058
3364
  */
4059
3365
  get get_ioe() {
4060
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4061
- _assertNum(this.__wbg_ptr);
4062
- const ret = wasm.rmvvideo_get_ioe(this.__wbg_ptr);
3366
+ const ret = wasm.avfvideo_get_ioe(this.__wbg_ptr);
4063
3367
  return ret;
4064
3368
  }
4065
3369
  /**
4066
3370
  * @returns {number}
4067
3371
  */
4068
3372
  get get_thrp() {
4069
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4070
- _assertNum(this.__wbg_ptr);
4071
- const ret = wasm.rmvvideo_get_thrp(this.__wbg_ptr);
3373
+ const ret = wasm.avfvideo_get_thrp(this.__wbg_ptr);
4072
3374
  return ret;
4073
3375
  }
4074
3376
  /**
4075
3377
  * @returns {number}
4076
3378
  */
4077
3379
  get get_corr() {
4078
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4079
- _assertNum(this.__wbg_ptr);
4080
- const ret = wasm.rmvvideo_get_corr(this.__wbg_ptr);
3380
+ const ret = wasm.avfvideo_get_corr(this.__wbg_ptr);
4081
3381
  return ret;
4082
3382
  }
4083
3383
  /**
4084
3384
  * @returns {number}
4085
3385
  */
4086
3386
  get get_events_len() {
4087
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4088
- _assertNum(this.__wbg_ptr);
4089
- const ret = wasm.rmvvideo_get_events_len(this.__wbg_ptr);
3387
+ const ret = wasm.avfvideo_get_events_len(this.__wbg_ptr);
4090
3388
  return ret >>> 0;
4091
3389
  }
4092
3390
  /**
@@ -4094,10 +3392,7 @@ export class RmvVideo {
4094
3392
  * @returns {number}
4095
3393
  */
4096
3394
  events_time(index) {
4097
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4098
- _assertNum(this.__wbg_ptr);
4099
- _assertNum(index);
4100
- const ret = wasm.rmvvideo_events_time(this.__wbg_ptr, index);
3395
+ const ret = wasm.avfvideo_events_time(this.__wbg_ptr, index);
4101
3396
  return ret;
4102
3397
  }
4103
3398
  /**
@@ -4108,11 +3403,8 @@ export class RmvVideo {
4108
3403
  let deferred1_0;
4109
3404
  let deferred1_1;
4110
3405
  try {
4111
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4112
3406
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
4113
- _assertNum(this.__wbg_ptr);
4114
- _assertNum(index);
4115
- wasm.rmvvideo_events_mouse(retptr, this.__wbg_ptr, index);
3407
+ wasm.avfvideo_events_mouse(retptr, this.__wbg_ptr, index);
4116
3408
  var r0 = getInt32Memory0()[retptr / 4 + 0];
4117
3409
  var r1 = getInt32Memory0()[retptr / 4 + 1];
4118
3410
  deferred1_0 = r0;
@@ -4128,10 +3420,7 @@ export class RmvVideo {
4128
3420
  * @returns {number}
4129
3421
  */
4130
3422
  events_x(index) {
4131
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4132
- _assertNum(this.__wbg_ptr);
4133
- _assertNum(index);
4134
- const ret = wasm.rmvvideo_events_x(this.__wbg_ptr, index);
3423
+ const ret = wasm.avfvideo_events_x(this.__wbg_ptr, index);
4135
3424
  return ret;
4136
3425
  }
4137
3426
  /**
@@ -4139,10 +3428,7 @@ export class RmvVideo {
4139
3428
  * @returns {number}
4140
3429
  */
4141
3430
  events_y(index) {
4142
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4143
- _assertNum(this.__wbg_ptr);
4144
- _assertNum(index);
4145
- const ret = wasm.rmvvideo_events_y(this.__wbg_ptr, index);
3431
+ const ret = wasm.avfvideo_events_y(this.__wbg_ptr, index);
4146
3432
  return ret;
4147
3433
  }
4148
3434
  /**
@@ -4150,10 +3436,7 @@ export class RmvVideo {
4150
3436
  * @returns {number}
4151
3437
  */
4152
3438
  events_useful_level(index) {
4153
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4154
- _assertNum(this.__wbg_ptr);
4155
- _assertNum(index);
4156
- const ret = wasm.rmvvideo_events_useful_level(this.__wbg_ptr, index);
3439
+ const ret = wasm.avfvideo_events_useful_level(this.__wbg_ptr, index);
4157
3440
  return ret;
4158
3441
  }
4159
3442
  /**
@@ -4161,29 +3444,21 @@ export class RmvVideo {
4161
3444
  * @returns {number}
4162
3445
  */
4163
3446
  events_mouse_state(index) {
4164
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4165
- _assertNum(this.__wbg_ptr);
4166
- _assertNum(index);
4167
- const ret = wasm.rmvvideo_events_mouse_state(this.__wbg_ptr, index);
3447
+ const ret = wasm.avfvideo_events_mouse_state(this.__wbg_ptr, index);
4168
3448
  return ret >>> 0;
4169
3449
  }
4170
3450
  /**
4171
3451
  * @returns {number}
4172
3452
  */
4173
3453
  get get_current_event_id() {
4174
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4175
- _assertNum(this.__wbg_ptr);
4176
- const ret = wasm.rmvvideo_get_current_event_id(this.__wbg_ptr);
3454
+ const ret = wasm.avfvideo_get_current_event_id(this.__wbg_ptr);
4177
3455
  return ret >>> 0;
4178
3456
  }
4179
3457
  /**
4180
3458
  * @param {number} id
4181
3459
  */
4182
3460
  set current_event_id(id) {
4183
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4184
- _assertNum(this.__wbg_ptr);
4185
- _assertNum(id);
4186
- wasm.rmvvideo_set_current_event_id(this.__wbg_ptr, id);
3461
+ wasm.avfvideo_set_current_event_id(this.__wbg_ptr, id);
4187
3462
  }
4188
3463
  /**
4189
3464
  * @returns {string}
@@ -4192,10 +3467,8 @@ export class RmvVideo {
4192
3467
  let deferred1_0;
4193
3468
  let deferred1_1;
4194
3469
  try {
4195
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4196
3470
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
4197
- _assertNum(this.__wbg_ptr);
4198
- wasm.rmvvideo_get_game_board(retptr, this.__wbg_ptr);
3471
+ wasm.avfvideo_get_game_board(retptr, this.__wbg_ptr);
4199
3472
  var r0 = getInt32Memory0()[retptr / 4 + 0];
4200
3473
  var r1 = getInt32Memory0()[retptr / 4 + 1];
4201
3474
  deferred1_0 = r0;
@@ -4213,10 +3486,8 @@ export class RmvVideo {
4213
3486
  let deferred1_0;
4214
3487
  let deferred1_1;
4215
3488
  try {
4216
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4217
3489
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
4218
- _assertNum(this.__wbg_ptr);
4219
- wasm.rmvvideo_get_game_board_poss(retptr, this.__wbg_ptr);
3490
+ wasm.avfvideo_get_game_board_poss(retptr, this.__wbg_ptr);
4220
3491
  var r0 = getInt32Memory0()[retptr / 4 + 0];
4221
3492
  var r1 = getInt32Memory0()[retptr / 4 + 1];
4222
3493
  deferred1_0 = r0;
@@ -4231,9 +3502,7 @@ export class RmvVideo {
4231
3502
  * @returns {number}
4232
3503
  */
4233
3504
  get get_mouse_state() {
4234
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4235
- _assertNum(this.__wbg_ptr);
4236
- const ret = wasm.rmvvideo_get_mouse_state(this.__wbg_ptr);
3505
+ const ret = wasm.avfvideo_get_mouse_state(this.__wbg_ptr);
4237
3506
  return ret >>> 0;
4238
3507
  }
4239
3508
  /**
@@ -4241,8 +3510,6 @@ export class RmvVideo {
4241
3510
  * @returns {number}
4242
3511
  */
4243
3512
  get get_game_board_state() {
4244
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4245
- _assertNum(this.__wbg_ptr);
4246
3513
  const ret = wasm.rmvvideo_get_game_board_state(this.__wbg_ptr);
4247
3514
  return ret >>> 0;
4248
3515
  }
@@ -4251,9 +3518,7 @@ export class RmvVideo {
4251
3518
  * @returns {CursorPos}
4252
3519
  */
4253
3520
  get get_x_y() {
4254
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4255
- _assertNum(this.__wbg_ptr);
4256
- const ret = wasm.rmvvideo_get_x_y(this.__wbg_ptr);
3521
+ const ret = wasm.avfvideo_get_x_y(this.__wbg_ptr);
4257
3522
  return CursorPos.__wrap(ret);
4258
3523
  }
4259
3524
  /**
@@ -4261,10 +3526,8 @@ export class RmvVideo {
4261
3526
  */
4262
3527
  get get_checksum() {
4263
3528
  try {
4264
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4265
3529
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
4266
- _assertNum(this.__wbg_ptr);
4267
- wasm.rmvvideo_get_checksum(retptr, this.__wbg_ptr);
3530
+ wasm.avfvideo_get_checksum(retptr, this.__wbg_ptr);
4268
3531
  var r0 = getInt32Memory0()[retptr / 4 + 0];
4269
3532
  var r1 = getInt32Memory0()[retptr / 4 + 1];
4270
3533
  var v1 = getArrayU8FromWasm0(r0, r1).slice();
@@ -4278,31 +3541,38 @@ export class RmvVideo {
4278
3541
  * @returns {number}
4279
3542
  */
4280
3543
  get get_pix_size() {
4281
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4282
- _assertNum(this.__wbg_ptr);
4283
- const ret = wasm.rmvvideo_get_pix_size(this.__wbg_ptr);
3544
+ const ret = wasm.avfvideo_get_pix_size(this.__wbg_ptr);
4284
3545
  return ret;
4285
3546
  }
4286
3547
  /**
4287
3548
  * @param {number} time
4288
3549
  */
4289
3550
  set current_time(time) {
4290
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4291
- _assertNum(this.__wbg_ptr);
4292
- wasm.rmvvideo_set_current_time(this.__wbg_ptr, time);
3551
+ wasm.avfvideo_set_current_time(this.__wbg_ptr, time);
4293
3552
  }
4294
3553
  /**
4295
3554
  * @returns {number}
4296
3555
  */
4297
3556
  is_valid() {
4298
- if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
4299
- _assertNum(this.__wbg_ptr);
4300
- const ret = wasm.rmvvideo_is_valid(this.__wbg_ptr);
3557
+ const ret = wasm.avfvideo_is_valid(this.__wbg_ptr);
4301
3558
  return ret;
4302
3559
  }
4303
3560
  }
4304
3561
 
4305
- export function __wbg_error_f851667af71bcfc6() { return logError(function (arg0, arg1) {
3562
+ export function __wbg_new_abda76e883ba8a5f() {
3563
+ const ret = new Error();
3564
+ return addHeapObject(ret);
3565
+ };
3566
+
3567
+ export function __wbg_stack_658279fe44541cf6(arg0, arg1) {
3568
+ const ret = getObject(arg1).stack;
3569
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3570
+ const len1 = WASM_VECTOR_LEN;
3571
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
3572
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
3573
+ };
3574
+
3575
+ export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
4306
3576
  let deferred0_0;
4307
3577
  let deferred0_1;
4308
3578
  try {
@@ -4312,97 +3582,81 @@ export function __wbg_error_f851667af71bcfc6() { return logError(function (arg0,
4312
3582
  } finally {
4313
3583
  wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
4314
3584
  }
4315
- }, arguments) };
4316
-
4317
- export function __wbg_new_abda76e883ba8a5f() { return logError(function () {
4318
- const ret = new Error();
4319
- return addHeapObject(ret);
4320
- }, arguments) };
3585
+ };
4321
3586
 
4322
- export function __wbg_stack_658279fe44541cf6() { return logError(function (arg0, arg1) {
4323
- const ret = getObject(arg1).stack;
4324
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4325
- const len1 = WASM_VECTOR_LEN;
4326
- getInt32Memory0()[arg0 / 4 + 1] = len1;
4327
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
4328
- }, arguments) };
3587
+ export function __wbindgen_object_drop_ref(arg0) {
3588
+ takeObject(arg0);
3589
+ };
4329
3590
 
4330
- export function __wbindgen_string_new(arg0, arg1) {
4331
- const ret = getStringFromWasm0(arg0, arg1);
3591
+ export function __wbg_crypto_c48a774b022d20ac(arg0) {
3592
+ const ret = getObject(arg0).crypto;
4332
3593
  return addHeapObject(ret);
4333
3594
  };
4334
3595
 
4335
3596
  export function __wbindgen_is_object(arg0) {
4336
3597
  const val = getObject(arg0);
4337
3598
  const ret = typeof(val) === 'object' && val !== null;
4338
- _assertBoolean(ret);
4339
3599
  return ret;
4340
3600
  };
4341
3601
 
4342
- export function __wbindgen_is_string(arg0) {
4343
- const ret = typeof(getObject(arg0)) === 'string';
4344
- _assertBoolean(ret);
4345
- return ret;
3602
+ export function __wbg_process_298734cf255a885d(arg0) {
3603
+ const ret = getObject(arg0).process;
3604
+ return addHeapObject(ret);
4346
3605
  };
4347
3606
 
4348
- export function __wbg_crypto_c48a774b022d20ac() { return logError(function (arg0) {
4349
- const ret = getObject(arg0).crypto;
3607
+ export function __wbg_versions_e2e78e134e3e5d01(arg0) {
3608
+ const ret = getObject(arg0).versions;
4350
3609
  return addHeapObject(ret);
4351
- }, arguments) };
3610
+ };
4352
3611
 
4353
- export function __wbg_msCrypto_bcb970640f50a1e8() { return logError(function (arg0) {
4354
- const ret = getObject(arg0).msCrypto;
3612
+ export function __wbg_node_1cd7a5d853dbea79(arg0) {
3613
+ const ret = getObject(arg0).node;
4355
3614
  return addHeapObject(ret);
4356
- }, arguments) };
4357
-
4358
- export function __wbg_getRandomValues_37fa2ca9e4e07fab() { return handleError(function (arg0, arg1) {
4359
- getObject(arg0).getRandomValues(getObject(arg1));
4360
- }, arguments) };
3615
+ };
4361
3616
 
4362
- export function __wbg_randomFillSync_dc1e9a60c158336d() { return handleError(function (arg0, arg1) {
4363
- getObject(arg0).randomFillSync(takeObject(arg1));
4364
- }, arguments) };
3617
+ export function __wbindgen_is_string(arg0) {
3618
+ const ret = typeof(getObject(arg0)) === 'string';
3619
+ return ret;
3620
+ };
4365
3621
 
4366
3622
  export function __wbg_require_8f08ceecec0f4fee() { return handleError(function () {
4367
3623
  const ret = module.require;
4368
3624
  return addHeapObject(ret);
4369
3625
  }, arguments) };
4370
3626
 
4371
- export function __wbg_process_298734cf255a885d() { return logError(function (arg0) {
4372
- const ret = getObject(arg0).process;
3627
+ export function __wbindgen_string_new(arg0, arg1) {
3628
+ const ret = getStringFromWasm0(arg0, arg1);
4373
3629
  return addHeapObject(ret);
4374
- }, arguments) };
3630
+ };
4375
3631
 
4376
- export function __wbg_versions_e2e78e134e3e5d01() { return logError(function (arg0) {
4377
- const ret = getObject(arg0).versions;
3632
+ export function __wbg_msCrypto_bcb970640f50a1e8(arg0) {
3633
+ const ret = getObject(arg0).msCrypto;
4378
3634
  return addHeapObject(ret);
3635
+ };
3636
+
3637
+ export function __wbg_randomFillSync_dc1e9a60c158336d() { return handleError(function (arg0, arg1) {
3638
+ getObject(arg0).randomFillSync(takeObject(arg1));
4379
3639
  }, arguments) };
4380
3640
 
4381
- export function __wbg_node_1cd7a5d853dbea79() { return logError(function (arg0) {
4382
- const ret = getObject(arg0).node;
4383
- return addHeapObject(ret);
3641
+ export function __wbg_getRandomValues_37fa2ca9e4e07fab() { return handleError(function (arg0, arg1) {
3642
+ getObject(arg0).getRandomValues(getObject(arg1));
4384
3643
  }, arguments) };
4385
3644
 
4386
- export function __wbg_newnoargs_581967eacc0e2604() { return logError(function (arg0, arg1) {
3645
+ export function __wbindgen_is_function(arg0) {
3646
+ const ret = typeof(getObject(arg0)) === 'function';
3647
+ return ret;
3648
+ };
3649
+
3650
+ export function __wbg_newnoargs_581967eacc0e2604(arg0, arg1) {
4387
3651
  const ret = new Function(getStringFromWasm0(arg0, arg1));
4388
3652
  return addHeapObject(ret);
4389
- }, arguments) };
3653
+ };
4390
3654
 
4391
3655
  export function __wbg_call_cb65541d95d71282() { return handleError(function (arg0, arg1) {
4392
3656
  const ret = getObject(arg0).call(getObject(arg1));
4393
3657
  return addHeapObject(ret);
4394
3658
  }, arguments) };
4395
3659
 
4396
- export function __wbg_call_01734de55d61e11d() { return handleError(function (arg0, arg1, arg2) {
4397
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
4398
- return addHeapObject(ret);
4399
- }, arguments) };
4400
-
4401
- export function __wbg_globalThis_1d39714405582d3c() { return handleError(function () {
4402
- const ret = globalThis.globalThis;
4403
- return addHeapObject(ret);
4404
- }, arguments) };
4405
-
4406
3660
  export function __wbg_self_1ff1d729e9aae938() { return handleError(function () {
4407
3661
  const ret = self.self;
4408
3662
  return addHeapObject(ret);
@@ -4413,50 +3667,53 @@ export function __wbg_window_5f4faef6c12b79ec() { return handleError(function ()
4413
3667
  return addHeapObject(ret);
4414
3668
  }, arguments) };
4415
3669
 
3670
+ export function __wbg_globalThis_1d39714405582d3c() { return handleError(function () {
3671
+ const ret = globalThis.globalThis;
3672
+ return addHeapObject(ret);
3673
+ }, arguments) };
3674
+
4416
3675
  export function __wbg_global_651f05c6a0944d1c() { return handleError(function () {
4417
3676
  const ret = global.global;
4418
3677
  return addHeapObject(ret);
4419
3678
  }, arguments) };
4420
3679
 
4421
- export function __wbg_new_8125e318e6245eed() { return logError(function (arg0) {
4422
- const ret = new Uint8Array(getObject(arg0));
3680
+ export function __wbindgen_is_undefined(arg0) {
3681
+ const ret = getObject(arg0) === undefined;
3682
+ return ret;
3683
+ };
3684
+
3685
+ export function __wbg_call_01734de55d61e11d() { return handleError(function (arg0, arg1, arg2) {
3686
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
4423
3687
  return addHeapObject(ret);
4424
3688
  }, arguments) };
4425
3689
 
4426
- export function __wbg_newwithlength_e5d69174d6984cd7() { return logError(function (arg0) {
4427
- const ret = new Uint8Array(arg0 >>> 0);
3690
+ export function __wbg_buffer_085ec1f694018c4f(arg0) {
3691
+ const ret = getObject(arg0).buffer;
4428
3692
  return addHeapObject(ret);
4429
- }, arguments) };
3693
+ };
4430
3694
 
4431
- export function __wbg_newwithbyteoffsetandlength_6da8e527659b86aa() { return logError(function (arg0, arg1, arg2) {
3695
+ export function __wbg_newwithbyteoffsetandlength_6da8e527659b86aa(arg0, arg1, arg2) {
4432
3696
  const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
4433
3697
  return addHeapObject(ret);
4434
- }, arguments) };
3698
+ };
4435
3699
 
4436
- export function __wbg_subarray_13db269f57aa838d() { return logError(function (arg0, arg1, arg2) {
4437
- const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
3700
+ export function __wbg_new_8125e318e6245eed(arg0) {
3701
+ const ret = new Uint8Array(getObject(arg0));
4438
3702
  return addHeapObject(ret);
4439
- }, arguments) };
3703
+ };
4440
3704
 
4441
- export function __wbg_set_5cf90238115182c3() { return logError(function (arg0, arg1, arg2) {
3705
+ export function __wbg_set_5cf90238115182c3(arg0, arg1, arg2) {
4442
3706
  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
4443
- }, arguments) };
3707
+ };
4444
3708
 
4445
- export function __wbg_buffer_085ec1f694018c4f() { return logError(function (arg0) {
4446
- const ret = getObject(arg0).buffer;
3709
+ export function __wbg_newwithlength_e5d69174d6984cd7(arg0) {
3710
+ const ret = new Uint8Array(arg0 >>> 0);
4447
3711
  return addHeapObject(ret);
4448
- }, arguments) };
4449
-
4450
- export function __wbindgen_is_function(arg0) {
4451
- const ret = typeof(getObject(arg0)) === 'function';
4452
- _assertBoolean(ret);
4453
- return ret;
4454
3712
  };
4455
3713
 
4456
- export function __wbindgen_is_undefined(arg0) {
4457
- const ret = getObject(arg0) === undefined;
4458
- _assertBoolean(ret);
4459
- return ret;
3714
+ export function __wbg_subarray_13db269f57aa838d(arg0, arg1, arg2) {
3715
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
3716
+ return addHeapObject(ret);
4460
3717
  };
4461
3718
 
4462
3719
  export function __wbindgen_object_clone_ref(arg0) {
@@ -4464,10 +3721,6 @@ export function __wbindgen_object_clone_ref(arg0) {
4464
3721
  return addHeapObject(ret);
4465
3722
  };
4466
3723
 
4467
- export function __wbindgen_object_drop_ref(arg0) {
4468
- takeObject(arg0);
4469
- };
4470
-
4471
3724
  export function __wbindgen_throw(arg0, arg1) {
4472
3725
  throw new Error(getStringFromWasm0(arg0, arg1));
4473
3726
  };