objdiff-wasm 3.0.0-beta.8 → 3.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/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,13 +118,14 @@ 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
|
|
127
125
|
];
|
|
128
126
|
const finalizationRegistry0 = finalizationRegistryCreate((handle)=>{
|
|
129
127
|
const { rep } = rscTableRemove(handleTable0, handle);
|
|
130
|
-
exports0['
|
|
128
|
+
exports0['1'](rep);
|
|
131
129
|
});
|
|
132
130
|
handleTables[0] = handleTable0;
|
|
133
131
|
const trampoline0 = rscTableCreateOwn.bind(null, handleTable0);
|
|
@@ -147,7 +145,7 @@ const handleTable2 = [
|
|
|
147
145
|
];
|
|
148
146
|
const finalizationRegistry2 = finalizationRegistryCreate((handle)=>{
|
|
149
147
|
const { rep } = rscTableRemove(handleTable2, handle);
|
|
150
|
-
exports0['
|
|
148
|
+
exports0['3'](rep);
|
|
151
149
|
});
|
|
152
150
|
handleTables[2] = handleTable2;
|
|
153
151
|
const trampoline2 = rscTableCreateOwn.bind(null, handleTable2);
|
|
@@ -200,15 +198,15 @@ class DiffConfig {
|
|
|
200
198
|
writable: true,
|
|
201
199
|
value: handle1
|
|
202
200
|
});
|
|
203
|
-
|
|
201
|
+
finalizationRegistry1.register(rsc0, handle1, rsc0);
|
|
204
202
|
Object.defineProperty(rsc0, symbolDispose, {
|
|
205
203
|
writable: true,
|
|
206
204
|
value: function() {
|
|
207
|
-
|
|
208
|
-
rscTableRemove(
|
|
205
|
+
finalizationRegistry1.unregister(rsc0);
|
|
206
|
+
rscTableRemove(handleTable1, handle1);
|
|
209
207
|
rsc0[symbolDispose] = emptyFunc;
|
|
210
208
|
rsc0[symbolRscHandle] = void 0;
|
|
211
|
-
exports0['
|
|
209
|
+
exports0['2'](handleTable1[(handle1 << 1) + 1] & ~T_FLAG);
|
|
212
210
|
}
|
|
213
211
|
});
|
|
214
212
|
return rsc0;
|
|
@@ -217,8 +215,8 @@ class DiffConfig {
|
|
|
217
215
|
let diffMethodDiffConfigSetProperty;
|
|
218
216
|
DiffConfig.prototype.setProperty = function(arg1, arg2) {
|
|
219
217
|
var handle1 = this[symbolRscHandle];
|
|
220
|
-
if (!handle1 || (
|
|
221
|
-
var handle0 =
|
|
218
|
+
if (!handle1 || (handleTable1[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
219
|
+
var handle0 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
|
|
222
220
|
var ptr2 = utf8Encode(arg1, realloc0, memory0);
|
|
223
221
|
var len2 = utf8EncodedLen;
|
|
224
222
|
var ptr3 = utf8Encode(arg2, realloc0, memory0);
|
|
@@ -252,8 +250,8 @@ DiffConfig.prototype.setProperty = function(arg1, arg2) {
|
|
|
252
250
|
let diffMethodDiffConfigGetProperty;
|
|
253
251
|
DiffConfig.prototype.getProperty = function(arg1) {
|
|
254
252
|
var handle1 = this[symbolRscHandle];
|
|
255
|
-
if (!handle1 || (
|
|
256
|
-
var handle0 =
|
|
253
|
+
if (!handle1 || (handleTable1[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
254
|
+
var handle0 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
|
|
257
255
|
var ptr2 = utf8Encode(arg1, realloc0, memory0);
|
|
258
256
|
var len2 = utf8EncodedLen;
|
|
259
257
|
const ret = diffMethodDiffConfigGetProperty(handle0, ptr2, len2);
|
|
@@ -298,8 +296,8 @@ Object$1.parse = function(arg0, arg1) {
|
|
|
298
296
|
var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, +len0);
|
|
299
297
|
new Uint8Array(memory0.buffer, ptr0, +len0).set(src0);
|
|
300
298
|
var handle2 = arg1[symbolRscHandle];
|
|
301
|
-
if (!handle2 || (
|
|
302
|
-
var handle1 =
|
|
299
|
+
if (!handle2 || (handleTable1[(handle2 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
300
|
+
var handle1 = handleTable1[(handle2 << 1) + 1] & ~T_FLAG;
|
|
303
301
|
const ret = diffStaticObjectParse(ptr0, len0, handle1);
|
|
304
302
|
let variant6;
|
|
305
303
|
switch(dataView(memory0).getUint8(ret + 0, true)){
|
|
@@ -310,15 +308,15 @@ Object$1.parse = function(arg0, arg1) {
|
|
|
310
308
|
writable: true,
|
|
311
309
|
value: handle4
|
|
312
310
|
});
|
|
313
|
-
|
|
311
|
+
finalizationRegistry2.register(rsc3, handle4, rsc3);
|
|
314
312
|
Object.defineProperty(rsc3, symbolDispose, {
|
|
315
313
|
writable: true,
|
|
316
314
|
value: function() {
|
|
317
|
-
|
|
318
|
-
rscTableRemove(
|
|
315
|
+
finalizationRegistry2.unregister(rsc3);
|
|
316
|
+
rscTableRemove(handleTable2, handle4);
|
|
319
317
|
rsc3[symbolDispose] = emptyFunc;
|
|
320
318
|
rsc3[symbolRscHandle] = void 0;
|
|
321
|
-
exports0['
|
|
319
|
+
exports0['3'](handleTable2[(handle4 << 1) + 1] & ~T_FLAG);
|
|
322
320
|
}
|
|
323
321
|
});
|
|
324
322
|
variant6 = {
|
|
@@ -346,8 +344,8 @@ Object$1.parse = function(arg0, arg1) {
|
|
|
346
344
|
let diffMethodObjectHash;
|
|
347
345
|
Object$1.prototype.hash = function() {
|
|
348
346
|
var handle1 = this[symbolRscHandle];
|
|
349
|
-
if (!handle1 || (
|
|
350
|
-
var handle0 =
|
|
347
|
+
if (!handle1 || (handleTable2[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "Object" resource.');
|
|
348
|
+
var handle0 = handleTable2[(handle1 << 1) + 1] & ~T_FLAG;
|
|
351
349
|
const ret = diffMethodObjectHash(handle0);
|
|
352
350
|
return BigInt.asUintN(64, ret);
|
|
353
351
|
};
|
|
@@ -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;
|
|
@@ -404,8 +637,8 @@ function runDiff(arg0, arg1, arg2) {
|
|
|
404
637
|
} else {
|
|
405
638
|
const e = variant2;
|
|
406
639
|
var handle1 = e[symbolRscHandle];
|
|
407
|
-
if (!handle1 || (
|
|
408
|
-
var handle0 =
|
|
640
|
+
if (!handle1 || (handleTable2[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "Object" resource.');
|
|
641
|
+
var handle0 = handleTable2[(handle1 << 1) + 1] & ~T_FLAG;
|
|
409
642
|
variant2_0 = 1;
|
|
410
643
|
variant2_1 = handle0;
|
|
411
644
|
}
|
|
@@ -418,97 +651,146 @@ function runDiff(arg0, arg1, arg2) {
|
|
|
418
651
|
} else {
|
|
419
652
|
const e = variant5;
|
|
420
653
|
var handle4 = e[symbolRscHandle];
|
|
421
|
-
if (!handle4 || (
|
|
422
|
-
var handle3 =
|
|
654
|
+
if (!handle4 || (handleTable2[(handle4 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "Object" resource.');
|
|
655
|
+
var handle3 = handleTable2[(handle4 << 1) + 1] & ~T_FLAG;
|
|
423
656
|
variant5_0 = 1;
|
|
424
657
|
variant5_1 = handle3;
|
|
425
658
|
}
|
|
426
659
|
var handle7 = arg2[symbolRscHandle];
|
|
427
|
-
if (!handle7 || (
|
|
428
|
-
var handle6 =
|
|
429
|
-
|
|
430
|
-
|
|
660
|
+
if (!handle7 || (handleTable1[(handle7 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
661
|
+
var handle6 = handleTable1[(handle7 << 1) + 1] & ~T_FLAG;
|
|
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['
|
|
732
|
+
finalizationRegistry0.unregister(rsc17);
|
|
733
|
+
rscTableRemove(handleTable0, handle18);
|
|
734
|
+
rsc17[symbolDispose] = emptyFunc;
|
|
735
|
+
rsc17[symbolRscHandle] = void 0;
|
|
736
|
+
exports0['1'](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['
|
|
760
|
+
finalizationRegistry0.unregister(rsc20);
|
|
761
|
+
rscTableRemove(handleTable0, handle21);
|
|
762
|
+
rsc20[symbolDispose] = emptyFunc;
|
|
763
|
+
rsc20[symbolRscHandle] = void 0;
|
|
764
|
+
exports0['1'](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,164 @@ 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 || (handleTable1[(handle3 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
1033
|
+
var handle2 = handleTable1[(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
|
-
|
|
884
|
-
tag: '
|
|
1173
|
+
variant11 = {
|
|
1174
|
+
tag: 'data-flow'
|
|
885
1175
|
};
|
|
886
1176
|
break;
|
|
887
1177
|
case 5:
|
|
888
|
-
|
|
889
|
-
tag: '
|
|
1178
|
+
variant11 = {
|
|
1179
|
+
tag: 'delete'
|
|
890
1180
|
};
|
|
891
1181
|
break;
|
|
892
1182
|
case 6:
|
|
893
|
-
|
|
1183
|
+
variant11 = {
|
|
1184
|
+
tag: 'insert'
|
|
1185
|
+
};
|
|
1186
|
+
break;
|
|
1187
|
+
case 7:
|
|
1188
|
+
variant11 = {
|
|
894
1189
|
tag: 'rotating',
|
|
895
1190
|
val: clampGuest(dataView(memory0).getUint8(base + 33, true), 0, 255)
|
|
896
1191
|
};
|
|
@@ -898,40 +1193,40 @@ function displayInstructionRow(arg0, arg1, arg2, arg3) {
|
|
|
898
1193
|
default:
|
|
899
1194
|
throw new TypeError('invalid variant discriminant for DiffTextColor');
|
|
900
1195
|
}
|
|
901
|
-
|
|
902
|
-
text:
|
|
903
|
-
color:
|
|
1196
|
+
result12.push({
|
|
1197
|
+
text: variant10,
|
|
1198
|
+
color: variant11,
|
|
904
1199
|
padTo: clampGuest(dataView(memory0).getUint8(base + 34, true), 0, 255)
|
|
905
1200
|
});
|
|
906
1201
|
}
|
|
907
|
-
let
|
|
1202
|
+
let enum13;
|
|
908
1203
|
switch(dataView(memory0).getUint8(ret + 8, true)){
|
|
909
1204
|
case 0:
|
|
910
|
-
|
|
1205
|
+
enum13 = 'none';
|
|
911
1206
|
break;
|
|
912
1207
|
case 1:
|
|
913
|
-
|
|
1208
|
+
enum13 = 'op-mismatch';
|
|
914
1209
|
break;
|
|
915
1210
|
case 2:
|
|
916
|
-
|
|
1211
|
+
enum13 = 'arg-mismatch';
|
|
917
1212
|
break;
|
|
918
1213
|
case 3:
|
|
919
|
-
|
|
1214
|
+
enum13 = 'replace';
|
|
920
1215
|
break;
|
|
921
1216
|
case 4:
|
|
922
|
-
|
|
1217
|
+
enum13 = 'insert';
|
|
923
1218
|
break;
|
|
924
1219
|
case 5:
|
|
925
|
-
|
|
1220
|
+
enum13 = 'delete';
|
|
926
1221
|
break;
|
|
927
1222
|
default:
|
|
928
1223
|
throw new TypeError('invalid discriminant specified for InstructionDiffKind');
|
|
929
1224
|
}
|
|
930
1225
|
const retVal = {
|
|
931
|
-
segments:
|
|
932
|
-
diffKind:
|
|
1226
|
+
segments: result12,
|
|
1227
|
+
diffKind: enum13
|
|
933
1228
|
};
|
|
934
|
-
|
|
1229
|
+
postReturn6(ret);
|
|
935
1230
|
return retVal;
|
|
936
1231
|
}
|
|
937
1232
|
let displaySymbolContext;
|
|
@@ -939,81 +1234,80 @@ function symbolContext(arg0, arg1) {
|
|
|
939
1234
|
var handle1 = arg0[symbolRscHandle];
|
|
940
1235
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
941
1236
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
var
|
|
945
|
-
var
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
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;
|
|
950
1244
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
951
1245
|
case 0:
|
|
952
1246
|
{
|
|
953
|
-
var
|
|
954
|
-
var
|
|
955
|
-
var
|
|
956
|
-
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;
|
|
957
1251
|
switch(dataView(memory0).getUint8(base + 12, true)){
|
|
958
1252
|
case 0:
|
|
959
|
-
|
|
1253
|
+
variant4 = void 0;
|
|
960
1254
|
break;
|
|
961
1255
|
case 1:
|
|
962
|
-
var
|
|
963
|
-
var
|
|
964
|
-
var
|
|
965
|
-
|
|
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;
|
|
966
1260
|
break;
|
|
967
1261
|
default:
|
|
968
1262
|
throw new TypeError('invalid variant discriminant for option');
|
|
969
1263
|
}
|
|
970
|
-
|
|
1264
|
+
variant7 = {
|
|
971
1265
|
tag: 'copy',
|
|
972
1266
|
val: {
|
|
973
|
-
value:
|
|
974
|
-
label:
|
|
1267
|
+
value: result2,
|
|
1268
|
+
label: variant4
|
|
975
1269
|
}
|
|
976
1270
|
};
|
|
977
1271
|
break;
|
|
978
1272
|
}
|
|
979
1273
|
case 1:
|
|
980
1274
|
{
|
|
981
|
-
var
|
|
982
|
-
var
|
|
983
|
-
var
|
|
984
|
-
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;
|
|
985
1279
|
switch(dataView(memory0).getUint8(base + 16, true)){
|
|
986
1280
|
case 0:
|
|
987
|
-
|
|
1281
|
+
enum6 = 'normal';
|
|
988
1282
|
break;
|
|
989
1283
|
case 1:
|
|
990
|
-
|
|
1284
|
+
enum6 = 'extab';
|
|
991
1285
|
break;
|
|
992
1286
|
default:
|
|
993
1287
|
throw new TypeError('invalid discriminant specified for SymbolNavigationKind');
|
|
994
1288
|
}
|
|
995
|
-
|
|
1289
|
+
variant7 = {
|
|
996
1290
|
tag: 'navigate',
|
|
997
1291
|
val: {
|
|
998
|
-
label:
|
|
1292
|
+
label: result5,
|
|
999
1293
|
symbol: dataView(memory0).getInt32(base + 12, true) >>> 0,
|
|
1000
|
-
kind:
|
|
1294
|
+
kind: enum6
|
|
1001
1295
|
}
|
|
1002
1296
|
};
|
|
1003
1297
|
break;
|
|
1004
1298
|
}
|
|
1005
1299
|
case 2:
|
|
1006
|
-
|
|
1300
|
+
variant7 = {
|
|
1007
1301
|
tag: 'separator'
|
|
1008
1302
|
};
|
|
1009
1303
|
break;
|
|
1010
1304
|
default:
|
|
1011
1305
|
throw new TypeError('invalid variant discriminant for ContextItem');
|
|
1012
1306
|
}
|
|
1013
|
-
|
|
1307
|
+
result8.push(variant7);
|
|
1014
1308
|
}
|
|
1015
|
-
const retVal =
|
|
1016
|
-
|
|
1309
|
+
const retVal = result8;
|
|
1310
|
+
postReturn7(ret);
|
|
1017
1311
|
return retVal;
|
|
1018
1312
|
}
|
|
1019
1313
|
let displaySymbolHover;
|
|
@@ -1021,65 +1315,64 @@ function symbolHover(arg0, arg1) {
|
|
|
1021
1315
|
var handle1 = arg0[symbolRscHandle];
|
|
1022
1316
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
1023
1317
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
var
|
|
1027
|
-
var
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
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;
|
|
1032
1325
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
1033
1326
|
case 0:
|
|
1034
1327
|
{
|
|
1035
|
-
var
|
|
1036
|
-
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);
|
|
1037
1333
|
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;
|
|
1334
|
+
let enum4;
|
|
1042
1335
|
switch(dataView(memory0).getUint8(base + 20, true)){
|
|
1043
1336
|
case 0:
|
|
1044
|
-
|
|
1337
|
+
enum4 = 'normal';
|
|
1045
1338
|
break;
|
|
1046
1339
|
case 1:
|
|
1047
|
-
|
|
1340
|
+
enum4 = 'emphasized';
|
|
1048
1341
|
break;
|
|
1049
1342
|
case 2:
|
|
1050
|
-
|
|
1343
|
+
enum4 = 'special';
|
|
1051
1344
|
break;
|
|
1052
1345
|
case 3:
|
|
1053
|
-
|
|
1346
|
+
enum4 = 'delete';
|
|
1054
1347
|
break;
|
|
1055
1348
|
case 4:
|
|
1056
|
-
|
|
1349
|
+
enum4 = 'insert';
|
|
1057
1350
|
break;
|
|
1058
1351
|
default:
|
|
1059
1352
|
throw new TypeError('invalid discriminant specified for HoverItemColor');
|
|
1060
1353
|
}
|
|
1061
|
-
|
|
1354
|
+
variant5 = {
|
|
1062
1355
|
tag: 'text',
|
|
1063
1356
|
val: {
|
|
1064
|
-
label:
|
|
1065
|
-
value:
|
|
1066
|
-
color:
|
|
1357
|
+
label: result2,
|
|
1358
|
+
value: result3,
|
|
1359
|
+
color: enum4
|
|
1067
1360
|
}
|
|
1068
1361
|
};
|
|
1069
1362
|
break;
|
|
1070
1363
|
}
|
|
1071
1364
|
case 1:
|
|
1072
|
-
|
|
1365
|
+
variant5 = {
|
|
1073
1366
|
tag: 'separator'
|
|
1074
1367
|
};
|
|
1075
1368
|
break;
|
|
1076
1369
|
default:
|
|
1077
1370
|
throw new TypeError('invalid variant discriminant for HoverItem');
|
|
1078
1371
|
}
|
|
1079
|
-
|
|
1372
|
+
result6.push(variant5);
|
|
1080
1373
|
}
|
|
1081
|
-
const retVal =
|
|
1082
|
-
|
|
1374
|
+
const retVal = result6;
|
|
1375
|
+
postReturn8(ret);
|
|
1083
1376
|
return retVal;
|
|
1084
1377
|
}
|
|
1085
1378
|
let displayInstructionContext;
|
|
@@ -1087,84 +1380,83 @@ function instructionContext(arg0, arg1, arg2, arg3) {
|
|
|
1087
1380
|
var handle1 = arg0[symbolRscHandle];
|
|
1088
1381
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
1089
1382
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
1090
|
-
var
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
var
|
|
1096
|
-
var
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
let variant10;
|
|
1383
|
+
var handle3 = arg3[symbolRscHandle];
|
|
1384
|
+
if (!handle3 || (handleTable1[(handle3 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
1385
|
+
var handle2 = handleTable1[(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;
|
|
1101
1393
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
1102
1394
|
case 0:
|
|
1103
1395
|
{
|
|
1104
|
-
var
|
|
1105
|
-
var
|
|
1106
|
-
var
|
|
1107
|
-
let
|
|
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;
|
|
1108
1400
|
switch(dataView(memory0).getUint8(base + 12, true)){
|
|
1109
1401
|
case 0:
|
|
1110
|
-
|
|
1402
|
+
variant6 = void 0;
|
|
1111
1403
|
break;
|
|
1112
1404
|
case 1:
|
|
1113
|
-
var
|
|
1114
|
-
var
|
|
1115
|
-
var
|
|
1116
|
-
|
|
1405
|
+
var ptr5 = dataView(memory0).getInt32(base + 16, true);
|
|
1406
|
+
var len5 = dataView(memory0).getInt32(base + 20, true);
|
|
1407
|
+
var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
|
|
1408
|
+
variant6 = result5;
|
|
1117
1409
|
break;
|
|
1118
1410
|
default:
|
|
1119
1411
|
throw new TypeError('invalid variant discriminant for option');
|
|
1120
1412
|
}
|
|
1121
|
-
|
|
1413
|
+
variant9 = {
|
|
1122
1414
|
tag: 'copy',
|
|
1123
1415
|
val: {
|
|
1124
|
-
value:
|
|
1125
|
-
label:
|
|
1416
|
+
value: result4,
|
|
1417
|
+
label: variant6
|
|
1126
1418
|
}
|
|
1127
1419
|
};
|
|
1128
1420
|
break;
|
|
1129
1421
|
}
|
|
1130
1422
|
case 1:
|
|
1131
1423
|
{
|
|
1132
|
-
var
|
|
1133
|
-
var
|
|
1134
|
-
var
|
|
1135
|
-
let
|
|
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;
|
|
1136
1428
|
switch(dataView(memory0).getUint8(base + 16, true)){
|
|
1137
1429
|
case 0:
|
|
1138
|
-
|
|
1430
|
+
enum8 = 'normal';
|
|
1139
1431
|
break;
|
|
1140
1432
|
case 1:
|
|
1141
|
-
|
|
1433
|
+
enum8 = 'extab';
|
|
1142
1434
|
break;
|
|
1143
1435
|
default:
|
|
1144
1436
|
throw new TypeError('invalid discriminant specified for SymbolNavigationKind');
|
|
1145
1437
|
}
|
|
1146
|
-
|
|
1438
|
+
variant9 = {
|
|
1147
1439
|
tag: 'navigate',
|
|
1148
1440
|
val: {
|
|
1149
|
-
label:
|
|
1441
|
+
label: result7,
|
|
1150
1442
|
symbol: dataView(memory0).getInt32(base + 12, true) >>> 0,
|
|
1151
|
-
kind:
|
|
1443
|
+
kind: enum8
|
|
1152
1444
|
}
|
|
1153
1445
|
};
|
|
1154
1446
|
break;
|
|
1155
1447
|
}
|
|
1156
1448
|
case 2:
|
|
1157
|
-
|
|
1449
|
+
variant9 = {
|
|
1158
1450
|
tag: 'separator'
|
|
1159
1451
|
};
|
|
1160
1452
|
break;
|
|
1161
1453
|
default:
|
|
1162
1454
|
throw new TypeError('invalid variant discriminant for ContextItem');
|
|
1163
1455
|
}
|
|
1164
|
-
|
|
1456
|
+
result10.push(variant9);
|
|
1165
1457
|
}
|
|
1166
|
-
const retVal =
|
|
1167
|
-
|
|
1458
|
+
const retVal = result10;
|
|
1459
|
+
postReturn7(ret);
|
|
1168
1460
|
return retVal;
|
|
1169
1461
|
}
|
|
1170
1462
|
let displayInstructionHover;
|
|
@@ -1172,80 +1464,79 @@ function instructionHover(arg0, arg1, arg2, arg3) {
|
|
|
1172
1464
|
var handle1 = arg0[symbolRscHandle];
|
|
1173
1465
|
if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
|
|
1174
1466
|
var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
|
|
1175
|
-
var
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
var
|
|
1181
|
-
var
|
|
1182
|
-
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
let variant8;
|
|
1467
|
+
var handle3 = arg3[symbolRscHandle];
|
|
1468
|
+
if (!handle3 || (handleTable1[(handle3 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
|
|
1469
|
+
var handle2 = handleTable1[(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;
|
|
1186
1477
|
switch(dataView(memory0).getUint8(base + 0, true)){
|
|
1187
1478
|
case 0:
|
|
1188
1479
|
{
|
|
1189
|
-
var
|
|
1190
|
-
var
|
|
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);
|
|
1191
1485
|
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;
|
|
1486
|
+
let enum6;
|
|
1196
1487
|
switch(dataView(memory0).getUint8(base + 20, true)){
|
|
1197
1488
|
case 0:
|
|
1198
|
-
|
|
1489
|
+
enum6 = 'normal';
|
|
1199
1490
|
break;
|
|
1200
1491
|
case 1:
|
|
1201
|
-
|
|
1492
|
+
enum6 = 'emphasized';
|
|
1202
1493
|
break;
|
|
1203
1494
|
case 2:
|
|
1204
|
-
|
|
1495
|
+
enum6 = 'special';
|
|
1205
1496
|
break;
|
|
1206
1497
|
case 3:
|
|
1207
|
-
|
|
1498
|
+
enum6 = 'delete';
|
|
1208
1499
|
break;
|
|
1209
1500
|
case 4:
|
|
1210
|
-
|
|
1501
|
+
enum6 = 'insert';
|
|
1211
1502
|
break;
|
|
1212
1503
|
default:
|
|
1213
1504
|
throw new TypeError('invalid discriminant specified for HoverItemColor');
|
|
1214
1505
|
}
|
|
1215
|
-
|
|
1506
|
+
variant7 = {
|
|
1216
1507
|
tag: 'text',
|
|
1217
1508
|
val: {
|
|
1218
|
-
label:
|
|
1219
|
-
value:
|
|
1220
|
-
color:
|
|
1509
|
+
label: result4,
|
|
1510
|
+
value: result5,
|
|
1511
|
+
color: enum6
|
|
1221
1512
|
}
|
|
1222
1513
|
};
|
|
1223
1514
|
break;
|
|
1224
1515
|
}
|
|
1225
1516
|
case 1:
|
|
1226
|
-
|
|
1517
|
+
variant7 = {
|
|
1227
1518
|
tag: 'separator'
|
|
1228
1519
|
};
|
|
1229
1520
|
break;
|
|
1230
1521
|
default:
|
|
1231
1522
|
throw new TypeError('invalid variant discriminant for HoverItem');
|
|
1232
1523
|
}
|
|
1233
|
-
|
|
1524
|
+
result8.push(variant7);
|
|
1234
1525
|
}
|
|
1235
|
-
const retVal =
|
|
1236
|
-
|
|
1526
|
+
const retVal = result8;
|
|
1527
|
+
postReturn8(ret);
|
|
1237
1528
|
return retVal;
|
|
1238
1529
|
}
|
|
1239
1530
|
const $init = (()=>{
|
|
1240
1531
|
let gen = function*() {
|
|
1241
1532
|
const module0 = fetchCompile(new URL('./objdiff.core.wasm', import.meta.url));
|
|
1242
|
-
const module1 = base64Compile('AGFzbQEAAAABDQJgAX8AYAV/f39/
|
|
1243
|
-
const module2 = base64Compile('AGFzbQEAAAABDQJgAX8AYAV/f39/
|
|
1533
|
+
const module1 = base64Compile('AGFzbQEAAAABDQJgAX8AYAV/f39/fwADBQQBAAAABAUBcAEEBAccBQEwAAABMQABATIAAgEzAAMIJGltcG9ydHMBAAoxBBEAIAAgASACIAMgBEEAEQEACwkAIABBAREAAAsJACAAQQIRAAALCQAgAEEDEQAACwAvCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BzAuMjM0LjA');
|
|
1534
|
+
const module2 = base64Compile('AGFzbQEAAAABDQJgAX8AYAV/f39/fwACJAUAATAAAQABMQAAAAEyAAAAATMAAAAIJGltcG9ydHMBcAEEBAkKAQBBAAsEAAECAwAvCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BzAuMjM0LjA');
|
|
1244
1535
|
({ exports: exports0 } = yield instantiateCore((yield module1)));
|
|
1245
1536
|
({ exports: exports1 } = yield instantiateCore((yield module0), {
|
|
1246
1537
|
'[export]objdiff:core/diff': {
|
|
1247
|
-
'[resource-new]diff-config':
|
|
1248
|
-
'[resource-new]object':
|
|
1538
|
+
'[resource-new]diff-config': trampoline1,
|
|
1539
|
+
'[resource-new]object': trampoline2,
|
|
1249
1540
|
'[resource-new]object-diff': trampoline0
|
|
1250
1541
|
},
|
|
1251
1542
|
'wasi:logging/logging@0.1.0-draft': {
|
|
@@ -1257,20 +1548,21 @@ const $init = (()=>{
|
|
|
1257
1548
|
'': {
|
|
1258
1549
|
$imports: exports0.$imports,
|
|
1259
1550
|
0: trampoline3,
|
|
1260
|
-
1: exports1['objdiff:core/diff#[dtor]diff
|
|
1261
|
-
2: exports1['objdiff:core/diff#[dtor]
|
|
1262
|
-
3: exports1['objdiff:core/diff#[dtor]object
|
|
1551
|
+
1: exports1['objdiff:core/diff#[dtor]object-diff'],
|
|
1552
|
+
2: exports1['objdiff:core/diff#[dtor]diff-config'],
|
|
1553
|
+
3: exports1['objdiff:core/diff#[dtor]object']
|
|
1263
1554
|
}
|
|
1264
1555
|
}));
|
|
1265
1556
|
postReturn0 = exports1.cabi_post_version;
|
|
1266
1557
|
realloc0 = exports1.cabi_realloc;
|
|
1267
1558
|
postReturn1 = exports1['cabi_post_objdiff:core/diff#[method]diff-config.set-property'];
|
|
1268
1559
|
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#instruction-
|
|
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#instruction-context'];
|
|
1565
|
+
postReturn8 = exports1['cabi_post_objdiff:core/display#instruction-hover'];
|
|
1274
1566
|
exports1Init = exports1.init;
|
|
1275
1567
|
exports1Version = exports1.version;
|
|
1276
1568
|
diffConstructorDiffConfig = exports1['objdiff:core/diff#[constructor]diff-config'];
|
|
@@ -1279,6 +1571,7 @@ const $init = (()=>{
|
|
|
1279
1571
|
diffStaticObjectParse = exports1['objdiff:core/diff#[static]object.parse'];
|
|
1280
1572
|
diffMethodObjectHash = exports1['objdiff:core/diff#[method]object.hash'];
|
|
1281
1573
|
diffMethodObjectDiffFindSymbol = exports1['objdiff:core/diff#[method]object-diff.find-symbol'];
|
|
1574
|
+
diffMethodObjectDiffGetSymbol = exports1['objdiff:core/diff#[method]object-diff.get-symbol'];
|
|
1282
1575
|
diffRunDiff = exports1['objdiff:core/diff#run-diff'];
|
|
1283
1576
|
displayDisplaySections = exports1['objdiff:core/display#display-sections'];
|
|
1284
1577
|
displayDisplaySymbol = exports1['objdiff:core/display#display-symbol'];
|