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