objdiff-wasm 3.0.0-beta.8 → 3.0.0-beta.9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/objdiff.js
CHANGED
|
@@ -55,9 +55,6 @@ function rscTableRemove(table, handle) {
|
|
|
55
55
|
}
|
|
56
56
|
const symbolRscHandle = Symbol('handle');
|
|
57
57
|
const symbolDispose = Symbol.dispose || Symbol.for('dispose');
|
|
58
|
-
function throwInvalidBool() {
|
|
59
|
-
throw new TypeError('invalid variant discriminant for bool');
|
|
60
|
-
}
|
|
61
58
|
function toUint32(val) {
|
|
62
59
|
return val >>> 0;
|
|
63
60
|
}
|
|
@@ -121,6 +118,7 @@ let postReturn4;
|
|
|
121
118
|
let postReturn5;
|
|
122
119
|
let postReturn6;
|
|
123
120
|
let postReturn7;
|
|
121
|
+
let postReturn8;
|
|
124
122
|
const handleTable0 = [
|
|
125
123
|
T_FLAG,
|
|
126
124
|
0
|
|
@@ -380,21 +378,256 @@ ObjectDiff.prototype.findSymbol = function(arg1, arg2) {
|
|
|
380
378
|
variant4_2 = len3;
|
|
381
379
|
}
|
|
382
380
|
const ret = diffMethodObjectDiffFindSymbol(handle0, ptr2, len2, variant4_0, variant4_1, variant4_2);
|
|
383
|
-
let
|
|
381
|
+
let variant15;
|
|
384
382
|
switch(dataView(memory0).getUint8(ret + 0, true)){
|
|
385
383
|
case 0:
|
|
386
|
-
|
|
384
|
+
variant15 = void 0;
|
|
387
385
|
break;
|
|
388
386
|
case 1:
|
|
389
|
-
|
|
387
|
+
{
|
|
388
|
+
var ptr5 = dataView(memory0).getInt32(ret + 12, true);
|
|
389
|
+
var len5 = dataView(memory0).getInt32(ret + 16, true);
|
|
390
|
+
var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
|
|
391
|
+
let variant7;
|
|
392
|
+
switch(dataView(memory0).getUint8(ret + 20, true)){
|
|
393
|
+
case 0:
|
|
394
|
+
variant7 = void 0;
|
|
395
|
+
break;
|
|
396
|
+
case 1:
|
|
397
|
+
var ptr6 = dataView(memory0).getInt32(ret + 24, true);
|
|
398
|
+
var len6 = dataView(memory0).getInt32(ret + 28, true);
|
|
399
|
+
var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
|
|
400
|
+
variant7 = result6;
|
|
401
|
+
break;
|
|
402
|
+
default:
|
|
403
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
404
|
+
}
|
|
405
|
+
let enum8;
|
|
406
|
+
switch(dataView(memory0).getUint8(ret + 48, true)){
|
|
407
|
+
case 0:
|
|
408
|
+
enum8 = 'unknown';
|
|
409
|
+
break;
|
|
410
|
+
case 1:
|
|
411
|
+
enum8 = 'function';
|
|
412
|
+
break;
|
|
413
|
+
case 2:
|
|
414
|
+
enum8 = 'object';
|
|
415
|
+
break;
|
|
416
|
+
case 3:
|
|
417
|
+
enum8 = 'section';
|
|
418
|
+
break;
|
|
419
|
+
default:
|
|
420
|
+
throw new TypeError('invalid discriminant specified for SymbolKind');
|
|
421
|
+
}
|
|
422
|
+
let variant9;
|
|
423
|
+
switch(dataView(memory0).getUint8(ret + 52, true)){
|
|
424
|
+
case 0:
|
|
425
|
+
variant9 = void 0;
|
|
426
|
+
break;
|
|
427
|
+
case 1:
|
|
428
|
+
variant9 = dataView(memory0).getInt32(ret + 56, true) >>> 0;
|
|
429
|
+
break;
|
|
430
|
+
default:
|
|
431
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
432
|
+
}
|
|
433
|
+
let variant11;
|
|
434
|
+
switch(dataView(memory0).getUint8(ret + 60, true)){
|
|
435
|
+
case 0:
|
|
436
|
+
variant11 = void 0;
|
|
437
|
+
break;
|
|
438
|
+
case 1:
|
|
439
|
+
var ptr10 = dataView(memory0).getInt32(ret + 64, true);
|
|
440
|
+
var len10 = dataView(memory0).getInt32(ret + 68, true);
|
|
441
|
+
var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
|
|
442
|
+
variant11 = result10;
|
|
443
|
+
break;
|
|
444
|
+
default:
|
|
445
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
446
|
+
}
|
|
447
|
+
if ((4294967040 & dataView(memory0).getUint8(ret + 72, true)) !== 0) throw new TypeError('flags have extraneous bits set');
|
|
448
|
+
var flags12 = {
|
|
449
|
+
global: Boolean(1 & dataView(memory0).getUint8(ret + 72, true)),
|
|
450
|
+
local: Boolean(2 & dataView(memory0).getUint8(ret + 72, true)),
|
|
451
|
+
weak: Boolean(4 & dataView(memory0).getUint8(ret + 72, true)),
|
|
452
|
+
common: Boolean(8 & dataView(memory0).getUint8(ret + 72, true)),
|
|
453
|
+
hidden: Boolean(16 & dataView(memory0).getUint8(ret + 72, true)),
|
|
454
|
+
hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 72, true)),
|
|
455
|
+
sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 72, true)),
|
|
456
|
+
ignored: Boolean(128 & dataView(memory0).getUint8(ret + 72, true))
|
|
457
|
+
};
|
|
458
|
+
let variant13;
|
|
459
|
+
switch(dataView(memory0).getUint8(ret + 76, true)){
|
|
460
|
+
case 0:
|
|
461
|
+
variant13 = void 0;
|
|
462
|
+
break;
|
|
463
|
+
case 1:
|
|
464
|
+
variant13 = dataView(memory0).getInt32(ret + 80, true) >>> 0;
|
|
465
|
+
break;
|
|
466
|
+
default:
|
|
467
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
468
|
+
}
|
|
469
|
+
let variant14;
|
|
470
|
+
switch(dataView(memory0).getUint8(ret + 88, true)){
|
|
471
|
+
case 0:
|
|
472
|
+
variant14 = void 0;
|
|
473
|
+
break;
|
|
474
|
+
case 1:
|
|
475
|
+
variant14 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 96, true));
|
|
476
|
+
break;
|
|
477
|
+
default:
|
|
478
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
479
|
+
}
|
|
480
|
+
variant15 = {
|
|
481
|
+
id: dataView(memory0).getInt32(ret + 8, true) >>> 0,
|
|
482
|
+
name: result5,
|
|
483
|
+
demangledName: variant7,
|
|
484
|
+
address: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 32, true)),
|
|
485
|
+
size: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 40, true)),
|
|
486
|
+
kind: enum8,
|
|
487
|
+
section: variant9,
|
|
488
|
+
sectionName: variant11,
|
|
489
|
+
flags: flags12,
|
|
490
|
+
align: variant13,
|
|
491
|
+
virtualAddress: variant14
|
|
492
|
+
};
|
|
493
|
+
break;
|
|
494
|
+
}
|
|
495
|
+
default:
|
|
496
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
497
|
+
}
|
|
498
|
+
const retVal = variant15;
|
|
499
|
+
postReturn3(ret);
|
|
500
|
+
return retVal;
|
|
501
|
+
};
|
|
502
|
+
let diffMethodObjectDiffGetSymbol;
|
|
503
|
+
ObjectDiff.prototype.getSymbol = function(arg1) {
|
|
504
|
+
var handle1 = this[symbolRscHandle];
|
|
505
|
+
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
506
|
+
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
507
|
+
const ret = diffMethodObjectDiffGetSymbol(handle0, toUint32(arg1));
|
|
508
|
+
let variant12;
|
|
509
|
+
switch(dataView(memory0).getUint8(ret + 0, true)){
|
|
510
|
+
case 0:
|
|
511
|
+
variant12 = void 0;
|
|
390
512
|
break;
|
|
513
|
+
case 1:
|
|
514
|
+
{
|
|
515
|
+
var ptr2 = dataView(memory0).getInt32(ret + 12, true);
|
|
516
|
+
var len2 = dataView(memory0).getInt32(ret + 16, true);
|
|
517
|
+
var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
|
|
518
|
+
let variant4;
|
|
519
|
+
switch(dataView(memory0).getUint8(ret + 20, true)){
|
|
520
|
+
case 0:
|
|
521
|
+
variant4 = void 0;
|
|
522
|
+
break;
|
|
523
|
+
case 1:
|
|
524
|
+
var ptr3 = dataView(memory0).getInt32(ret + 24, true);
|
|
525
|
+
var len3 = dataView(memory0).getInt32(ret + 28, true);
|
|
526
|
+
var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
|
|
527
|
+
variant4 = result3;
|
|
528
|
+
break;
|
|
529
|
+
default:
|
|
530
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
531
|
+
}
|
|
532
|
+
let enum5;
|
|
533
|
+
switch(dataView(memory0).getUint8(ret + 48, true)){
|
|
534
|
+
case 0:
|
|
535
|
+
enum5 = 'unknown';
|
|
536
|
+
break;
|
|
537
|
+
case 1:
|
|
538
|
+
enum5 = 'function';
|
|
539
|
+
break;
|
|
540
|
+
case 2:
|
|
541
|
+
enum5 = 'object';
|
|
542
|
+
break;
|
|
543
|
+
case 3:
|
|
544
|
+
enum5 = 'section';
|
|
545
|
+
break;
|
|
546
|
+
default:
|
|
547
|
+
throw new TypeError('invalid discriminant specified for SymbolKind');
|
|
548
|
+
}
|
|
549
|
+
let variant6;
|
|
550
|
+
switch(dataView(memory0).getUint8(ret + 52, true)){
|
|
551
|
+
case 0:
|
|
552
|
+
variant6 = void 0;
|
|
553
|
+
break;
|
|
554
|
+
case 1:
|
|
555
|
+
variant6 = dataView(memory0).getInt32(ret + 56, true) >>> 0;
|
|
556
|
+
break;
|
|
557
|
+
default:
|
|
558
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
559
|
+
}
|
|
560
|
+
let variant8;
|
|
561
|
+
switch(dataView(memory0).getUint8(ret + 60, true)){
|
|
562
|
+
case 0:
|
|
563
|
+
variant8 = void 0;
|
|
564
|
+
break;
|
|
565
|
+
case 1:
|
|
566
|
+
var ptr7 = dataView(memory0).getInt32(ret + 64, true);
|
|
567
|
+
var len7 = dataView(memory0).getInt32(ret + 68, true);
|
|
568
|
+
var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
|
|
569
|
+
variant8 = result7;
|
|
570
|
+
break;
|
|
571
|
+
default:
|
|
572
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
573
|
+
}
|
|
574
|
+
if ((4294967040 & dataView(memory0).getUint8(ret + 72, true)) !== 0) throw new TypeError('flags have extraneous bits set');
|
|
575
|
+
var flags9 = {
|
|
576
|
+
global: Boolean(1 & dataView(memory0).getUint8(ret + 72, true)),
|
|
577
|
+
local: Boolean(2 & dataView(memory0).getUint8(ret + 72, true)),
|
|
578
|
+
weak: Boolean(4 & dataView(memory0).getUint8(ret + 72, true)),
|
|
579
|
+
common: Boolean(8 & dataView(memory0).getUint8(ret + 72, true)),
|
|
580
|
+
hidden: Boolean(16 & dataView(memory0).getUint8(ret + 72, true)),
|
|
581
|
+
hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 72, true)),
|
|
582
|
+
sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 72, true)),
|
|
583
|
+
ignored: Boolean(128 & dataView(memory0).getUint8(ret + 72, true))
|
|
584
|
+
};
|
|
585
|
+
let variant10;
|
|
586
|
+
switch(dataView(memory0).getUint8(ret + 76, true)){
|
|
587
|
+
case 0:
|
|
588
|
+
variant10 = void 0;
|
|
589
|
+
break;
|
|
590
|
+
case 1:
|
|
591
|
+
variant10 = dataView(memory0).getInt32(ret + 80, true) >>> 0;
|
|
592
|
+
break;
|
|
593
|
+
default:
|
|
594
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
595
|
+
}
|
|
596
|
+
let variant11;
|
|
597
|
+
switch(dataView(memory0).getUint8(ret + 88, true)){
|
|
598
|
+
case 0:
|
|
599
|
+
variant11 = void 0;
|
|
600
|
+
break;
|
|
601
|
+
case 1:
|
|
602
|
+
variant11 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 96, true));
|
|
603
|
+
break;
|
|
604
|
+
default:
|
|
605
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
606
|
+
}
|
|
607
|
+
variant12 = {
|
|
608
|
+
id: dataView(memory0).getInt32(ret + 8, true) >>> 0,
|
|
609
|
+
name: result2,
|
|
610
|
+
demangledName: variant4,
|
|
611
|
+
address: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 32, true)),
|
|
612
|
+
size: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 40, true)),
|
|
613
|
+
kind: enum5,
|
|
614
|
+
section: variant6,
|
|
615
|
+
sectionName: variant8,
|
|
616
|
+
flags: flags9,
|
|
617
|
+
align: variant10,
|
|
618
|
+
virtualAddress: variant11
|
|
619
|
+
};
|
|
620
|
+
break;
|
|
621
|
+
}
|
|
391
622
|
default:
|
|
392
623
|
throw new TypeError('invalid variant discriminant for option');
|
|
393
624
|
}
|
|
394
|
-
|
|
625
|
+
const retVal = variant12;
|
|
626
|
+
postReturn3(ret);
|
|
627
|
+
return retVal;
|
|
395
628
|
};
|
|
396
629
|
let diffRunDiff;
|
|
397
|
-
function runDiff(arg0, arg1, arg2) {
|
|
630
|
+
function runDiff(arg0, arg1, arg2, arg3) {
|
|
398
631
|
var variant2 = arg0;
|
|
399
632
|
let variant2_0;
|
|
400
633
|
let variant2_1;
|
|
@@ -426,89 +659,138 @@ function runDiff(arg0, arg1, arg2) {
|
|
|
426
659
|
var handle7 = arg2[symbolRscHandle];
|
|
427
660
|
if (!handle7 || (handleTable2[(handle7 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
428
661
|
var handle6 = handleTable2[(handle7 << 1) + 1] & ~T_FLAG;
|
|
429
|
-
|
|
430
|
-
|
|
662
|
+
var { mappings: v8_0, selectingLeft: v8_1, selectingRight: v8_2 } = arg3;
|
|
663
|
+
var vec12 = v8_0;
|
|
664
|
+
var len12 = vec12.length;
|
|
665
|
+
var result12 = realloc0(0, 0, 4, 16 * len12);
|
|
666
|
+
for(let i = 0; i < vec12.length; i++){
|
|
667
|
+
const e = vec12[i];
|
|
668
|
+
const base = result12 + 16 * i;
|
|
669
|
+
var [tuple9_0, tuple9_1] = e;
|
|
670
|
+
var ptr10 = utf8Encode(tuple9_0, realloc0, memory0);
|
|
671
|
+
var len10 = utf8EncodedLen;
|
|
672
|
+
dataView(memory0).setInt32(base + 4, len10, true);
|
|
673
|
+
dataView(memory0).setInt32(base + 0, ptr10, true);
|
|
674
|
+
var ptr11 = utf8Encode(tuple9_1, realloc0, memory0);
|
|
675
|
+
var len11 = utf8EncodedLen;
|
|
676
|
+
dataView(memory0).setInt32(base + 12, len11, true);
|
|
677
|
+
dataView(memory0).setInt32(base + 8, ptr11, true);
|
|
678
|
+
}
|
|
679
|
+
var variant14 = v8_1;
|
|
680
|
+
let variant14_0;
|
|
681
|
+
let variant14_1;
|
|
682
|
+
let variant14_2;
|
|
683
|
+
if (null == variant14) {
|
|
684
|
+
variant14_0 = 0;
|
|
685
|
+
variant14_1 = 0;
|
|
686
|
+
variant14_2 = 0;
|
|
687
|
+
} else {
|
|
688
|
+
const e = variant14;
|
|
689
|
+
var ptr13 = utf8Encode(e, realloc0, memory0);
|
|
690
|
+
var len13 = utf8EncodedLen;
|
|
691
|
+
variant14_0 = 1;
|
|
692
|
+
variant14_1 = ptr13;
|
|
693
|
+
variant14_2 = len13;
|
|
694
|
+
}
|
|
695
|
+
var variant16 = v8_2;
|
|
696
|
+
let variant16_0;
|
|
697
|
+
let variant16_1;
|
|
698
|
+
let variant16_2;
|
|
699
|
+
if (null == variant16) {
|
|
700
|
+
variant16_0 = 0;
|
|
701
|
+
variant16_1 = 0;
|
|
702
|
+
variant16_2 = 0;
|
|
703
|
+
} else {
|
|
704
|
+
const e = variant16;
|
|
705
|
+
var ptr15 = utf8Encode(e, realloc0, memory0);
|
|
706
|
+
var len15 = utf8EncodedLen;
|
|
707
|
+
variant16_0 = 1;
|
|
708
|
+
variant16_1 = ptr15;
|
|
709
|
+
variant16_2 = len15;
|
|
710
|
+
}
|
|
711
|
+
const ret = diffRunDiff(variant2_0, variant2_1, variant5_0, variant5_1, handle6, result12, len12, variant14_0, variant14_1, variant14_2, variant16_0, variant16_1, variant16_2);
|
|
712
|
+
let variant24;
|
|
431
713
|
switch(dataView(memory0).getUint8(ret + 0, true)){
|
|
432
714
|
case 0:
|
|
433
715
|
{
|
|
434
|
-
let
|
|
716
|
+
let variant19;
|
|
435
717
|
switch(dataView(memory0).getUint8(ret + 4, true)){
|
|
436
718
|
case 0:
|
|
437
|
-
|
|
719
|
+
variant19 = void 0;
|
|
438
720
|
break;
|
|
439
721
|
case 1:
|
|
440
|
-
var
|
|
441
|
-
var
|
|
442
|
-
Object.defineProperty(
|
|
722
|
+
var handle18 = dataView(memory0).getInt32(ret + 8, true);
|
|
723
|
+
var rsc17 = new.target === ObjectDiff ? this : Object.create(ObjectDiff.prototype);
|
|
724
|
+
Object.defineProperty(rsc17, symbolRscHandle, {
|
|
443
725
|
writable: true,
|
|
444
|
-
value:
|
|
726
|
+
value: handle18
|
|
445
727
|
});
|
|
446
|
-
finalizationRegistry0.register(
|
|
447
|
-
Object.defineProperty(
|
|
728
|
+
finalizationRegistry0.register(rsc17, handle18, rsc17);
|
|
729
|
+
Object.defineProperty(rsc17, symbolDispose, {
|
|
448
730
|
writable: true,
|
|
449
731
|
value: function() {
|
|
450
|
-
finalizationRegistry0.unregister(
|
|
451
|
-
rscTableRemove(handleTable0,
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
exports0['3'](handleTable0[(
|
|
732
|
+
finalizationRegistry0.unregister(rsc17);
|
|
733
|
+
rscTableRemove(handleTable0, handle18);
|
|
734
|
+
rsc17[symbolDispose] = emptyFunc;
|
|
735
|
+
rsc17[symbolRscHandle] = void 0;
|
|
736
|
+
exports0['3'](handleTable0[(handle18 << 1) + 1] & ~T_FLAG);
|
|
455
737
|
}
|
|
456
738
|
});
|
|
457
|
-
|
|
739
|
+
variant19 = rsc17;
|
|
458
740
|
break;
|
|
459
741
|
default:
|
|
460
742
|
throw new TypeError('invalid variant discriminant for option');
|
|
461
743
|
}
|
|
462
|
-
let
|
|
744
|
+
let variant22;
|
|
463
745
|
switch(dataView(memory0).getUint8(ret + 12, true)){
|
|
464
746
|
case 0:
|
|
465
|
-
|
|
747
|
+
variant22 = void 0;
|
|
466
748
|
break;
|
|
467
749
|
case 1:
|
|
468
|
-
var
|
|
469
|
-
var
|
|
470
|
-
Object.defineProperty(
|
|
750
|
+
var handle21 = dataView(memory0).getInt32(ret + 16, true);
|
|
751
|
+
var rsc20 = new.target === ObjectDiff ? this : Object.create(ObjectDiff.prototype);
|
|
752
|
+
Object.defineProperty(rsc20, symbolRscHandle, {
|
|
471
753
|
writable: true,
|
|
472
|
-
value:
|
|
754
|
+
value: handle21
|
|
473
755
|
});
|
|
474
|
-
finalizationRegistry0.register(
|
|
475
|
-
Object.defineProperty(
|
|
756
|
+
finalizationRegistry0.register(rsc20, handle21, rsc20);
|
|
757
|
+
Object.defineProperty(rsc20, symbolDispose, {
|
|
476
758
|
writable: true,
|
|
477
759
|
value: function() {
|
|
478
|
-
finalizationRegistry0.unregister(
|
|
479
|
-
rscTableRemove(handleTable0,
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
exports0['3'](handleTable0[(
|
|
760
|
+
finalizationRegistry0.unregister(rsc20);
|
|
761
|
+
rscTableRemove(handleTable0, handle21);
|
|
762
|
+
rsc20[symbolDispose] = emptyFunc;
|
|
763
|
+
rsc20[symbolRscHandle] = void 0;
|
|
764
|
+
exports0['3'](handleTable0[(handle21 << 1) + 1] & ~T_FLAG);
|
|
483
765
|
}
|
|
484
766
|
});
|
|
485
|
-
|
|
767
|
+
variant22 = rsc20;
|
|
486
768
|
break;
|
|
487
769
|
default:
|
|
488
770
|
throw new TypeError('invalid variant discriminant for option');
|
|
489
771
|
}
|
|
490
|
-
|
|
772
|
+
variant24 = {
|
|
491
773
|
tag: 'ok',
|
|
492
774
|
val: {
|
|
493
|
-
left:
|
|
494
|
-
right:
|
|
775
|
+
left: variant19,
|
|
776
|
+
right: variant22
|
|
495
777
|
}
|
|
496
778
|
};
|
|
497
779
|
break;
|
|
498
780
|
}
|
|
499
781
|
case 1:
|
|
500
|
-
var
|
|
501
|
-
var
|
|
502
|
-
var
|
|
503
|
-
|
|
782
|
+
var ptr23 = dataView(memory0).getInt32(ret + 4, true);
|
|
783
|
+
var len23 = dataView(memory0).getInt32(ret + 8, true);
|
|
784
|
+
var result23 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr23, len23));
|
|
785
|
+
variant24 = {
|
|
504
786
|
tag: 'err',
|
|
505
|
-
val:
|
|
787
|
+
val: result23
|
|
506
788
|
};
|
|
507
789
|
break;
|
|
508
790
|
default:
|
|
509
791
|
throw new TypeError('invalid variant discriminant for expected');
|
|
510
792
|
}
|
|
511
|
-
const retVal =
|
|
793
|
+
const retVal = variant24;
|
|
512
794
|
postReturn1(ret);
|
|
513
795
|
if ('object' == typeof retVal && 'err' === retVal.tag) throw new ComponentError(retVal.val);
|
|
514
796
|
return retVal.val;
|
|
@@ -548,11 +830,11 @@ function displaySections(arg0, arg1, arg2) {
|
|
|
548
830
|
}
|
|
549
831
|
var { showHiddenSymbols: v6_0, showMappedSymbols: v6_1, reverseFnOrder: v6_2 } = arg2;
|
|
550
832
|
const ret = displayDisplaySections(handle0, variant4_0, variant4_1, variant4_2, variant5_0, variant5_1, v6_0 ? 1 : 0, v6_1 ? 1 : 0, v6_2 ? 1 : 0);
|
|
551
|
-
var
|
|
552
|
-
var
|
|
553
|
-
var
|
|
554
|
-
for(let i = 0; i <
|
|
555
|
-
const base =
|
|
833
|
+
var len11 = dataView(memory0).getInt32(ret + 4, true);
|
|
834
|
+
var base11 = dataView(memory0).getInt32(ret + 0, true);
|
|
835
|
+
var result11 = [];
|
|
836
|
+
for(let i = 0; i < len11; i++){
|
|
837
|
+
const base = base11 + 40 * i;
|
|
556
838
|
var ptr7 = dataView(memory0).getInt32(base + 0, true);
|
|
557
839
|
var len7 = dataView(memory0).getInt32(base + 4, true);
|
|
558
840
|
var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
|
|
@@ -570,27 +852,19 @@ function displaySections(arg0, arg1, arg2) {
|
|
|
570
852
|
default:
|
|
571
853
|
throw new TypeError('invalid variant discriminant for option');
|
|
572
854
|
}
|
|
573
|
-
var
|
|
574
|
-
var
|
|
575
|
-
var
|
|
576
|
-
|
|
577
|
-
const base = base11 + 8 * i;
|
|
578
|
-
var bool10 = dataView(memory0).getUint8(base + 4, true);
|
|
579
|
-
result11.push({
|
|
580
|
-
symbol: dataView(memory0).getInt32(base + 0, true) >>> 0,
|
|
581
|
-
isMappingSymbol: 0 == bool10 ? false : 1 == bool10 ? true : throwInvalidBool()
|
|
582
|
-
});
|
|
583
|
-
}
|
|
584
|
-
result12.push({
|
|
855
|
+
var ptr10 = dataView(memory0).getInt32(base + 32, true);
|
|
856
|
+
var len10 = dataView(memory0).getInt32(base + 36, true);
|
|
857
|
+
var result10 = new Uint32Array(memory0.buffer.slice(ptr10, ptr10 + 4 * len10));
|
|
858
|
+
result11.push({
|
|
585
859
|
id: result7,
|
|
586
860
|
name: result8,
|
|
587
861
|
size: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 16, true)),
|
|
588
862
|
matchPercent: variant9,
|
|
589
|
-
symbols:
|
|
863
|
+
symbols: result10
|
|
590
864
|
});
|
|
591
865
|
}
|
|
592
|
-
const retVal =
|
|
593
|
-
|
|
866
|
+
const retVal = result11;
|
|
867
|
+
postReturn4(ret);
|
|
594
868
|
return retVal;
|
|
595
869
|
}
|
|
596
870
|
let displayDisplaySymbol;
|
|
@@ -598,82 +872,84 @@ function displaySymbol(arg0, arg1) {
|
|
|
598
872
|
var handle1 = arg0[symbolRscHandle];
|
|
599
873
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
600
874
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
var
|
|
604
|
-
var
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
switch(dataView(memory0).getUint8(ret + 8, true)){
|
|
875
|
+
const ret = displayDisplaySymbol(handle0, toUint32(arg1));
|
|
876
|
+
var ptr2 = dataView(memory0).getInt32(ret + 4, true);
|
|
877
|
+
var len2 = dataView(memory0).getInt32(ret + 8, true);
|
|
878
|
+
var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
|
|
879
|
+
let variant4;
|
|
880
|
+
switch(dataView(memory0).getUint8(ret + 12, true)){
|
|
608
881
|
case 0:
|
|
609
|
-
|
|
882
|
+
variant4 = void 0;
|
|
610
883
|
break;
|
|
611
884
|
case 1:
|
|
612
|
-
var
|
|
613
|
-
var
|
|
614
|
-
var
|
|
615
|
-
|
|
885
|
+
var ptr3 = dataView(memory0).getInt32(ret + 16, true);
|
|
886
|
+
var len3 = dataView(memory0).getInt32(ret + 20, true);
|
|
887
|
+
var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
|
|
888
|
+
variant4 = result3;
|
|
616
889
|
break;
|
|
617
890
|
default:
|
|
618
891
|
throw new TypeError('invalid variant discriminant for option');
|
|
619
892
|
}
|
|
620
|
-
let
|
|
893
|
+
let enum5;
|
|
621
894
|
switch(dataView(memory0).getUint8(ret + 40, true)){
|
|
622
895
|
case 0:
|
|
623
|
-
|
|
896
|
+
enum5 = 'unknown';
|
|
624
897
|
break;
|
|
625
898
|
case 1:
|
|
626
|
-
|
|
899
|
+
enum5 = 'function';
|
|
627
900
|
break;
|
|
628
901
|
case 2:
|
|
629
|
-
|
|
902
|
+
enum5 = 'object';
|
|
630
903
|
break;
|
|
631
904
|
case 3:
|
|
632
|
-
|
|
905
|
+
enum5 = 'section';
|
|
633
906
|
break;
|
|
634
907
|
default:
|
|
635
908
|
throw new TypeError('invalid discriminant specified for SymbolKind');
|
|
636
909
|
}
|
|
637
|
-
let
|
|
910
|
+
let variant6;
|
|
638
911
|
switch(dataView(memory0).getUint8(ret + 44, true)){
|
|
639
912
|
case 0:
|
|
640
|
-
|
|
913
|
+
variant6 = void 0;
|
|
641
914
|
break;
|
|
642
915
|
case 1:
|
|
643
|
-
|
|
916
|
+
variant6 = dataView(memory0).getInt32(ret + 48, true) >>> 0;
|
|
644
917
|
break;
|
|
645
918
|
default:
|
|
646
919
|
throw new TypeError('invalid variant discriminant for option');
|
|
647
920
|
}
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
global: Boolean(1 & dataView(memory0).getUint8(ret + 52, true)),
|
|
651
|
-
local: Boolean(2 & dataView(memory0).getUint8(ret + 52, true)),
|
|
652
|
-
weak: Boolean(4 & dataView(memory0).getUint8(ret + 52, true)),
|
|
653
|
-
common: Boolean(8 & dataView(memory0).getUint8(ret + 52, true)),
|
|
654
|
-
hidden: Boolean(16 & dataView(memory0).getUint8(ret + 52, true)),
|
|
655
|
-
hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 52, true)),
|
|
656
|
-
sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 52, true)),
|
|
657
|
-
ignored: Boolean(128 & dataView(memory0).getUint8(ret + 52, true))
|
|
658
|
-
};
|
|
659
|
-
let variant9;
|
|
660
|
-
switch(dataView(memory0).getUint8(ret + 56, true)){
|
|
921
|
+
let variant8;
|
|
922
|
+
switch(dataView(memory0).getUint8(ret + 52, true)){
|
|
661
923
|
case 0:
|
|
662
|
-
|
|
924
|
+
variant8 = void 0;
|
|
663
925
|
break;
|
|
664
926
|
case 1:
|
|
665
|
-
|
|
927
|
+
var ptr7 = dataView(memory0).getInt32(ret + 56, true);
|
|
928
|
+
var len7 = dataView(memory0).getInt32(ret + 60, true);
|
|
929
|
+
var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
|
|
930
|
+
variant8 = result7;
|
|
666
931
|
break;
|
|
667
932
|
default:
|
|
668
933
|
throw new TypeError('invalid variant discriminant for option');
|
|
669
934
|
}
|
|
935
|
+
if ((4294967040 & dataView(memory0).getUint8(ret + 64, true)) !== 0) throw new TypeError('flags have extraneous bits set');
|
|
936
|
+
var flags9 = {
|
|
937
|
+
global: Boolean(1 & dataView(memory0).getUint8(ret + 64, true)),
|
|
938
|
+
local: Boolean(2 & dataView(memory0).getUint8(ret + 64, true)),
|
|
939
|
+
weak: Boolean(4 & dataView(memory0).getUint8(ret + 64, true)),
|
|
940
|
+
common: Boolean(8 & dataView(memory0).getUint8(ret + 64, true)),
|
|
941
|
+
hidden: Boolean(16 & dataView(memory0).getUint8(ret + 64, true)),
|
|
942
|
+
hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 64, true)),
|
|
943
|
+
sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 64, true)),
|
|
944
|
+
ignored: Boolean(128 & dataView(memory0).getUint8(ret + 64, true))
|
|
945
|
+
};
|
|
670
946
|
let variant10;
|
|
671
|
-
switch(dataView(memory0).getUint8(ret +
|
|
947
|
+
switch(dataView(memory0).getUint8(ret + 68, true)){
|
|
672
948
|
case 0:
|
|
673
949
|
variant10 = void 0;
|
|
674
950
|
break;
|
|
675
951
|
case 1:
|
|
676
|
-
variant10 =
|
|
952
|
+
variant10 = dataView(memory0).getInt32(ret + 72, true) >>> 0;
|
|
677
953
|
break;
|
|
678
954
|
default:
|
|
679
955
|
throw new TypeError('invalid variant discriminant for option');
|
|
@@ -684,52 +960,67 @@ function displaySymbol(arg0, arg1) {
|
|
|
684
960
|
variant11 = void 0;
|
|
685
961
|
break;
|
|
686
962
|
case 1:
|
|
687
|
-
variant11 = dataView(memory0).
|
|
963
|
+
variant11 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 88, true));
|
|
688
964
|
break;
|
|
689
965
|
default:
|
|
690
966
|
throw new TypeError('invalid variant discriminant for option');
|
|
691
967
|
}
|
|
692
968
|
let variant12;
|
|
693
|
-
switch(dataView(memory0).getUint8(ret +
|
|
969
|
+
switch(dataView(memory0).getUint8(ret + 96, true)){
|
|
694
970
|
case 0:
|
|
695
971
|
variant12 = void 0;
|
|
696
972
|
break;
|
|
697
973
|
case 1:
|
|
698
|
-
variant12 = dataView(memory0).
|
|
974
|
+
variant12 = dataView(memory0).getInt32(ret + 100, true) >>> 0;
|
|
699
975
|
break;
|
|
700
976
|
default:
|
|
701
977
|
throw new TypeError('invalid variant discriminant for option');
|
|
702
978
|
}
|
|
703
979
|
let variant13;
|
|
704
|
-
switch(dataView(memory0).getUint8(ret +
|
|
980
|
+
switch(dataView(memory0).getUint8(ret + 104, true)){
|
|
705
981
|
case 0:
|
|
706
982
|
variant13 = void 0;
|
|
707
983
|
break;
|
|
708
984
|
case 1:
|
|
709
|
-
variant13 =
|
|
710
|
-
|
|
711
|
-
|
|
985
|
+
variant13 = dataView(memory0).getFloat32(ret + 108, true);
|
|
986
|
+
break;
|
|
987
|
+
default:
|
|
988
|
+
throw new TypeError('invalid variant discriminant for option');
|
|
989
|
+
}
|
|
990
|
+
let variant14;
|
|
991
|
+
switch(dataView(memory0).getUint8(ret + 112, true)){
|
|
992
|
+
case 0:
|
|
993
|
+
variant14 = void 0;
|
|
994
|
+
break;
|
|
995
|
+
case 1:
|
|
996
|
+
variant14 = [
|
|
997
|
+
BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 120, true)),
|
|
998
|
+
BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 128, true))
|
|
712
999
|
];
|
|
713
1000
|
break;
|
|
714
1001
|
default:
|
|
715
1002
|
throw new TypeError('invalid variant discriminant for option');
|
|
716
1003
|
}
|
|
717
1004
|
const retVal = {
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
1005
|
+
info: {
|
|
1006
|
+
id: dataView(memory0).getInt32(ret + 0, true) >>> 0,
|
|
1007
|
+
name: result2,
|
|
1008
|
+
demangledName: variant4,
|
|
1009
|
+
address: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 24, true)),
|
|
1010
|
+
size: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 32, true)),
|
|
1011
|
+
kind: enum5,
|
|
1012
|
+
section: variant6,
|
|
1013
|
+
sectionName: variant8,
|
|
1014
|
+
flags: flags9,
|
|
1015
|
+
align: variant10,
|
|
1016
|
+
virtualAddress: variant11
|
|
1017
|
+
},
|
|
1018
|
+
targetSymbol: variant12,
|
|
1019
|
+
matchPercent: variant13,
|
|
1020
|
+
diffScore: variant14,
|
|
1021
|
+
rowCount: dataView(memory0).getInt32(ret + 136, true) >>> 0
|
|
731
1022
|
};
|
|
732
|
-
|
|
1023
|
+
postReturn5(ret);
|
|
733
1024
|
return retVal;
|
|
734
1025
|
}
|
|
735
1026
|
let displayDisplayInstructionRow;
|
|
@@ -737,160 +1028,159 @@ function displayInstructionRow(arg0, arg1, arg2, arg3) {
|
|
|
737
1028
|
var handle1 = arg0[symbolRscHandle];
|
|
738
1029
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
739
1030
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
740
|
-
var
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
var
|
|
746
|
-
var
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
let variant11;
|
|
1031
|
+
var handle3 = arg3[symbolRscHandle];
|
|
1032
|
+
if (!handle3 || (handleTable2[(handle3 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
1033
|
+
var handle2 = handleTable2[(handle3 << 1) + 1] & ~T_FLAG;
|
|
1034
|
+
const ret = displayDisplayInstructionRow(handle0, toUint32(arg1), toUint32(arg2), handle2);
|
|
1035
|
+
var len12 = dataView(memory0).getInt32(ret + 4, true);
|
|
1036
|
+
var base12 = dataView(memory0).getInt32(ret + 0, true);
|
|
1037
|
+
var result12 = [];
|
|
1038
|
+
for(let i = 0; i < len12; i++){
|
|
1039
|
+
const base = base12 + 40 * i;
|
|
1040
|
+
let variant10;
|
|
751
1041
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
752
1042
|
case 0:
|
|
753
|
-
var
|
|
754
|
-
var
|
|
755
|
-
var
|
|
756
|
-
|
|
1043
|
+
var ptr4 = dataView(memory0).getInt32(base + 8, true);
|
|
1044
|
+
var len4 = dataView(memory0).getInt32(base + 12, true);
|
|
1045
|
+
var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
|
|
1046
|
+
variant10 = {
|
|
757
1047
|
tag: 'basic',
|
|
758
|
-
val:
|
|
1048
|
+
val: result4
|
|
759
1049
|
};
|
|
760
1050
|
break;
|
|
761
1051
|
case 1:
|
|
762
|
-
|
|
1052
|
+
variant10 = {
|
|
763
1053
|
tag: 'line',
|
|
764
1054
|
val: dataView(memory0).getInt32(base + 8, true) >>> 0
|
|
765
1055
|
};
|
|
766
1056
|
break;
|
|
767
1057
|
case 2:
|
|
768
|
-
|
|
1058
|
+
variant10 = {
|
|
769
1059
|
tag: 'address',
|
|
770
1060
|
val: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 8, true))
|
|
771
1061
|
};
|
|
772
1062
|
break;
|
|
773
1063
|
case 3:
|
|
774
|
-
var
|
|
775
|
-
var
|
|
776
|
-
var
|
|
777
|
-
|
|
1064
|
+
var ptr5 = dataView(memory0).getInt32(base + 8, true);
|
|
1065
|
+
var len5 = dataView(memory0).getInt32(base + 12, true);
|
|
1066
|
+
var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
|
|
1067
|
+
variant10 = {
|
|
778
1068
|
tag: 'opcode',
|
|
779
1069
|
val: {
|
|
780
|
-
mnemonic:
|
|
1070
|
+
mnemonic: result5,
|
|
781
1071
|
opcode: clampGuest(dataView(memory0).getUint16(base + 16, true), 0, 65535)
|
|
782
1072
|
}
|
|
783
1073
|
};
|
|
784
1074
|
break;
|
|
785
1075
|
case 4:
|
|
786
|
-
|
|
1076
|
+
variant10 = {
|
|
787
1077
|
tag: 'signed',
|
|
788
1078
|
val: dataView(memory0).getBigInt64(base + 8, true)
|
|
789
1079
|
};
|
|
790
1080
|
break;
|
|
791
1081
|
case 5:
|
|
792
|
-
|
|
1082
|
+
variant10 = {
|
|
793
1083
|
tag: 'unsigned',
|
|
794
1084
|
val: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 8, true))
|
|
795
1085
|
};
|
|
796
1086
|
break;
|
|
797
1087
|
case 6:
|
|
798
|
-
var
|
|
799
|
-
var
|
|
800
|
-
var
|
|
801
|
-
|
|
1088
|
+
var ptr6 = dataView(memory0).getInt32(base + 8, true);
|
|
1089
|
+
var len6 = dataView(memory0).getInt32(base + 12, true);
|
|
1090
|
+
var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
|
|
1091
|
+
variant10 = {
|
|
802
1092
|
tag: 'opaque',
|
|
803
|
-
val:
|
|
1093
|
+
val: result6
|
|
804
1094
|
};
|
|
805
1095
|
break;
|
|
806
1096
|
case 7:
|
|
807
|
-
|
|
1097
|
+
variant10 = {
|
|
808
1098
|
tag: 'branch-dest',
|
|
809
1099
|
val: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 8, true))
|
|
810
1100
|
};
|
|
811
1101
|
break;
|
|
812
1102
|
case 8:
|
|
813
1103
|
{
|
|
814
|
-
var
|
|
815
|
-
var
|
|
816
|
-
var
|
|
817
|
-
let
|
|
1104
|
+
var ptr7 = dataView(memory0).getInt32(base + 8, true);
|
|
1105
|
+
var len7 = dataView(memory0).getInt32(base + 12, true);
|
|
1106
|
+
var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
|
|
1107
|
+
let variant9;
|
|
818
1108
|
switch(dataView(memory0).getUint8(base + 16, true)){
|
|
819
1109
|
case 0:
|
|
820
|
-
|
|
1110
|
+
variant9 = void 0;
|
|
821
1111
|
break;
|
|
822
1112
|
case 1:
|
|
823
|
-
var
|
|
824
|
-
var
|
|
825
|
-
var
|
|
826
|
-
|
|
1113
|
+
var ptr8 = dataView(memory0).getInt32(base + 20, true);
|
|
1114
|
+
var len8 = dataView(memory0).getInt32(base + 24, true);
|
|
1115
|
+
var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
|
|
1116
|
+
variant9 = result8;
|
|
827
1117
|
break;
|
|
828
1118
|
default:
|
|
829
1119
|
throw new TypeError('invalid variant discriminant for option');
|
|
830
1120
|
}
|
|
831
|
-
|
|
1121
|
+
variant10 = {
|
|
832
1122
|
tag: 'symbol',
|
|
833
1123
|
val: {
|
|
834
|
-
name:
|
|
835
|
-
demangledName:
|
|
1124
|
+
name: result7,
|
|
1125
|
+
demangledName: variant9
|
|
836
1126
|
}
|
|
837
1127
|
};
|
|
838
1128
|
break;
|
|
839
1129
|
}
|
|
840
1130
|
case 9:
|
|
841
|
-
|
|
1131
|
+
variant10 = {
|
|
842
1132
|
tag: 'addend',
|
|
843
1133
|
val: dataView(memory0).getBigInt64(base + 8, true)
|
|
844
1134
|
};
|
|
845
1135
|
break;
|
|
846
1136
|
case 10:
|
|
847
|
-
|
|
1137
|
+
variant10 = {
|
|
848
1138
|
tag: 'spacing',
|
|
849
1139
|
val: clampGuest(dataView(memory0).getUint8(base + 8, true), 0, 255)
|
|
850
1140
|
};
|
|
851
1141
|
break;
|
|
852
1142
|
case 11:
|
|
853
|
-
|
|
1143
|
+
variant10 = {
|
|
854
1144
|
tag: 'eol'
|
|
855
1145
|
};
|
|
856
1146
|
break;
|
|
857
1147
|
default:
|
|
858
1148
|
throw new TypeError('invalid variant discriminant for DiffText');
|
|
859
1149
|
}
|
|
860
|
-
let
|
|
1150
|
+
let variant11;
|
|
861
1151
|
switch(dataView(memory0).getUint8(base + 32, true)){
|
|
862
1152
|
case 0:
|
|
863
|
-
|
|
1153
|
+
variant11 = {
|
|
864
1154
|
tag: 'normal'
|
|
865
1155
|
};
|
|
866
1156
|
break;
|
|
867
1157
|
case 1:
|
|
868
|
-
|
|
1158
|
+
variant11 = {
|
|
869
1159
|
tag: 'dim'
|
|
870
1160
|
};
|
|
871
1161
|
break;
|
|
872
1162
|
case 2:
|
|
873
|
-
|
|
1163
|
+
variant11 = {
|
|
874
1164
|
tag: 'bright'
|
|
875
1165
|
};
|
|
876
1166
|
break;
|
|
877
1167
|
case 3:
|
|
878
|
-
|
|
1168
|
+
variant11 = {
|
|
879
1169
|
tag: 'replace'
|
|
880
1170
|
};
|
|
881
1171
|
break;
|
|
882
1172
|
case 4:
|
|
883
|
-
|
|
1173
|
+
variant11 = {
|
|
884
1174
|
tag: 'delete'
|
|
885
1175
|
};
|
|
886
1176
|
break;
|
|
887
1177
|
case 5:
|
|
888
|
-
|
|
1178
|
+
variant11 = {
|
|
889
1179
|
tag: 'insert'
|
|
890
1180
|
};
|
|
891
1181
|
break;
|
|
892
1182
|
case 6:
|
|
893
|
-
|
|
1183
|
+
variant11 = {
|
|
894
1184
|
tag: 'rotating',
|
|
895
1185
|
val: clampGuest(dataView(memory0).getUint8(base + 33, true), 0, 255)
|
|
896
1186
|
};
|
|
@@ -898,40 +1188,40 @@ function displayInstructionRow(arg0, arg1, arg2, arg3) {
|
|
|
898
1188
|
default:
|
|
899
1189
|
throw new TypeError('invalid variant discriminant for DiffTextColor');
|
|
900
1190
|
}
|
|
901
|
-
|
|
902
|
-
text:
|
|
903
|
-
color:
|
|
1191
|
+
result12.push({
|
|
1192
|
+
text: variant10,
|
|
1193
|
+
color: variant11,
|
|
904
1194
|
padTo: clampGuest(dataView(memory0).getUint8(base + 34, true), 0, 255)
|
|
905
1195
|
});
|
|
906
1196
|
}
|
|
907
|
-
let
|
|
1197
|
+
let enum13;
|
|
908
1198
|
switch(dataView(memory0).getUint8(ret + 8, true)){
|
|
909
1199
|
case 0:
|
|
910
|
-
|
|
1200
|
+
enum13 = 'none';
|
|
911
1201
|
break;
|
|
912
1202
|
case 1:
|
|
913
|
-
|
|
1203
|
+
enum13 = 'op-mismatch';
|
|
914
1204
|
break;
|
|
915
1205
|
case 2:
|
|
916
|
-
|
|
1206
|
+
enum13 = 'arg-mismatch';
|
|
917
1207
|
break;
|
|
918
1208
|
case 3:
|
|
919
|
-
|
|
1209
|
+
enum13 = 'replace';
|
|
920
1210
|
break;
|
|
921
1211
|
case 4:
|
|
922
|
-
|
|
1212
|
+
enum13 = 'insert';
|
|
923
1213
|
break;
|
|
924
1214
|
case 5:
|
|
925
|
-
|
|
1215
|
+
enum13 = 'delete';
|
|
926
1216
|
break;
|
|
927
1217
|
default:
|
|
928
1218
|
throw new TypeError('invalid discriminant specified for InstructionDiffKind');
|
|
929
1219
|
}
|
|
930
1220
|
const retVal = {
|
|
931
|
-
segments:
|
|
932
|
-
diffKind:
|
|
1221
|
+
segments: result12,
|
|
1222
|
+
diffKind: enum13
|
|
933
1223
|
};
|
|
934
|
-
|
|
1224
|
+
postReturn6(ret);
|
|
935
1225
|
return retVal;
|
|
936
1226
|
}
|
|
937
1227
|
let displaySymbolContext;
|
|
@@ -939,81 +1229,80 @@ function symbolContext(arg0, arg1) {
|
|
|
939
1229
|
var handle1 = arg0[symbolRscHandle];
|
|
940
1230
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
941
1231
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
var
|
|
945
|
-
var
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
let variant8;
|
|
1232
|
+
const ret = displaySymbolContext(handle0, toUint32(arg1));
|
|
1233
|
+
var len8 = dataView(memory0).getInt32(ret + 4, true);
|
|
1234
|
+
var base8 = dataView(memory0).getInt32(ret + 0, true);
|
|
1235
|
+
var result8 = [];
|
|
1236
|
+
for(let i = 0; i < len8; i++){
|
|
1237
|
+
const base = base8 + 24 * i;
|
|
1238
|
+
let variant7;
|
|
950
1239
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
951
1240
|
case 0:
|
|
952
1241
|
{
|
|
953
|
-
var
|
|
954
|
-
var
|
|
955
|
-
var
|
|
956
|
-
let
|
|
1242
|
+
var ptr2 = dataView(memory0).getInt32(base + 4, true);
|
|
1243
|
+
var len2 = dataView(memory0).getInt32(base + 8, true);
|
|
1244
|
+
var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
|
|
1245
|
+
let variant4;
|
|
957
1246
|
switch(dataView(memory0).getUint8(base + 12, true)){
|
|
958
1247
|
case 0:
|
|
959
|
-
|
|
1248
|
+
variant4 = void 0;
|
|
960
1249
|
break;
|
|
961
1250
|
case 1:
|
|
962
|
-
var
|
|
963
|
-
var
|
|
964
|
-
var
|
|
965
|
-
|
|
1251
|
+
var ptr3 = dataView(memory0).getInt32(base + 16, true);
|
|
1252
|
+
var len3 = dataView(memory0).getInt32(base + 20, true);
|
|
1253
|
+
var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
|
|
1254
|
+
variant4 = result3;
|
|
966
1255
|
break;
|
|
967
1256
|
default:
|
|
968
1257
|
throw new TypeError('invalid variant discriminant for option');
|
|
969
1258
|
}
|
|
970
|
-
|
|
1259
|
+
variant7 = {
|
|
971
1260
|
tag: 'copy',
|
|
972
1261
|
val: {
|
|
973
|
-
value:
|
|
974
|
-
label:
|
|
1262
|
+
value: result2,
|
|
1263
|
+
label: variant4
|
|
975
1264
|
}
|
|
976
1265
|
};
|
|
977
1266
|
break;
|
|
978
1267
|
}
|
|
979
1268
|
case 1:
|
|
980
1269
|
{
|
|
981
|
-
var
|
|
982
|
-
var
|
|
983
|
-
var
|
|
984
|
-
let
|
|
1270
|
+
var ptr5 = dataView(memory0).getInt32(base + 4, true);
|
|
1271
|
+
var len5 = dataView(memory0).getInt32(base + 8, true);
|
|
1272
|
+
var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
|
|
1273
|
+
let enum6;
|
|
985
1274
|
switch(dataView(memory0).getUint8(base + 16, true)){
|
|
986
1275
|
case 0:
|
|
987
|
-
|
|
1276
|
+
enum6 = 'normal';
|
|
988
1277
|
break;
|
|
989
1278
|
case 1:
|
|
990
|
-
|
|
1279
|
+
enum6 = 'extab';
|
|
991
1280
|
break;
|
|
992
1281
|
default:
|
|
993
1282
|
throw new TypeError('invalid discriminant specified for SymbolNavigationKind');
|
|
994
1283
|
}
|
|
995
|
-
|
|
1284
|
+
variant7 = {
|
|
996
1285
|
tag: 'navigate',
|
|
997
1286
|
val: {
|
|
998
|
-
label:
|
|
1287
|
+
label: result5,
|
|
999
1288
|
symbol: dataView(memory0).getInt32(base + 12, true) >>> 0,
|
|
1000
|
-
kind:
|
|
1289
|
+
kind: enum6
|
|
1001
1290
|
}
|
|
1002
1291
|
};
|
|
1003
1292
|
break;
|
|
1004
1293
|
}
|
|
1005
1294
|
case 2:
|
|
1006
|
-
|
|
1295
|
+
variant7 = {
|
|
1007
1296
|
tag: 'separator'
|
|
1008
1297
|
};
|
|
1009
1298
|
break;
|
|
1010
1299
|
default:
|
|
1011
1300
|
throw new TypeError('invalid variant discriminant for ContextItem');
|
|
1012
1301
|
}
|
|
1013
|
-
|
|
1302
|
+
result8.push(variant7);
|
|
1014
1303
|
}
|
|
1015
|
-
const retVal =
|
|
1016
|
-
|
|
1304
|
+
const retVal = result8;
|
|
1305
|
+
postReturn7(ret);
|
|
1017
1306
|
return retVal;
|
|
1018
1307
|
}
|
|
1019
1308
|
let displaySymbolHover;
|
|
@@ -1021,65 +1310,64 @@ function symbolHover(arg0, arg1) {
|
|
|
1021
1310
|
var handle1 = arg0[symbolRscHandle];
|
|
1022
1311
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
1023
1312
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
var
|
|
1027
|
-
var
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
let variant6;
|
|
1313
|
+
const ret = displaySymbolHover(handle0, toUint32(arg1));
|
|
1314
|
+
var len6 = dataView(memory0).getInt32(ret + 4, true);
|
|
1315
|
+
var base6 = dataView(memory0).getInt32(ret + 0, true);
|
|
1316
|
+
var result6 = [];
|
|
1317
|
+
for(let i = 0; i < len6; i++){
|
|
1318
|
+
const base = base6 + 24 * i;
|
|
1319
|
+
let variant5;
|
|
1032
1320
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
1033
1321
|
case 0:
|
|
1034
1322
|
{
|
|
1035
|
-
var
|
|
1036
|
-
var
|
|
1323
|
+
var ptr2 = dataView(memory0).getInt32(base + 4, true);
|
|
1324
|
+
var len2 = dataView(memory0).getInt32(base + 8, true);
|
|
1325
|
+
var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
|
|
1326
|
+
var ptr3 = dataView(memory0).getInt32(base + 12, true);
|
|
1327
|
+
var len3 = dataView(memory0).getInt32(base + 16, true);
|
|
1037
1328
|
var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
|
|
1038
|
-
|
|
1039
|
-
var len4 = dataView(memory0).getInt32(base + 16, true);
|
|
1040
|
-
var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
|
|
1041
|
-
let enum5;
|
|
1329
|
+
let enum4;
|
|
1042
1330
|
switch(dataView(memory0).getUint8(base + 20, true)){
|
|
1043
1331
|
case 0:
|
|
1044
|
-
|
|
1332
|
+
enum4 = 'normal';
|
|
1045
1333
|
break;
|
|
1046
1334
|
case 1:
|
|
1047
|
-
|
|
1335
|
+
enum4 = 'emphasized';
|
|
1048
1336
|
break;
|
|
1049
1337
|
case 2:
|
|
1050
|
-
|
|
1338
|
+
enum4 = 'special';
|
|
1051
1339
|
break;
|
|
1052
1340
|
case 3:
|
|
1053
|
-
|
|
1341
|
+
enum4 = 'delete';
|
|
1054
1342
|
break;
|
|
1055
1343
|
case 4:
|
|
1056
|
-
|
|
1344
|
+
enum4 = 'insert';
|
|
1057
1345
|
break;
|
|
1058
1346
|
default:
|
|
1059
1347
|
throw new TypeError('invalid discriminant specified for HoverItemColor');
|
|
1060
1348
|
}
|
|
1061
|
-
|
|
1349
|
+
variant5 = {
|
|
1062
1350
|
tag: 'text',
|
|
1063
1351
|
val: {
|
|
1064
|
-
label:
|
|
1065
|
-
value:
|
|
1066
|
-
color:
|
|
1352
|
+
label: result2,
|
|
1353
|
+
value: result3,
|
|
1354
|
+
color: enum4
|
|
1067
1355
|
}
|
|
1068
1356
|
};
|
|
1069
1357
|
break;
|
|
1070
1358
|
}
|
|
1071
1359
|
case 1:
|
|
1072
|
-
|
|
1360
|
+
variant5 = {
|
|
1073
1361
|
tag: 'separator'
|
|
1074
1362
|
};
|
|
1075
1363
|
break;
|
|
1076
1364
|
default:
|
|
1077
1365
|
throw new TypeError('invalid variant discriminant for HoverItem');
|
|
1078
1366
|
}
|
|
1079
|
-
|
|
1367
|
+
result6.push(variant5);
|
|
1080
1368
|
}
|
|
1081
|
-
const retVal =
|
|
1082
|
-
|
|
1369
|
+
const retVal = result6;
|
|
1370
|
+
postReturn8(ret);
|
|
1083
1371
|
return retVal;
|
|
1084
1372
|
}
|
|
1085
1373
|
let displayInstructionContext;
|
|
@@ -1087,84 +1375,83 @@ function instructionContext(arg0, arg1, arg2, arg3) {
|
|
|
1087
1375
|
var handle1 = arg0[symbolRscHandle];
|
|
1088
1376
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
1089
1377
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
1090
|
-
var
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
var
|
|
1096
|
-
var
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
let variant10;
|
|
1378
|
+
var handle3 = arg3[symbolRscHandle];
|
|
1379
|
+
if (!handle3 || (handleTable2[(handle3 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
1380
|
+
var handle2 = handleTable2[(handle3 << 1) + 1] & ~T_FLAG;
|
|
1381
|
+
const ret = displayInstructionContext(handle0, toUint32(arg1), toUint32(arg2), handle2);
|
|
1382
|
+
var len10 = dataView(memory0).getInt32(ret + 4, true);
|
|
1383
|
+
var base10 = dataView(memory0).getInt32(ret + 0, true);
|
|
1384
|
+
var result10 = [];
|
|
1385
|
+
for(let i = 0; i < len10; i++){
|
|
1386
|
+
const base = base10 + 24 * i;
|
|
1387
|
+
let variant9;
|
|
1101
1388
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
1102
1389
|
case 0:
|
|
1103
1390
|
{
|
|
1104
|
-
var
|
|
1105
|
-
var
|
|
1106
|
-
var
|
|
1107
|
-
let
|
|
1391
|
+
var ptr4 = dataView(memory0).getInt32(base + 4, true);
|
|
1392
|
+
var len4 = dataView(memory0).getInt32(base + 8, true);
|
|
1393
|
+
var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
|
|
1394
|
+
let variant6;
|
|
1108
1395
|
switch(dataView(memory0).getUint8(base + 12, true)){
|
|
1109
1396
|
case 0:
|
|
1110
|
-
|
|
1397
|
+
variant6 = void 0;
|
|
1111
1398
|
break;
|
|
1112
1399
|
case 1:
|
|
1113
|
-
var
|
|
1114
|
-
var
|
|
1115
|
-
var
|
|
1116
|
-
|
|
1400
|
+
var ptr5 = dataView(memory0).getInt32(base + 16, true);
|
|
1401
|
+
var len5 = dataView(memory0).getInt32(base + 20, true);
|
|
1402
|
+
var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
|
|
1403
|
+
variant6 = result5;
|
|
1117
1404
|
break;
|
|
1118
1405
|
default:
|
|
1119
1406
|
throw new TypeError('invalid variant discriminant for option');
|
|
1120
1407
|
}
|
|
1121
|
-
|
|
1408
|
+
variant9 = {
|
|
1122
1409
|
tag: 'copy',
|
|
1123
1410
|
val: {
|
|
1124
|
-
value:
|
|
1125
|
-
label:
|
|
1411
|
+
value: result4,
|
|
1412
|
+
label: variant6
|
|
1126
1413
|
}
|
|
1127
1414
|
};
|
|
1128
1415
|
break;
|
|
1129
1416
|
}
|
|
1130
1417
|
case 1:
|
|
1131
1418
|
{
|
|
1132
|
-
var
|
|
1133
|
-
var
|
|
1134
|
-
var
|
|
1135
|
-
let
|
|
1419
|
+
var ptr7 = dataView(memory0).getInt32(base + 4, true);
|
|
1420
|
+
var len7 = dataView(memory0).getInt32(base + 8, true);
|
|
1421
|
+
var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
|
|
1422
|
+
let enum8;
|
|
1136
1423
|
switch(dataView(memory0).getUint8(base + 16, true)){
|
|
1137
1424
|
case 0:
|
|
1138
|
-
|
|
1425
|
+
enum8 = 'normal';
|
|
1139
1426
|
break;
|
|
1140
1427
|
case 1:
|
|
1141
|
-
|
|
1428
|
+
enum8 = 'extab';
|
|
1142
1429
|
break;
|
|
1143
1430
|
default:
|
|
1144
1431
|
throw new TypeError('invalid discriminant specified for SymbolNavigationKind');
|
|
1145
1432
|
}
|
|
1146
|
-
|
|
1433
|
+
variant9 = {
|
|
1147
1434
|
tag: 'navigate',
|
|
1148
1435
|
val: {
|
|
1149
|
-
label:
|
|
1436
|
+
label: result7,
|
|
1150
1437
|
symbol: dataView(memory0).getInt32(base + 12, true) >>> 0,
|
|
1151
|
-
kind:
|
|
1438
|
+
kind: enum8
|
|
1152
1439
|
}
|
|
1153
1440
|
};
|
|
1154
1441
|
break;
|
|
1155
1442
|
}
|
|
1156
1443
|
case 2:
|
|
1157
|
-
|
|
1444
|
+
variant9 = {
|
|
1158
1445
|
tag: 'separator'
|
|
1159
1446
|
};
|
|
1160
1447
|
break;
|
|
1161
1448
|
default:
|
|
1162
1449
|
throw new TypeError('invalid variant discriminant for ContextItem');
|
|
1163
1450
|
}
|
|
1164
|
-
|
|
1451
|
+
result10.push(variant9);
|
|
1165
1452
|
}
|
|
1166
|
-
const retVal =
|
|
1167
|
-
|
|
1453
|
+
const retVal = result10;
|
|
1454
|
+
postReturn7(ret);
|
|
1168
1455
|
return retVal;
|
|
1169
1456
|
}
|
|
1170
1457
|
let displayInstructionHover;
|
|
@@ -1172,68 +1459,67 @@ function instructionHover(arg0, arg1, arg2, arg3) {
|
|
|
1172
1459
|
var handle1 = arg0[symbolRscHandle];
|
|
1173
1460
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
1174
1461
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
1175
|
-
var
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
var
|
|
1181
|
-
var
|
|
1182
|
-
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
let variant8;
|
|
1462
|
+
var handle3 = arg3[symbolRscHandle];
|
|
1463
|
+
if (!handle3 || (handleTable2[(handle3 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
1464
|
+
var handle2 = handleTable2[(handle3 << 1) + 1] & ~T_FLAG;
|
|
1465
|
+
const ret = displayInstructionHover(handle0, toUint32(arg1), toUint32(arg2), handle2);
|
|
1466
|
+
var len8 = dataView(memory0).getInt32(ret + 4, true);
|
|
1467
|
+
var base8 = dataView(memory0).getInt32(ret + 0, true);
|
|
1468
|
+
var result8 = [];
|
|
1469
|
+
for(let i = 0; i < len8; i++){
|
|
1470
|
+
const base = base8 + 24 * i;
|
|
1471
|
+
let variant7;
|
|
1186
1472
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
1187
1473
|
case 0:
|
|
1188
1474
|
{
|
|
1189
|
-
var
|
|
1190
|
-
var
|
|
1475
|
+
var ptr4 = dataView(memory0).getInt32(base + 4, true);
|
|
1476
|
+
var len4 = dataView(memory0).getInt32(base + 8, true);
|
|
1477
|
+
var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
|
|
1478
|
+
var ptr5 = dataView(memory0).getInt32(base + 12, true);
|
|
1479
|
+
var len5 = dataView(memory0).getInt32(base + 16, true);
|
|
1191
1480
|
var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
|
|
1192
|
-
|
|
1193
|
-
var len6 = dataView(memory0).getInt32(base + 16, true);
|
|
1194
|
-
var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
|
|
1195
|
-
let enum7;
|
|
1481
|
+
let enum6;
|
|
1196
1482
|
switch(dataView(memory0).getUint8(base + 20, true)){
|
|
1197
1483
|
case 0:
|
|
1198
|
-
|
|
1484
|
+
enum6 = 'normal';
|
|
1199
1485
|
break;
|
|
1200
1486
|
case 1:
|
|
1201
|
-
|
|
1487
|
+
enum6 = 'emphasized';
|
|
1202
1488
|
break;
|
|
1203
1489
|
case 2:
|
|
1204
|
-
|
|
1490
|
+
enum6 = 'special';
|
|
1205
1491
|
break;
|
|
1206
1492
|
case 3:
|
|
1207
|
-
|
|
1493
|
+
enum6 = 'delete';
|
|
1208
1494
|
break;
|
|
1209
1495
|
case 4:
|
|
1210
|
-
|
|
1496
|
+
enum6 = 'insert';
|
|
1211
1497
|
break;
|
|
1212
1498
|
default:
|
|
1213
1499
|
throw new TypeError('invalid discriminant specified for HoverItemColor');
|
|
1214
1500
|
}
|
|
1215
|
-
|
|
1501
|
+
variant7 = {
|
|
1216
1502
|
tag: 'text',
|
|
1217
1503
|
val: {
|
|
1218
|
-
label:
|
|
1219
|
-
value:
|
|
1220
|
-
color:
|
|
1504
|
+
label: result4,
|
|
1505
|
+
value: result5,
|
|
1506
|
+
color: enum6
|
|
1221
1507
|
}
|
|
1222
1508
|
};
|
|
1223
1509
|
break;
|
|
1224
1510
|
}
|
|
1225
1511
|
case 1:
|
|
1226
|
-
|
|
1512
|
+
variant7 = {
|
|
1227
1513
|
tag: 'separator'
|
|
1228
1514
|
};
|
|
1229
1515
|
break;
|
|
1230
1516
|
default:
|
|
1231
1517
|
throw new TypeError('invalid variant discriminant for HoverItem');
|
|
1232
1518
|
}
|
|
1233
|
-
|
|
1519
|
+
result8.push(variant7);
|
|
1234
1520
|
}
|
|
1235
|
-
const retVal =
|
|
1236
|
-
|
|
1521
|
+
const retVal = result8;
|
|
1522
|
+
postReturn8(ret);
|
|
1237
1523
|
return retVal;
|
|
1238
1524
|
}
|
|
1239
1525
|
const $init = (()=>{
|
|
@@ -1266,11 +1552,12 @@ const $init = (()=>{
|
|
|
1266
1552
|
realloc0 = exports1.cabi_realloc;
|
|
1267
1553
|
postReturn1 = exports1['cabi_post_objdiff:core/diff#[method]diff-config.set-property'];
|
|
1268
1554
|
postReturn2 = exports1['cabi_post_objdiff:core/diff#[method]diff-config.get-property'];
|
|
1269
|
-
postReturn3 = exports1['cabi_post_objdiff:core/
|
|
1270
|
-
postReturn4 = exports1['cabi_post_objdiff:core/display#display-
|
|
1271
|
-
postReturn5 = exports1['cabi_post_objdiff:core/display#display-
|
|
1272
|
-
postReturn6 = exports1['cabi_post_objdiff:core/display#
|
|
1273
|
-
postReturn7 = exports1['cabi_post_objdiff:core/display#
|
|
1555
|
+
postReturn3 = exports1['cabi_post_objdiff:core/diff#[method]object-diff.find-symbol'];
|
|
1556
|
+
postReturn4 = exports1['cabi_post_objdiff:core/display#display-sections'];
|
|
1557
|
+
postReturn5 = exports1['cabi_post_objdiff:core/display#display-symbol'];
|
|
1558
|
+
postReturn6 = exports1['cabi_post_objdiff:core/display#display-instruction-row'];
|
|
1559
|
+
postReturn7 = exports1['cabi_post_objdiff:core/display#symbol-context'];
|
|
1560
|
+
postReturn8 = exports1['cabi_post_objdiff:core/display#instruction-hover'];
|
|
1274
1561
|
exports1Init = exports1.init;
|
|
1275
1562
|
exports1Version = exports1.version;
|
|
1276
1563
|
diffConstructorDiffConfig = exports1['objdiff:core/diff#[constructor]diff-config'];
|
|
@@ -1279,6 +1566,7 @@ const $init = (()=>{
|
|
|
1279
1566
|
diffStaticObjectParse = exports1['objdiff:core/diff#[static]object.parse'];
|
|
1280
1567
|
diffMethodObjectHash = exports1['objdiff:core/diff#[method]object.hash'];
|
|
1281
1568
|
diffMethodObjectDiffFindSymbol = exports1['objdiff:core/diff#[method]object-diff.find-symbol'];
|
|
1569
|
+
diffMethodObjectDiffGetSymbol = exports1['objdiff:core/diff#[method]object-diff.get-symbol'];
|
|
1282
1570
|
diffRunDiff = exports1['objdiff:core/diff#run-diff'];
|
|
1283
1571
|
displayDisplaySections = exports1['objdiff:core/display#display-sections'];
|
|
1284
1572
|
displayDisplaySymbol = exports1['objdiff:core/display#display-symbol'];
|