objdiff-wasm 3.1.1 → 3.2.1

package/dist/interfaces/objdiff-core-diff.d.ts

@@ -28,6 +28,32 @@ export interface SymbolFlags {
   sizeInferred?: boolean,
   ignored?: boolean,
 }
+export interface DiffResult {
+  left?: ObjectDiff,
+  right?: ObjectDiff,
+}
+/**
+ * # Variants
+ * 
+ * ## `"target"`
+ * 
+ * ## `"base"`
+ */
+export type DiffSide = 'target' | 'base';
+/**
+ * # Variants
+ * 
+ * ## `"unknown"`
+ * 
+ * ## `"code"`
+ * 
+ * ## `"data"`
+ * 
+ * ## `"bss"`
+ * 
+ * ## `"common"`
+ */
+export type SectionKind = 'unknown' | 'code' | 'data' | 'bss' | 'common';
 export interface SymbolInfo {
   id: SymbolRef,
   name: string,
@@ -37,22 +63,11 @@ export interface SymbolInfo {
   kind: SymbolKind,
   section?: number,
   sectionName?: string,
+  sectionKind: SectionKind,
   flags: SymbolFlags,
   align?: number,
   virtualAddress?: bigint,
 }
-export interface DiffResult {
-  left?: ObjectDiff,
-  right?: ObjectDiff,
-}
-/**
- * # Variants
- * 
- * ## `"target"`
- * 
- * ## `"base"`
- */
-export type DiffSide = 'target' | 'base';
 
 export class DiffConfig {
   constructor()

package/dist/interfaces/objdiff-core-display.d.ts

@@ -6,11 +6,15 @@ export function symbolContext(diff: ObjectDiff, symbol: SymbolRef): Array<Contex
 export function symbolHover(diff: ObjectDiff, symbol: SymbolRef): Array<HoverItem>;
 export function instructionContext(diff: ObjectDiff, symbol: SymbolRef, rowIndex: number, config: DiffConfig): Array<ContextItem>;
 export function instructionHover(diff: ObjectDiff, symbol: SymbolRef, rowIndex: number, config: DiffConfig): Array<HoverItem>;
+export function displayDataRow(diff: ObjectDiff, symbol: SymbolRef, rowIndex: number): DataDiffRow;
+export function dataContext(diff: ObjectDiff, symbol: SymbolRef, rowIndex: number): Array<ContextItem>;
+export function dataHover(diff: ObjectDiff, symbol: SymbolRef, rowIndex: number): Array<HoverItem>;
 export type Object = import('./objdiff-core-diff.js').Object;
 export type ObjectDiff = import('./objdiff-core-diff.js').ObjectDiff;
 export type DiffConfig = import('./objdiff-core-diff.js').DiffConfig;
 export type SymbolInfo = import('./objdiff-core-diff.js').SymbolInfo;
 export type SymbolRef = import('./objdiff-core-diff.js').SymbolRef;
+export type SectionKind = import('./objdiff-core-diff.js').SectionKind;
 export interface DisplayConfig {
   showHiddenSymbols: boolean,
   showMappedSymbols: boolean,
@@ -26,6 +30,7 @@ export interface SectionDisplay {
   size: bigint,
   matchPercent?: number,
   symbols: Uint32Array,
+  kind: SectionKind,
 }
 export interface SymbolDisplay {
   info: SymbolInfo,
@@ -197,3 +202,30 @@ export interface InstructionDiffRow {
   segments: Array<DiffTextSegment>,
   diffKind: InstructionDiffKind,
 }
+/**
+ * # Variants
+ * 
+ * ## `"none"`
+ * 
+ * ## `"replace"`
+ * 
+ * ## `"delete"`
+ * 
+ * ## `"insert"`
+ */
+export type DataDiffKind = 'none' | 'replace' | 'delete' | 'insert';
+export interface DataDiff {
+  data: Uint8Array,
+  size: number,
+  kind: DataDiffKind,
+}
+export interface DataRelocationDiff {
+  address: bigint,
+  size: number,
+  kind: DataDiffKind,
+}
+export interface DataDiffRow {
+  address: bigint,
+  segments: Array<DataDiff>,
+  relocations: Array<DataRelocationDiff>,
+}

package/dist/objdiff.js

@@ -119,6 +119,7 @@ let postReturn5;
 let postReturn6;
 let postReturn7;
 let postReturn8;
+let postReturn9;
 const handleTable0 = [
     T_FLAG,
     0
@@ -395,10 +396,10 @@ ObjectDiff.prototype.findSymbol = function(arg1, arg2) {
         variant4_2 = len3;
     }
     const ret = diffMethodObjectDiffFindSymbol(handle0, ptr2, len2, variant4_0, variant4_1, variant4_2);
-    let variant15;
+    let variant16;
     switch(dataView(memory0).getUint8(ret + 0, true)){
         case 0:
-            variant15 = void 0;
+            variant16 = void 0;
             break;
         case 1:
             {
@@ -461,40 +462,60 @@ ObjectDiff.prototype.findSymbol = function(arg1, arg2) {
                     default:
                         throw new TypeError('invalid variant discriminant for option');
                 }
-                if ((4294967040 & dataView(memory0).getUint8(ret + 72, true)) !== 0) throw new TypeError('flags have extraneous bits set');
-                var flags12 = {
-                    global: Boolean(1 & dataView(memory0).getUint8(ret + 72, true)),
-                    local: Boolean(2 & dataView(memory0).getUint8(ret + 72, true)),
-                    weak: Boolean(4 & dataView(memory0).getUint8(ret + 72, true)),
-                    common: Boolean(8 & dataView(memory0).getUint8(ret + 72, true)),
-                    hidden: Boolean(16 & dataView(memory0).getUint8(ret + 72, true)),
-                    hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 72, true)),
-                    sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 72, true)),
-                    ignored: Boolean(128 & dataView(memory0).getUint8(ret + 72, true))
+                let enum12;
+                switch(dataView(memory0).getUint8(ret + 72, true)){
+                    case 0:
+                        enum12 = 'unknown';
+                        break;
+                    case 1:
+                        enum12 = 'code';
+                        break;
+                    case 2:
+                        enum12 = 'data';
+                        break;
+                    case 3:
+                        enum12 = 'bss';
+                        break;
+                    case 4:
+                        enum12 = 'common';
+                        break;
+                    default:
+                        throw new TypeError('invalid discriminant specified for SectionKind');
+                }
+                if ((4294967040 & dataView(memory0).getUint8(ret + 73, true)) !== 0) throw new TypeError('flags have extraneous bits set');
+                var flags13 = {
+                    global: Boolean(1 & dataView(memory0).getUint8(ret + 73, true)),
+                    local: Boolean(2 & dataView(memory0).getUint8(ret + 73, true)),
+                    weak: Boolean(4 & dataView(memory0).getUint8(ret + 73, true)),
+                    common: Boolean(8 & dataView(memory0).getUint8(ret + 73, true)),
+                    hidden: Boolean(16 & dataView(memory0).getUint8(ret + 73, true)),
+                    hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 73, true)),
+                    sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 73, true)),
+                    ignored: Boolean(128 & dataView(memory0).getUint8(ret + 73, true))
                 };
-                let variant13;
+                let variant14;
                 switch(dataView(memory0).getUint8(ret + 76, true)){
                     case 0:
-                        variant13 = void 0;
+                        variant14 = void 0;
                         break;
                     case 1:
-                        variant13 = dataView(memory0).getInt32(ret + 80, true) >>> 0;
+                        variant14 = dataView(memory0).getInt32(ret + 80, true) >>> 0;
                         break;
                     default:
                         throw new TypeError('invalid variant discriminant for option');
                 }
-                let variant14;
+                let variant15;
                 switch(dataView(memory0).getUint8(ret + 88, true)){
                     case 0:
-                        variant14 = void 0;
+                        variant15 = void 0;
                         break;
                     case 1:
-                        variant14 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 96, true));
+                        variant15 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 96, true));
                         break;
                     default:
                         throw new TypeError('invalid variant discriminant for option');
                 }
-                variant15 = {
+                variant16 = {
                     id: dataView(memory0).getInt32(ret + 8, true) >>> 0,
                     name: result5,
                     demangledName: variant7,
@@ -503,16 +524,17 @@ ObjectDiff.prototype.findSymbol = function(arg1, arg2) {
                     kind: enum8,
                     section: variant9,
                     sectionName: variant11,
-                    flags: flags12,
-                    align: variant13,
-                    virtualAddress: variant14
+                    sectionKind: enum12,
+                    flags: flags13,
+                    align: variant14,
+                    virtualAddress: variant15
                 };
                 break;
             }
         default:
             throw new TypeError('invalid variant discriminant for option');
     }
-    const retVal = variant15;
+    const retVal = variant16;
     postReturn3(ret);
     return retVal;
 };
@@ -522,10 +544,10 @@ ObjectDiff.prototype.getSymbol = function(arg1) {
     if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
     var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
     const ret = diffMethodObjectDiffGetSymbol(handle0, toUint32(arg1));
-    let variant12;
+    let variant13;
     switch(dataView(memory0).getUint8(ret + 0, true)){
         case 0:
-            variant12 = void 0;
+            variant13 = void 0;
             break;
         case 1:
             {
@@ -588,40 +610,60 @@ ObjectDiff.prototype.getSymbol = function(arg1) {
                     default:
                         throw new TypeError('invalid variant discriminant for option');
                 }
-                if ((4294967040 & dataView(memory0).getUint8(ret + 72, true)) !== 0) throw new TypeError('flags have extraneous bits set');
-                var flags9 = {
-                    global: Boolean(1 & dataView(memory0).getUint8(ret + 72, true)),
-                    local: Boolean(2 & dataView(memory0).getUint8(ret + 72, true)),
-                    weak: Boolean(4 & dataView(memory0).getUint8(ret + 72, true)),
-                    common: Boolean(8 & dataView(memory0).getUint8(ret + 72, true)),
-                    hidden: Boolean(16 & dataView(memory0).getUint8(ret + 72, true)),
-                    hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 72, true)),
-                    sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 72, true)),
-                    ignored: Boolean(128 & dataView(memory0).getUint8(ret + 72, true))
+                let enum9;
+                switch(dataView(memory0).getUint8(ret + 72, true)){
+                    case 0:
+                        enum9 = 'unknown';
+                        break;
+                    case 1:
+                        enum9 = 'code';
+                        break;
+                    case 2:
+                        enum9 = 'data';
+                        break;
+                    case 3:
+                        enum9 = 'bss';
+                        break;
+                    case 4:
+                        enum9 = 'common';
+                        break;
+                    default:
+                        throw new TypeError('invalid discriminant specified for SectionKind');
+                }
+                if ((4294967040 & dataView(memory0).getUint8(ret + 73, true)) !== 0) throw new TypeError('flags have extraneous bits set');
+                var flags10 = {
+                    global: Boolean(1 & dataView(memory0).getUint8(ret + 73, true)),
+                    local: Boolean(2 & dataView(memory0).getUint8(ret + 73, true)),
+                    weak: Boolean(4 & dataView(memory0).getUint8(ret + 73, true)),
+                    common: Boolean(8 & dataView(memory0).getUint8(ret + 73, true)),
+                    hidden: Boolean(16 & dataView(memory0).getUint8(ret + 73, true)),
+                    hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 73, true)),
+                    sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 73, true)),
+                    ignored: Boolean(128 & dataView(memory0).getUint8(ret + 73, true))
                 };
-                let variant10;
+                let variant11;
                 switch(dataView(memory0).getUint8(ret + 76, true)){
                     case 0:
-                        variant10 = void 0;
+                        variant11 = void 0;
                         break;
                     case 1:
-                        variant10 = dataView(memory0).getInt32(ret + 80, true) >>> 0;
+                        variant11 = dataView(memory0).getInt32(ret + 80, true) >>> 0;
                         break;
                     default:
                         throw new TypeError('invalid variant discriminant for option');
                 }
-                let variant11;
+                let variant12;
                 switch(dataView(memory0).getUint8(ret + 88, true)){
                     case 0:
-                        variant11 = void 0;
+                        variant12 = void 0;
                         break;
                     case 1:
-                        variant11 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 96, true));
+                        variant12 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 96, true));
                         break;
                     default:
                         throw new TypeError('invalid variant discriminant for option');
                 }
-                variant12 = {
+                variant13 = {
                     id: dataView(memory0).getInt32(ret + 8, true) >>> 0,
                     name: result2,
                     demangledName: variant4,
@@ -630,16 +672,17 @@ ObjectDiff.prototype.getSymbol = function(arg1) {
                     kind: enum5,
                     section: variant6,
                     sectionName: variant8,
-                    flags: flags9,
-                    align: variant10,
-                    virtualAddress: variant11
+                    sectionKind: enum9,
+                    flags: flags10,
+                    align: variant11,
+                    virtualAddress: variant12
                 };
                 break;
             }
         default:
             throw new TypeError('invalid variant discriminant for option');
     }
-    const retVal = variant12;
+    const retVal = variant13;
     postReturn3(ret);
     return retVal;
 };
@@ -847,11 +890,11 @@ function displaySections(arg0, arg1, arg2) {
     }
     var { showHiddenSymbols: v6_0, showMappedSymbols: v6_1, reverseFnOrder: v6_2 } = arg2;
     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);
-    var len11 = dataView(memory0).getInt32(ret + 4, true);
-    var base11 = dataView(memory0).getInt32(ret + 0, true);
-    var result11 = [];
-    for(let i = 0; i < len11; i++){
-        const base = base11 + 40 * i;
+    var len12 = dataView(memory0).getInt32(ret + 4, true);
+    var base12 = dataView(memory0).getInt32(ret + 0, true);
+    var result12 = [];
+    for(let i = 0; i < len12; i++){
+        const base = base12 + 48 * i;
         var ptr7 = dataView(memory0).getInt32(base + 0, true);
         var len7 = dataView(memory0).getInt32(base + 4, true);
         var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
@@ -872,15 +915,36 @@ function displaySections(arg0, arg1, arg2) {
         var ptr10 = dataView(memory0).getInt32(base + 32, true);
         var len10 = dataView(memory0).getInt32(base + 36, true);
         var result10 = new Uint32Array(memory0.buffer.slice(ptr10, ptr10 + 4 * len10));
-        result11.push({
+        let enum11;
+        switch(dataView(memory0).getUint8(base + 40, true)){
+            case 0:
+                enum11 = 'unknown';
+                break;
+            case 1:
+                enum11 = 'code';
+                break;
+            case 2:
+                enum11 = 'data';
+                break;
+            case 3:
+                enum11 = 'bss';
+                break;
+            case 4:
+                enum11 = 'common';
+                break;
+            default:
+                throw new TypeError('invalid discriminant specified for SectionKind');
+        }
+        result12.push({
             id: result7,
             name: result8,
             size: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 16, true)),
             matchPercent: variant9,
-            symbols: result10
+            symbols: result10,
+            kind: enum11
         });
     }
-    const retVal = result11;
+    const retVal = result12;
     postReturn4(ret);
     return retVal;
 }
@@ -949,68 +1013,88 @@ function displaySymbol(arg0, arg1) {
         default:
             throw new TypeError('invalid variant discriminant for option');
     }
-    if ((4294967040 & dataView(memory0).getUint8(ret + 64, true)) !== 0) throw new TypeError('flags have extraneous bits set');
-    var flags9 = {
-        global: Boolean(1 & dataView(memory0).getUint8(ret + 64, true)),
-        local: Boolean(2 & dataView(memory0).getUint8(ret + 64, true)),
-        weak: Boolean(4 & dataView(memory0).getUint8(ret + 64, true)),
-        common: Boolean(8 & dataView(memory0).getUint8(ret + 64, true)),
-        hidden: Boolean(16 & dataView(memory0).getUint8(ret + 64, true)),
-        hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 64, true)),
-        sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 64, true)),
-        ignored: Boolean(128 & dataView(memory0).getUint8(ret + 64, true))
-    };
-    let variant10;
-    switch(dataView(memory0).getUint8(ret + 68, true)){
+    let enum9;
+    switch(dataView(memory0).getUint8(ret + 64, true)){
         case 0:
-            variant10 = void 0;
+            enum9 = 'unknown';
             break;
         case 1:
-            variant10 = dataView(memory0).getInt32(ret + 72, true) >>> 0;
+            enum9 = 'code';
+            break;
+        case 2:
+            enum9 = 'data';
+            break;
+        case 3:
+            enum9 = 'bss';
+            break;
+        case 4:
+            enum9 = 'common';
             break;
         default:
-            throw new TypeError('invalid variant discriminant for option');
+            throw new TypeError('invalid discriminant specified for SectionKind');
     }
+    if ((4294967040 & dataView(memory0).getUint8(ret + 65, true)) !== 0) throw new TypeError('flags have extraneous bits set');
+    var flags10 = {
+        global: Boolean(1 & dataView(memory0).getUint8(ret + 65, true)),
+        local: Boolean(2 & dataView(memory0).getUint8(ret + 65, true)),
+        weak: Boolean(4 & dataView(memory0).getUint8(ret + 65, true)),
+        common: Boolean(8 & dataView(memory0).getUint8(ret + 65, true)),
+        hidden: Boolean(16 & dataView(memory0).getUint8(ret + 65, true)),
+        hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 65, true)),
+        sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 65, true)),
+        ignored: Boolean(128 & dataView(memory0).getUint8(ret + 65, true))
+    };
     let variant11;
-    switch(dataView(memory0).getUint8(ret + 80, true)){
+    switch(dataView(memory0).getUint8(ret + 68, true)){
         case 0:
             variant11 = void 0;
             break;
         case 1:
-            variant11 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 88, true));
+            variant11 = dataView(memory0).getInt32(ret + 72, true) >>> 0;
             break;
         default:
             throw new TypeError('invalid variant discriminant for option');
     }
     let variant12;
-    switch(dataView(memory0).getUint8(ret + 96, true)){
+    switch(dataView(memory0).getUint8(ret + 80, true)){
         case 0:
             variant12 = void 0;
             break;
         case 1:
-            variant12 = dataView(memory0).getInt32(ret + 100, true) >>> 0;
+            variant12 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 88, true));
             break;
         default:
             throw new TypeError('invalid variant discriminant for option');
     }
     let variant13;
-    switch(dataView(memory0).getUint8(ret + 104, true)){
+    switch(dataView(memory0).getUint8(ret + 96, true)){
         case 0:
             variant13 = void 0;
             break;
         case 1:
-            variant13 = dataView(memory0).getFloat32(ret + 108, true);
+            variant13 = dataView(memory0).getInt32(ret + 100, true) >>> 0;
             break;
         default:
             throw new TypeError('invalid variant discriminant for option');
     }
     let variant14;
-    switch(dataView(memory0).getUint8(ret + 112, true)){
+    switch(dataView(memory0).getUint8(ret + 104, true)){
         case 0:
             variant14 = void 0;
             break;
         case 1:
-            variant14 = [
+            variant14 = dataView(memory0).getFloat32(ret + 108, true);
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    let variant15;
+    switch(dataView(memory0).getUint8(ret + 112, true)){
+        case 0:
+            variant15 = void 0;
+            break;
+        case 1:
+            variant15 = [
                 BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 120, true)),
                 BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 128, true))
             ];
@@ -1028,13 +1112,14 @@ function displaySymbol(arg0, arg1) {
             kind: enum5,
             section: variant6,
             sectionName: variant8,
-            flags: flags9,
-            align: variant10,
-            virtualAddress: variant11
+            sectionKind: enum9,
+            flags: flags10,
+            align: variant11,
+            virtualAddress: variant12
         },
-        targetSymbol: variant12,
-        matchPercent: variant13,
-        diffScore: variant14,
+        targetSymbol: variant13,
+        matchPercent: variant14,
+        diffScore: variant15,
         rowCount: dataView(memory0).getInt32(ret + 136, true) >>> 0
     };
     postReturn5(ret);
@@ -1544,6 +1629,225 @@ function instructionHover(arg0, arg1, arg2, arg3) {
     postReturn8(ret);
     return retVal;
 }
+let displayDisplayDataRow;
+function displayDataRow(arg0, arg1, arg2) {
+    var handle1 = arg0[symbolRscHandle];
+    if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
+    var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
+    const ret = displayDisplayDataRow(handle0, toUint32(arg1), toUint32(arg2));
+    var len4 = dataView(memory0).getInt32(ret + 12, true);
+    var base4 = dataView(memory0).getInt32(ret + 8, true);
+    var result4 = [];
+    for(let i = 0; i < len4; i++){
+        const base = base4 + 16 * i;
+        var ptr2 = dataView(memory0).getInt32(base + 0, true);
+        var len2 = dataView(memory0).getInt32(base + 4, true);
+        var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + +len2));
+        let enum3;
+        switch(dataView(memory0).getUint8(base + 12, true)){
+            case 0:
+                enum3 = 'none';
+                break;
+            case 1:
+                enum3 = 'replace';
+                break;
+            case 2:
+                enum3 = 'delete';
+                break;
+            case 3:
+                enum3 = 'insert';
+                break;
+            default:
+                throw new TypeError('invalid discriminant specified for DataDiffKind');
+        }
+        result4.push({
+            data: result2,
+            size: dataView(memory0).getInt32(base + 8, true) >>> 0,
+            kind: enum3
+        });
+    }
+    var len6 = dataView(memory0).getInt32(ret + 20, true);
+    var base6 = dataView(memory0).getInt32(ret + 16, true);
+    var result6 = [];
+    for(let i = 0; i < len6; i++){
+        const base = base6 + 16 * i;
+        let enum5;
+        switch(dataView(memory0).getUint8(base + 12, true)){
+            case 0:
+                enum5 = 'none';
+                break;
+            case 1:
+                enum5 = 'replace';
+                break;
+            case 2:
+                enum5 = 'delete';
+                break;
+            case 3:
+                enum5 = 'insert';
+                break;
+            default:
+                throw new TypeError('invalid discriminant specified for DataDiffKind');
+        }
+        result6.push({
+            address: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 0, true)),
+            size: dataView(memory0).getInt32(base + 8, true) >>> 0,
+            kind: enum5
+        });
+    }
+    const retVal = {
+        address: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 0, true)),
+        segments: result4,
+        relocations: result6
+    };
+    postReturn9(ret);
+    return retVal;
+}
+let displayDataContext;
+function dataContext(arg0, arg1, arg2) {
+    var handle1 = arg0[symbolRscHandle];
+    if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
+    var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
+    const ret = displayDataContext(handle0, toUint32(arg1), toUint32(arg2));
+    var len8 = dataView(memory0).getInt32(ret + 4, true);
+    var base8 = dataView(memory0).getInt32(ret + 0, true);
+    var result8 = [];
+    for(let i = 0; i < len8; i++){
+        const base = base8 + 24 * i;
+        let variant7;
+        switch(dataView(memory0).getUint8(base + 0, true)){
+            case 0:
+                {
+                    var ptr2 = dataView(memory0).getInt32(base + 4, true);
+                    var len2 = dataView(memory0).getInt32(base + 8, true);
+                    var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+                    let variant4;
+                    switch(dataView(memory0).getUint8(base + 12, true)){
+                        case 0:
+                            variant4 = void 0;
+                            break;
+                        case 1:
+                            var ptr3 = dataView(memory0).getInt32(base + 16, true);
+                            var len3 = dataView(memory0).getInt32(base + 20, true);
+                            var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+                            variant4 = result3;
+                            break;
+                        default:
+                            throw new TypeError('invalid variant discriminant for option');
+                    }
+                    variant7 = {
+                        tag: 'copy',
+                        val: {
+                            value: result2,
+                            label: variant4
+                        }
+                    };
+                    break;
+                }
+            case 1:
+                {
+                    var ptr5 = dataView(memory0).getInt32(base + 4, true);
+                    var len5 = dataView(memory0).getInt32(base + 8, true);
+                    var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+                    let enum6;
+                    switch(dataView(memory0).getUint8(base + 16, true)){
+                        case 0:
+                            enum6 = 'normal';
+                            break;
+                        case 1:
+                            enum6 = 'extab';
+                            break;
+                        default:
+                            throw new TypeError('invalid discriminant specified for SymbolNavigationKind');
+                    }
+                    variant7 = {
+                        tag: 'navigate',
+                        val: {
+                            label: result5,
+                            symbol: dataView(memory0).getInt32(base + 12, true) >>> 0,
+                            kind: enum6
+                        }
+                    };
+                    break;
+                }
+            case 2:
+                variant7 = {
+                    tag: 'separator'
+                };
+                break;
+            default:
+                throw new TypeError('invalid variant discriminant for ContextItem');
+        }
+        result8.push(variant7);
+    }
+    const retVal = result8;
+    postReturn7(ret);
+    return retVal;
+}
+let displayDataHover;
+function dataHover(arg0, arg1, arg2) {
+    var handle1 = arg0[symbolRscHandle];
+    if (!handle1 || (handleTable0[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "ObjectDiff" resource.');
+    var handle0 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
+    const ret = displayDataHover(handle0, toUint32(arg1), toUint32(arg2));
+    var len6 = dataView(memory0).getInt32(ret + 4, true);
+    var base6 = dataView(memory0).getInt32(ret + 0, true);
+    var result6 = [];
+    for(let i = 0; i < len6; i++){
+        const base = base6 + 24 * i;
+        let variant5;
+        switch(dataView(memory0).getUint8(base + 0, true)){
+            case 0:
+                {
+                    var ptr2 = dataView(memory0).getInt32(base + 4, true);
+                    var len2 = dataView(memory0).getInt32(base + 8, true);
+                    var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+                    var ptr3 = dataView(memory0).getInt32(base + 12, true);
+                    var len3 = dataView(memory0).getInt32(base + 16, true);
+                    var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+                    let enum4;
+                    switch(dataView(memory0).getUint8(base + 20, true)){
+                        case 0:
+                            enum4 = 'normal';
+                            break;
+                        case 1:
+                            enum4 = 'emphasized';
+                            break;
+                        case 2:
+                            enum4 = 'special';
+                            break;
+                        case 3:
+                            enum4 = 'delete';
+                            break;
+                        case 4:
+                            enum4 = 'insert';
+                            break;
+                        default:
+                            throw new TypeError('invalid discriminant specified for HoverItemColor');
+                    }
+                    variant5 = {
+                        tag: 'text',
+                        val: {
+                            label: result2,
+                            value: result3,
+                            color: enum4
+                        }
+                    };
+                    break;
+                }
+            case 1:
+                variant5 = {
+                    tag: 'separator'
+                };
+                break;
+            default:
+                throw new TypeError('invalid variant discriminant for HoverItem');
+        }
+        result6.push(variant5);
+    }
+    const retVal = result6;
+    postReturn8(ret);
+    return retVal;
+}
 const $init = (()=>{
     let gen = function*() {
         const module0 = fetchCompile(new URL('./objdiff.core.wasm', import.meta.url));
@@ -1579,8 +1883,9 @@ const $init = (()=>{
         postReturn4 = exports1['cabi_post_objdiff:core/display#display-sections'];
         postReturn5 = exports1['cabi_post_objdiff:core/display#display-symbol'];
         postReturn6 = exports1['cabi_post_objdiff:core/display#display-instruction-row'];
-        postReturn7 = exports1['cabi_post_objdiff:core/display#instruction-context'];
-        postReturn8 = exports1['cabi_post_objdiff:core/display#instruction-hover'];
+        postReturn7 = exports1['cabi_post_objdiff:core/display#data-context'];
+        postReturn8 = exports1['cabi_post_objdiff:core/display#data-hover'];
+        postReturn9 = exports1['cabi_post_objdiff:core/display#display-data-row'];
         exports1Init = exports1.init;
         exports1Version = exports1.version;
         diffConstructorDiffConfig = exports1['objdiff:core/diff#[constructor]diff-config'];
@@ -1598,6 +1903,9 @@ const $init = (()=>{
         displaySymbolHover = exports1['objdiff:core/display#symbol-hover'];
         displayInstructionContext = exports1['objdiff:core/display#instruction-context'];
         displayInstructionHover = exports1['objdiff:core/display#instruction-hover'];
+        displayDisplayDataRow = exports1['objdiff:core/display#display-data-row'];
+        displayDataContext = exports1['objdiff:core/display#data-context'];
+        displayDataHover = exports1['objdiff:core/display#data-hover'];
     }();
     let promise, resolve, reject;
     function runNext(value) {
@@ -1627,6 +1935,9 @@ const diff = {
     runDiff: runDiff
 };
 const display = {
+    dataContext: dataContext,
+    dataHover: dataHover,
+    displayDataRow: displayDataRow,
     displayInstructionRow: displayInstructionRow,
     displaySections: displaySections,
     displaySymbol: displaySymbol,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objdiff-wasm",
-  "version": "3.1.1",
+  "version": "3.2.1",
   "description": "A local diffing tool for decompilation projects.",
   "author": {
     "name": "Luke Street",