objdiff-wasm 2.0.0 → 3.0.0-alpha.2

package/dist/objdiff.js

@@ -0,0 +1,1351 @@
+import { log } from './wasi-logging.js';
+const base64Compile = (str)=>WebAssembly.compile(Uint8Array.from(atob(str), (b)=>b.charCodeAt(0)));
+function clampGuest(i, min, max) {
+    if (i < min || i > max) throw new TypeError(`must be between ${min} and ${max}`);
+    return i;
+}
+class ComponentError extends Error {
+    constructor(value){
+        const enumerable = 'string' != typeof value;
+        super(enumerable ? `${String(value)} (see error.payload)` : value);
+        Object.defineProperty(this, 'payload', {
+            value,
+            enumerable
+        });
+    }
+}
+let dv = new DataView(new ArrayBuffer());
+const dataView = (mem)=>dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
+const emptyFunc = ()=>{};
+const fetchCompile = (url)=>fetch(url).then(WebAssembly.compileStreaming);
+function finalizationRegistryCreate(unregister) {
+    if ('undefined' == typeof FinalizationRegistry) return {
+        unregister () {}
+    };
+    return new FinalizationRegistry(unregister);
+}
+const handleTables = [];
+const instantiateCore = WebAssembly.instantiate;
+const T_FLAG = 1073741824;
+function rscTableCreateOwn(table, rep) {
+    const free = table[0] & ~T_FLAG;
+    if (0 === free) {
+        table.push(0);
+        table.push(rep | T_FLAG);
+        return (table.length >> 1) - 1;
+    }
+    table[0] = table[free << 1];
+    table[free << 1] = 0;
+    table[(free << 1) + 1] = rep | T_FLAG;
+    return free;
+}
+function rscTableRemove(table, handle) {
+    const scope = table[handle << 1];
+    const val = table[(handle << 1) + 1];
+    const own = (val & T_FLAG) !== 0;
+    const rep = val & ~T_FLAG;
+    if (0 === val || (scope & T_FLAG) !== 0) throw new TypeError('Invalid handle');
+    table[handle << 1] = table[0] | T_FLAG;
+    table[0] = handle | T_FLAG;
+    return {
+        rep,
+        scope,
+        own
+    };
+}
+const symbolRscHandle = Symbol('handle');
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+function throwInvalidBool() {
+    throw new TypeError('invalid variant discriminant for bool');
+}
+function toUint32(val) {
+    return val >>> 0;
+}
+const utf8Decoder = new TextDecoder();
+const utf8Encoder = new TextEncoder();
+let utf8EncodedLen = 0;
+function utf8Encode(s, realloc, memory) {
+    if ('string' != typeof s) throw new TypeError('expected a string');
+    if (0 === s.length) {
+        utf8EncodedLen = 0;
+        return 1;
+    }
+    let buf = utf8Encoder.encode(s);
+    let ptr = realloc(0, 0, 1, buf.length);
+    new Uint8Array(memory.buffer).set(buf, ptr);
+    utf8EncodedLen = buf.length;
+    return ptr;
+}
+let exports0;
+let exports1;
+let memory0;
+function trampoline3(arg0, arg1, arg2, arg3, arg4) {
+    let enum0;
+    switch(arg0){
+        case 0:
+            enum0 = 'trace';
+            break;
+        case 1:
+            enum0 = 'debug';
+            break;
+        case 2:
+            enum0 = 'info';
+            break;
+        case 3:
+            enum0 = 'warn';
+            break;
+        case 4:
+            enum0 = 'error';
+            break;
+        case 5:
+            enum0 = 'critical';
+            break;
+        default:
+            throw new TypeError('invalid discriminant specified for Level');
+    }
+    var ptr1 = arg1;
+    var len1 = arg2;
+    var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+    var ptr2 = arg3;
+    var len2 = arg4;
+    var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+    log(enum0, result1, result2);
+}
+let exports2;
+let postReturn0;
+let realloc0;
+let postReturn1;
+let postReturn2;
+let postReturn3;
+let postReturn4;
+let postReturn5;
+let postReturn6;
+let postReturn7;
+let postReturn8;
+let postReturn9;
+const handleTable0 = [
+    T_FLAG,
+    0
+];
+const finalizationRegistry0 = finalizationRegistryCreate((handle)=>{
+    const { rep } = rscTableRemove(handleTable0, handle);
+    exports0['3'](rep);
+});
+handleTables[0] = handleTable0;
+const trampoline0 = rscTableCreateOwn.bind(null, handleTable0);
+const handleTable1 = [
+    T_FLAG,
+    0
+];
+const finalizationRegistry1 = finalizationRegistryCreate((handle)=>{
+    const { rep } = rscTableRemove(handleTable1, handle);
+    exports0['2'](rep);
+});
+handleTables[1] = handleTable1;
+const trampoline1 = rscTableCreateOwn.bind(null, handleTable1);
+const handleTable2 = [
+    T_FLAG,
+    0
+];
+const finalizationRegistry2 = finalizationRegistryCreate((handle)=>{
+    const { rep } = rscTableRemove(handleTable2, handle);
+    exports0['1'](rep);
+});
+handleTables[2] = handleTable2;
+const trampoline2 = rscTableCreateOwn.bind(null, handleTable2);
+let exports1Init;
+function init(arg0) {
+    var val0 = arg0;
+    let enum0;
+    switch(val0){
+        case 'trace':
+            enum0 = 0;
+            break;
+        case 'debug':
+            enum0 = 1;
+            break;
+        case 'info':
+            enum0 = 2;
+            break;
+        case 'warn':
+            enum0 = 3;
+            break;
+        case 'error':
+            enum0 = 4;
+            break;
+        case 'critical':
+            enum0 = 5;
+            break;
+        default:
+            if (arg0 instanceof Error) console.error(arg0);
+            throw new TypeError(`"${val0}" is not one of the cases of level`);
+    }
+    exports1Init(enum0);
+}
+let exports1Version;
+function version() {
+    const ret = exports1Version();
+    var ptr0 = dataView(memory0).getInt32(ret + 0, true);
+    var len0 = dataView(memory0).getInt32(ret + 4, true);
+    var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+    const retVal = result0;
+    postReturn0(ret);
+    return retVal;
+}
+let diffConstructorDiffConfig;
+class DiffConfig {
+    constructor(){
+        const ret = diffConstructorDiffConfig();
+        var handle1 = ret;
+        var rsc0 = new.target === DiffConfig ? this : Object.create(DiffConfig.prototype);
+        Object.defineProperty(rsc0, symbolRscHandle, {
+            writable: true,
+            value: handle1
+        });
+        finalizationRegistry2.register(rsc0, handle1, rsc0);
+        Object.defineProperty(rsc0, symbolDispose, {
+            writable: true,
+            value: function() {
+                finalizationRegistry2.unregister(rsc0);
+                rscTableRemove(handleTable2, handle1);
+                rsc0[symbolDispose] = emptyFunc;
+                rsc0[symbolRscHandle] = void 0;
+                exports0['1'](handleTable2[(handle1 << 1) + 1] & ~T_FLAG);
+            }
+        });
+        return rsc0;
+    }
+}
+let diffMethodDiffConfigSetProperty;
+DiffConfig.prototype.setProperty = function(arg1, arg2) {
+    var handle1 = this[symbolRscHandle];
+    if (!handle1 || (handleTable2[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
+    var handle0 = handleTable2[(handle1 << 1) + 1] & ~T_FLAG;
+    var ptr2 = utf8Encode(arg1, realloc0, memory0);
+    var len2 = utf8EncodedLen;
+    var ptr3 = utf8Encode(arg2, realloc0, memory0);
+    var len3 = utf8EncodedLen;
+    const ret = diffMethodDiffConfigSetProperty(handle0, ptr2, len2, ptr3, len3);
+    let variant5;
+    switch(dataView(memory0).getUint8(ret + 0, true)){
+        case 0:
+            variant5 = {
+                tag: 'ok',
+                val: void 0
+            };
+            break;
+        case 1:
+            var ptr4 = dataView(memory0).getInt32(ret + 4, true);
+            var len4 = dataView(memory0).getInt32(ret + 8, true);
+            var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+            variant5 = {
+                tag: 'err',
+                val: result4
+            };
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for expected');
+    }
+    const retVal = variant5;
+    postReturn1(ret);
+    if ('object' == typeof retVal && 'err' === retVal.tag) throw new ComponentError(retVal.val);
+    return retVal.val;
+};
+let diffMethodDiffConfigGetProperty;
+DiffConfig.prototype.getProperty = function(arg1) {
+    var handle1 = this[symbolRscHandle];
+    if (!handle1 || (handleTable2[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
+    var handle0 = handleTable2[(handle1 << 1) + 1] & ~T_FLAG;
+    var ptr2 = utf8Encode(arg1, realloc0, memory0);
+    var len2 = utf8EncodedLen;
+    const ret = diffMethodDiffConfigGetProperty(handle0, ptr2, len2);
+    let variant5;
+    switch(dataView(memory0).getUint8(ret + 0, true)){
+        case 0:
+            var ptr3 = dataView(memory0).getInt32(ret + 4, true);
+            var len3 = dataView(memory0).getInt32(ret + 8, true);
+            var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+            variant5 = {
+                tag: 'ok',
+                val: result3
+            };
+            break;
+        case 1:
+            var ptr4 = dataView(memory0).getInt32(ret + 4, true);
+            var len4 = dataView(memory0).getInt32(ret + 8, true);
+            var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+            variant5 = {
+                tag: 'err',
+                val: result4
+            };
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for expected');
+    }
+    const retVal = variant5;
+    postReturn2(ret);
+    if ('object' == typeof retVal && 'err' === retVal.tag) throw new ComponentError(retVal.val);
+    return retVal.val;
+};
+let diffStaticObjectParse;
+class Object$1 {
+    constructor(){
+        throw new Error('"Object$1" resource does not define a constructor');
+    }
+}
+Object$1.parse = function(arg0, arg1) {
+    var val0 = arg0;
+    var len0 = val0.byteLength;
+    var ptr0 = realloc0(0, 0, 1, +len0);
+    var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, +len0);
+    new Uint8Array(memory0.buffer, ptr0, +len0).set(src0);
+    var handle2 = arg1[symbolRscHandle];
+    if (!handle2 || (handleTable2[(handle2 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
+    var handle1 = handleTable2[(handle2 << 1) + 1] & ~T_FLAG;
+    const ret = diffStaticObjectParse(ptr0, len0, handle1);
+    let variant6;
+    switch(dataView(memory0).getUint8(ret + 0, true)){
+        case 0:
+            var handle4 = dataView(memory0).getInt32(ret + 4, true);
+            var rsc3 = new.target === Object$1 ? this : Object.create(Object$1.prototype);
+            Object.defineProperty(rsc3, symbolRscHandle, {
+                writable: true,
+                value: handle4
+            });
+            finalizationRegistry1.register(rsc3, handle4, rsc3);
+            Object.defineProperty(rsc3, symbolDispose, {
+                writable: true,
+                value: function() {
+                    finalizationRegistry1.unregister(rsc3);
+                    rscTableRemove(handleTable1, handle4);
+                    rsc3[symbolDispose] = emptyFunc;
+                    rsc3[symbolRscHandle] = void 0;
+                    exports0['2'](handleTable1[(handle4 << 1) + 1] & ~T_FLAG);
+                }
+            });
+            variant6 = {
+                tag: 'ok',
+                val: rsc3
+            };
+            break;
+        case 1:
+            var ptr5 = dataView(memory0).getInt32(ret + 4, true);
+            var len5 = dataView(memory0).getInt32(ret + 8, true);
+            var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+            variant6 = {
+                tag: 'err',
+                val: result5
+            };
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for expected');
+    }
+    const retVal = variant6;
+    postReturn1(ret);
+    if ('object' == typeof retVal && 'err' === retVal.tag) throw new ComponentError(retVal.val);
+    return retVal.val;
+};
+let diffMethodObjectDiffFindSymbol;
+class ObjectDiff {
+    constructor(){
+        throw new Error('"ObjectDiff" resource does not define a constructor');
+    }
+}
+ObjectDiff.prototype.findSymbol = function(arg1, arg2) {
+    var handle1 = this[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;
+    var ptr2 = utf8Encode(arg1, realloc0, memory0);
+    var len2 = utf8EncodedLen;
+    var variant4 = arg2;
+    let variant4_0;
+    let variant4_1;
+    let variant4_2;
+    if (null == variant4) {
+        variant4_0 = 0;
+        variant4_1 = 0;
+        variant4_2 = 0;
+    } else {
+        const e = variant4;
+        var ptr3 = utf8Encode(e, realloc0, memory0);
+        var len3 = utf8EncodedLen;
+        variant4_0 = 1;
+        variant4_1 = ptr3;
+        variant4_2 = len3;
+    }
+    const ret = diffMethodObjectDiffFindSymbol(handle0, ptr2, len2, variant4_0, variant4_1, variant4_2);
+    let variant5;
+    switch(dataView(memory0).getUint8(ret + 0, true)){
+        case 0:
+            variant5 = void 0;
+            break;
+        case 1:
+            variant5 = dataView(memory0).getInt32(ret + 4, true) >>> 0;
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    return variant5;
+};
+let diffRunDiff;
+function runDiff(arg0, arg1, arg2) {
+    var variant2 = arg0;
+    let variant2_0;
+    let variant2_1;
+    if (null == variant2) {
+        variant2_0 = 0;
+        variant2_1 = 0;
+    } else {
+        const e = variant2;
+        var handle1 = e[symbolRscHandle];
+        if (!handle1 || (handleTable1[(handle1 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "Object" resource.');
+        var handle0 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
+        variant2_0 = 1;
+        variant2_1 = handle0;
+    }
+    var variant5 = arg1;
+    let variant5_0;
+    let variant5_1;
+    if (null == variant5) {
+        variant5_0 = 0;
+        variant5_1 = 0;
+    } else {
+        const e = variant5;
+        var handle4 = e[symbolRscHandle];
+        if (!handle4 || (handleTable1[(handle4 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "Object" resource.');
+        var handle3 = handleTable1[(handle4 << 1) + 1] & ~T_FLAG;
+        variant5_0 = 1;
+        variant5_1 = handle3;
+    }
+    var handle7 = arg2[symbolRscHandle];
+    if (!handle7 || (handleTable2[(handle7 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
+    var handle6 = handleTable2[(handle7 << 1) + 1] & ~T_FLAG;
+    const ret = diffRunDiff(variant2_0, variant2_1, variant5_0, variant5_1, handle6);
+    let variant15;
+    switch(dataView(memory0).getUint8(ret + 0, true)){
+        case 0:
+            {
+                let variant10;
+                switch(dataView(memory0).getUint8(ret + 4, true)){
+                    case 0:
+                        variant10 = void 0;
+                        break;
+                    case 1:
+                        var handle9 = dataView(memory0).getInt32(ret + 8, true);
+                        var rsc8 = new.target === ObjectDiff ? this : Object.create(ObjectDiff.prototype);
+                        Object.defineProperty(rsc8, symbolRscHandle, {
+                            writable: true,
+                            value: handle9
+                        });
+                        finalizationRegistry0.register(rsc8, handle9, rsc8);
+                        Object.defineProperty(rsc8, symbolDispose, {
+                            writable: true,
+                            value: function() {
+                                finalizationRegistry0.unregister(rsc8);
+                                rscTableRemove(handleTable0, handle9);
+                                rsc8[symbolDispose] = emptyFunc;
+                                rsc8[symbolRscHandle] = void 0;
+                                exports0['3'](handleTable0[(handle9 << 1) + 1] & ~T_FLAG);
+                            }
+                        });
+                        variant10 = rsc8;
+                        break;
+                    default:
+                        throw new TypeError('invalid variant discriminant for option');
+                }
+                let variant13;
+                switch(dataView(memory0).getUint8(ret + 12, true)){
+                    case 0:
+                        variant13 = void 0;
+                        break;
+                    case 1:
+                        var handle12 = dataView(memory0).getInt32(ret + 16, true);
+                        var rsc11 = new.target === ObjectDiff ? this : Object.create(ObjectDiff.prototype);
+                        Object.defineProperty(rsc11, symbolRscHandle, {
+                            writable: true,
+                            value: handle12
+                        });
+                        finalizationRegistry0.register(rsc11, handle12, rsc11);
+                        Object.defineProperty(rsc11, symbolDispose, {
+                            writable: true,
+                            value: function() {
+                                finalizationRegistry0.unregister(rsc11);
+                                rscTableRemove(handleTable0, handle12);
+                                rsc11[symbolDispose] = emptyFunc;
+                                rsc11[symbolRscHandle] = void 0;
+                                exports0['3'](handleTable0[(handle12 << 1) + 1] & ~T_FLAG);
+                            }
+                        });
+                        variant13 = rsc11;
+                        break;
+                    default:
+                        throw new TypeError('invalid variant discriminant for option');
+                }
+                variant15 = {
+                    tag: 'ok',
+                    val: {
+                        left: variant10,
+                        right: variant13
+                    }
+                };
+                break;
+            }
+        case 1:
+            var ptr14 = dataView(memory0).getInt32(ret + 4, true);
+            var len14 = dataView(memory0).getInt32(ret + 8, true);
+            var result14 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr14, len14));
+            variant15 = {
+                tag: 'err',
+                val: result14
+            };
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for expected');
+    }
+    const retVal = variant15;
+    postReturn1(ret);
+    if ('object' == typeof retVal && 'err' === retVal.tag) throw new ComponentError(retVal.val);
+    return retVal.val;
+}
+let displayDisplaySections;
+function displaySections(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;
+    var { regex: v2_0, mapping: v2_1 } = arg1;
+    var variant4 = v2_0;
+    let variant4_0;
+    let variant4_1;
+    let variant4_2;
+    if (null == variant4) {
+        variant4_0 = 0;
+        variant4_1 = 0;
+        variant4_2 = 0;
+    } else {
+        const e = variant4;
+        var ptr3 = utf8Encode(e, realloc0, memory0);
+        var len3 = utf8EncodedLen;
+        variant4_0 = 1;
+        variant4_1 = ptr3;
+        variant4_2 = len3;
+    }
+    var variant5 = v2_1;
+    let variant5_0;
+    let variant5_1;
+    if (null == variant5) {
+        variant5_0 = 0;
+        variant5_1 = 0;
+    } else {
+        const e = variant5;
+        variant5_0 = 1;
+        variant5_1 = toUint32(e);
+    }
+    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 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 + 40 * 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));
+        var ptr8 = dataView(memory0).getInt32(base + 8, true);
+        var len8 = dataView(memory0).getInt32(base + 12, true);
+        var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+        let variant9;
+        switch(dataView(memory0).getUint8(base + 24, true)){
+            case 0:
+                variant9 = void 0;
+                break;
+            case 1:
+                variant9 = dataView(memory0).getFloat32(base + 28, true);
+                break;
+            default:
+                throw new TypeError('invalid variant discriminant for option');
+        }
+        var len11 = dataView(memory0).getInt32(base + 36, true);
+        var base11 = dataView(memory0).getInt32(base + 32, true);
+        var result11 = [];
+        for(let i = 0; i < len11; i++){
+            const base = base11 + 8 * i;
+            var bool10 = dataView(memory0).getUint8(base + 4, true);
+            result11.push({
+                symbol: dataView(memory0).getInt32(base + 0, true) >>> 0,
+                isMappingSymbol: 0 == bool10 ? false : 1 == bool10 ? true : throwInvalidBool()
+            });
+        }
+        result12.push({
+            id: result7,
+            name: result8,
+            size: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 16, true)),
+            matchPercent: variant9,
+            symbols: result11
+        });
+    }
+    const retVal = result12;
+    postReturn3(ret);
+    return retVal;
+}
+let displayDisplaySymbol;
+function displaySymbol(arg0, arg1) {
+    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;
+    var { symbol: v2_0, isMappingSymbol: v2_1 } = arg1;
+    const ret = displayDisplaySymbol(handle0, toUint32(v2_0), v2_1 ? 1 : 0);
+    var ptr3 = dataView(memory0).getInt32(ret + 0, true);
+    var len3 = dataView(memory0).getInt32(ret + 4, true);
+    var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+    let variant5;
+    switch(dataView(memory0).getUint8(ret + 8, true)){
+        case 0:
+            variant5 = void 0;
+            break;
+        case 1:
+            var ptr4 = dataView(memory0).getInt32(ret + 12, true);
+            var len4 = dataView(memory0).getInt32(ret + 16, true);
+            var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+            variant5 = result4;
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    let enum6;
+    switch(dataView(memory0).getUint8(ret + 40, true)){
+        case 0:
+            enum6 = 'unknown';
+            break;
+        case 1:
+            enum6 = 'function';
+            break;
+        case 2:
+            enum6 = 'object';
+            break;
+        case 3:
+            enum6 = 'section';
+            break;
+        default:
+            throw new TypeError('invalid discriminant specified for SymbolKind');
+    }
+    let variant7;
+    switch(dataView(memory0).getUint8(ret + 44, true)){
+        case 0:
+            variant7 = void 0;
+            break;
+        case 1:
+            variant7 = dataView(memory0).getInt32(ret + 48, true) >>> 0;
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    if ((4294967168 & dataView(memory0).getUint8(ret + 52, true)) !== 0) throw new TypeError('flags have extraneous bits set');
+    var flags8 = {
+        global: Boolean(1 & dataView(memory0).getUint8(ret + 52, true)),
+        local: Boolean(2 & dataView(memory0).getUint8(ret + 52, true)),
+        weak: Boolean(4 & dataView(memory0).getUint8(ret + 52, true)),
+        common: Boolean(8 & dataView(memory0).getUint8(ret + 52, true)),
+        hidden: Boolean(16 & dataView(memory0).getUint8(ret + 52, true)),
+        hasExtra: Boolean(32 & dataView(memory0).getUint8(ret + 52, true)),
+        sizeInferred: Boolean(64 & dataView(memory0).getUint8(ret + 52, true))
+    };
+    let variant9;
+    switch(dataView(memory0).getUint8(ret + 56, true)){
+        case 0:
+            variant9 = void 0;
+            break;
+        case 1:
+            variant9 = dataView(memory0).getInt32(ret + 60, true) >>> 0;
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    let variant10;
+    switch(dataView(memory0).getUint8(ret + 64, true)){
+        case 0:
+            variant10 = void 0;
+            break;
+        case 1:
+            variant10 = BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 72, true));
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    let variant11;
+    switch(dataView(memory0).getUint8(ret + 80, true)){
+        case 0:
+            variant11 = void 0;
+            break;
+        case 1:
+            variant11 = dataView(memory0).getInt32(ret + 84, true) >>> 0;
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    let variant12;
+    switch(dataView(memory0).getUint8(ret + 88, true)){
+        case 0:
+            variant12 = void 0;
+            break;
+        case 1:
+            variant12 = dataView(memory0).getFloat32(ret + 92, true);
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    let variant13;
+    switch(dataView(memory0).getUint8(ret + 96, true)){
+        case 0:
+            variant13 = void 0;
+            break;
+        case 1:
+            variant13 = [
+                BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 104, true)),
+                BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 112, true))
+            ];
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for option');
+    }
+    const retVal = {
+        name: result3,
+        demangledName: variant5,
+        address: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 24, true)),
+        size: BigInt.asUintN(64, dataView(memory0).getBigInt64(ret + 32, true)),
+        kind: enum6,
+        section: variant7,
+        flags: flags8,
+        align: variant9,
+        virtualAddress: variant10,
+        targetSymbol: variant11,
+        matchPercent: variant12,
+        diffScore: variant13,
+        rowCount: dataView(memory0).getInt32(ret + 120, true) >>> 0
+    };
+    postReturn4(ret);
+    return retVal;
+}
+let displayDisplayInstructionRow;
+function displayInstructionRow(arg0, arg1, arg2, arg3) {
+    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;
+    var { symbol: v2_0, isMappingSymbol: v2_1 } = arg1;
+    var handle4 = arg3[symbolRscHandle];
+    if (!handle4 || (handleTable2[(handle4 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
+    var handle3 = handleTable2[(handle4 << 1) + 1] & ~T_FLAG;
+    const ret = displayDisplayInstructionRow(handle0, toUint32(v2_0), v2_1 ? 1 : 0, toUint32(arg2), handle3);
+    var len13 = dataView(memory0).getInt32(ret + 4, true);
+    var base13 = dataView(memory0).getInt32(ret + 0, true);
+    var result13 = [];
+    for(let i = 0; i < len13; i++){
+        const base = base13 + 40 * i;
+        let variant11;
+        switch(dataView(memory0).getUint8(base + 0, true)){
+            case 0:
+                var ptr5 = dataView(memory0).getInt32(base + 8, true);
+                var len5 = dataView(memory0).getInt32(base + 12, true);
+                var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+                variant11 = {
+                    tag: 'basic',
+                    val: result5
+                };
+                break;
+            case 1:
+                variant11 = {
+                    tag: 'line',
+                    val: dataView(memory0).getInt32(base + 8, true) >>> 0
+                };
+                break;
+            case 2:
+                variant11 = {
+                    tag: 'address',
+                    val: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 8, true))
+                };
+                break;
+            case 3:
+                var ptr6 = dataView(memory0).getInt32(base + 8, true);
+                var len6 = dataView(memory0).getInt32(base + 12, true);
+                var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+                variant11 = {
+                    tag: 'opcode',
+                    val: {
+                        mnemonic: result6,
+                        opcode: clampGuest(dataView(memory0).getUint16(base + 16, true), 0, 65535)
+                    }
+                };
+                break;
+            case 4:
+                variant11 = {
+                    tag: 'signed',
+                    val: dataView(memory0).getBigInt64(base + 8, true)
+                };
+                break;
+            case 5:
+                variant11 = {
+                    tag: 'unsigned',
+                    val: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 8, true))
+                };
+                break;
+            case 6:
+                var ptr7 = dataView(memory0).getInt32(base + 8, true);
+                var len7 = dataView(memory0).getInt32(base + 12, true);
+                var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
+                variant11 = {
+                    tag: 'opaque',
+                    val: result7
+                };
+                break;
+            case 7:
+                variant11 = {
+                    tag: 'branch-dest',
+                    val: BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 8, true))
+                };
+                break;
+            case 8:
+                {
+                    var ptr8 = dataView(memory0).getInt32(base + 8, true);
+                    var len8 = dataView(memory0).getInt32(base + 12, true);
+                    var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+                    let variant10;
+                    switch(dataView(memory0).getUint8(base + 16, true)){
+                        case 0:
+                            variant10 = void 0;
+                            break;
+                        case 1:
+                            var ptr9 = dataView(memory0).getInt32(base + 20, true);
+                            var len9 = dataView(memory0).getInt32(base + 24, true);
+                            var result9 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9));
+                            variant10 = result9;
+                            break;
+                        default:
+                            throw new TypeError('invalid variant discriminant for option');
+                    }
+                    variant11 = {
+                        tag: 'symbol',
+                        val: {
+                            name: result8,
+                            demangledName: variant10
+                        }
+                    };
+                    break;
+                }
+            case 9:
+                variant11 = {
+                    tag: 'addend',
+                    val: dataView(memory0).getBigInt64(base + 8, true)
+                };
+                break;
+            case 10:
+                variant11 = {
+                    tag: 'spacing',
+                    val: clampGuest(dataView(memory0).getUint8(base + 8, true), 0, 255)
+                };
+                break;
+            case 11:
+                variant11 = {
+                    tag: 'eol'
+                };
+                break;
+            default:
+                throw new TypeError('invalid variant discriminant for DiffText');
+        }
+        let variant12;
+        switch(dataView(memory0).getUint8(base + 32, true)){
+            case 0:
+                variant12 = {
+                    tag: 'normal'
+                };
+                break;
+            case 1:
+                variant12 = {
+                    tag: 'dim'
+                };
+                break;
+            case 2:
+                variant12 = {
+                    tag: 'bright'
+                };
+                break;
+            case 3:
+                variant12 = {
+                    tag: 'replace'
+                };
+                break;
+            case 4:
+                variant12 = {
+                    tag: 'delete'
+                };
+                break;
+            case 5:
+                variant12 = {
+                    tag: 'insert'
+                };
+                break;
+            case 6:
+                variant12 = {
+                    tag: 'rotating',
+                    val: clampGuest(dataView(memory0).getUint8(base + 33, true), 0, 255)
+                };
+                break;
+            default:
+                throw new TypeError('invalid variant discriminant for DiffTextColor');
+        }
+        result13.push({
+            text: variant11,
+            color: variant12,
+            padTo: clampGuest(dataView(memory0).getUint8(base + 34, true), 0, 255)
+        });
+    }
+    let enum14;
+    switch(dataView(memory0).getUint8(ret + 8, true)){
+        case 0:
+            enum14 = 'none';
+            break;
+        case 1:
+            enum14 = 'op-mismatch';
+            break;
+        case 2:
+            enum14 = 'arg-mismatch';
+            break;
+        case 3:
+            enum14 = 'replace';
+            break;
+        case 4:
+            enum14 = 'insert';
+            break;
+        case 5:
+            enum14 = 'delete';
+            break;
+        default:
+            throw new TypeError('invalid discriminant specified for InstructionDiffKind');
+    }
+    const retVal = {
+        segments: result13,
+        diffKind: enum14
+    };
+    postReturn5(ret);
+    return retVal;
+}
+let displaySymbolContext;
+function symbolContext(arg0, arg1) {
+    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;
+    var { symbol: v2_0, isMappingSymbol: v2_1 } = arg1;
+    const ret = displaySymbolContext(handle0, toUint32(v2_0), v2_1 ? 1 : 0);
+    var len9 = dataView(memory0).getInt32(ret + 4, true);
+    var base9 = dataView(memory0).getInt32(ret + 0, true);
+    var result9 = [];
+    for(let i = 0; i < len9; i++){
+        const base = base9 + 24 * i;
+        let variant8;
+        switch(dataView(memory0).getUint8(base + 0, true)){
+            case 0:
+                {
+                    var ptr3 = dataView(memory0).getInt32(base + 4, true);
+                    var len3 = dataView(memory0).getInt32(base + 8, true);
+                    var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+                    let variant5;
+                    switch(dataView(memory0).getUint8(base + 12, true)){
+                        case 0:
+                            variant5 = void 0;
+                            break;
+                        case 1:
+                            var ptr4 = dataView(memory0).getInt32(base + 16, true);
+                            var len4 = dataView(memory0).getInt32(base + 20, true);
+                            var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+                            variant5 = result4;
+                            break;
+                        default:
+                            throw new TypeError('invalid variant discriminant for option');
+                    }
+                    variant8 = {
+                        tag: 'copy',
+                        val: {
+                            value: result3,
+                            label: variant5
+                        }
+                    };
+                    break;
+                }
+            case 1:
+                {
+                    var ptr6 = dataView(memory0).getInt32(base + 4, true);
+                    var len6 = dataView(memory0).getInt32(base + 8, true);
+                    var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+                    let enum7;
+                    switch(dataView(memory0).getUint8(base + 16, true)){
+                        case 0:
+                            enum7 = 'normal';
+                            break;
+                        case 1:
+                            enum7 = 'extab';
+                            break;
+                        default:
+                            throw new TypeError('invalid discriminant specified for SymbolNavigationKind');
+                    }
+                    variant8 = {
+                        tag: 'navigate',
+                        val: {
+                            label: result6,
+                            symbol: dataView(memory0).getInt32(base + 12, true) >>> 0,
+                            kind: enum7
+                        }
+                    };
+                    break;
+                }
+            case 2:
+                variant8 = {
+                    tag: 'separator'
+                };
+                break;
+            default:
+                throw new TypeError('invalid variant discriminant for ContextItem');
+        }
+        result9.push(variant8);
+    }
+    const retVal = result9;
+    postReturn6(ret);
+    return retVal;
+}
+let displaySymbolHover;
+function symbolHover(arg0, arg1) {
+    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;
+    var { symbol: v2_0, isMappingSymbol: v2_1 } = arg1;
+    const ret = displaySymbolHover(handle0, toUint32(v2_0), v2_1 ? 1 : 0);
+    var len7 = dataView(memory0).getInt32(ret + 4, true);
+    var base7 = dataView(memory0).getInt32(ret + 0, true);
+    var result7 = [];
+    for(let i = 0; i < len7; i++){
+        const base = base7 + 24 * i;
+        let variant6;
+        switch(dataView(memory0).getUint8(base + 0, true)){
+            case 0:
+                {
+                    var ptr3 = dataView(memory0).getInt32(base + 4, true);
+                    var len3 = dataView(memory0).getInt32(base + 8, true);
+                    var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+                    var ptr4 = dataView(memory0).getInt32(base + 12, true);
+                    var len4 = dataView(memory0).getInt32(base + 16, true);
+                    var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+                    let enum5;
+                    switch(dataView(memory0).getUint8(base + 20, true)){
+                        case 0:
+                            enum5 = 'normal';
+                            break;
+                        case 1:
+                            enum5 = 'emphasized';
+                            break;
+                        case 2:
+                            enum5 = 'special';
+                            break;
+                        default:
+                            throw new TypeError('invalid discriminant specified for HoverItemColor');
+                    }
+                    variant6 = {
+                        tag: 'text',
+                        val: {
+                            label: result3,
+                            value: result4,
+                            color: enum5
+                        }
+                    };
+                    break;
+                }
+            case 1:
+                variant6 = {
+                    tag: 'separator'
+                };
+                break;
+            default:
+                throw new TypeError('invalid variant discriminant for HoverItem');
+        }
+        result7.push(variant6);
+    }
+    const retVal = result7;
+    postReturn7(ret);
+    return retVal;
+}
+let displayInstructionContext;
+function instructionContext(arg0, arg1, arg2, arg3) {
+    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;
+    var { symbol: v2_0, isMappingSymbol: v2_1 } = arg1;
+    var handle4 = arg3[symbolRscHandle];
+    if (!handle4 || (handleTable2[(handle4 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
+    var handle3 = handleTable2[(handle4 << 1) + 1] & ~T_FLAG;
+    const ret = displayInstructionContext(handle0, toUint32(v2_0), v2_1 ? 1 : 0, toUint32(arg2), handle3);
+    let variant13;
+    switch(dataView(memory0).getUint8(ret + 0, true)){
+        case 0:
+            var len11 = dataView(memory0).getInt32(ret + 8, true);
+            var base11 = dataView(memory0).getInt32(ret + 4, true);
+            var result11 = [];
+            for(let i = 0; i < len11; i++){
+                const base = base11 + 24 * i;
+                let variant10;
+                switch(dataView(memory0).getUint8(base + 0, true)){
+                    case 0:
+                        {
+                            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 variant7;
+                            switch(dataView(memory0).getUint8(base + 12, true)){
+                                case 0:
+                                    variant7 = void 0;
+                                    break;
+                                case 1:
+                                    var ptr6 = dataView(memory0).getInt32(base + 16, true);
+                                    var len6 = dataView(memory0).getInt32(base + 20, true);
+                                    var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+                                    variant7 = result6;
+                                    break;
+                                default:
+                                    throw new TypeError('invalid variant discriminant for option');
+                            }
+                            variant10 = {
+                                tag: 'copy',
+                                val: {
+                                    value: result5,
+                                    label: variant7
+                                }
+                            };
+                            break;
+                        }
+                    case 1:
+                        {
+                            var ptr8 = dataView(memory0).getInt32(base + 4, true);
+                            var len8 = dataView(memory0).getInt32(base + 8, true);
+                            var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+                            let enum9;
+                            switch(dataView(memory0).getUint8(base + 16, true)){
+                                case 0:
+                                    enum9 = 'normal';
+                                    break;
+                                case 1:
+                                    enum9 = 'extab';
+                                    break;
+                                default:
+                                    throw new TypeError('invalid discriminant specified for SymbolNavigationKind');
+                            }
+                            variant10 = {
+                                tag: 'navigate',
+                                val: {
+                                    label: result8,
+                                    symbol: dataView(memory0).getInt32(base + 12, true) >>> 0,
+                                    kind: enum9
+                                }
+                            };
+                            break;
+                        }
+                    case 2:
+                        variant10 = {
+                            tag: 'separator'
+                        };
+                        break;
+                    default:
+                        throw new TypeError('invalid variant discriminant for ContextItem');
+                }
+                result11.push(variant10);
+            }
+            variant13 = {
+                tag: 'ok',
+                val: result11
+            };
+            break;
+        case 1:
+            var ptr12 = dataView(memory0).getInt32(ret + 4, true);
+            var len12 = dataView(memory0).getInt32(ret + 8, true);
+            var result12 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr12, len12));
+            variant13 = {
+                tag: 'err',
+                val: result12
+            };
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for expected');
+    }
+    const retVal = variant13;
+    postReturn8(ret);
+    if ('object' == typeof retVal && 'err' === retVal.tag) throw new ComponentError(retVal.val);
+    return retVal.val;
+}
+let displayInstructionHover;
+function instructionHover(arg0, arg1, arg2, arg3) {
+    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;
+    var { symbol: v2_0, isMappingSymbol: v2_1 } = arg1;
+    var handle4 = arg3[symbolRscHandle];
+    if (!handle4 || (handleTable2[(handle4 << 1) + 1] & T_FLAG) === 0) throw new TypeError('Resource error: Not a valid "DiffConfig" resource.');
+    var handle3 = handleTable2[(handle4 << 1) + 1] & ~T_FLAG;
+    const ret = displayInstructionHover(handle0, toUint32(v2_0), v2_1 ? 1 : 0, toUint32(arg2), handle3);
+    let variant11;
+    switch(dataView(memory0).getUint8(ret + 0, true)){
+        case 0:
+            var len9 = dataView(memory0).getInt32(ret + 8, true);
+            var base9 = dataView(memory0).getInt32(ret + 4, true);
+            var result9 = [];
+            for(let i = 0; i < len9; i++){
+                const base = base9 + 24 * i;
+                let variant8;
+                switch(dataView(memory0).getUint8(base + 0, true)){
+                    case 0:
+                        {
+                            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));
+                            var ptr6 = dataView(memory0).getInt32(base + 12, true);
+                            var len6 = dataView(memory0).getInt32(base + 16, true);
+                            var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+                            let enum7;
+                            switch(dataView(memory0).getUint8(base + 20, true)){
+                                case 0:
+                                    enum7 = 'normal';
+                                    break;
+                                case 1:
+                                    enum7 = 'emphasized';
+                                    break;
+                                case 2:
+                                    enum7 = 'special';
+                                    break;
+                                default:
+                                    throw new TypeError('invalid discriminant specified for HoverItemColor');
+                            }
+                            variant8 = {
+                                tag: 'text',
+                                val: {
+                                    label: result5,
+                                    value: result6,
+                                    color: enum7
+                                }
+                            };
+                            break;
+                        }
+                    case 1:
+                        variant8 = {
+                            tag: 'separator'
+                        };
+                        break;
+                    default:
+                        throw new TypeError('invalid variant discriminant for HoverItem');
+                }
+                result9.push(variant8);
+            }
+            variant11 = {
+                tag: 'ok',
+                val: result9
+            };
+            break;
+        case 1:
+            var ptr10 = dataView(memory0).getInt32(ret + 4, true);
+            var len10 = dataView(memory0).getInt32(ret + 8, true);
+            var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+            variant11 = {
+                tag: 'err',
+                val: result10
+            };
+            break;
+        default:
+            throw new TypeError('invalid variant discriminant for expected');
+    }
+    const retVal = variant11;
+    postReturn9(ret);
+    if ('object' == typeof retVal && 'err' === retVal.tag) throw new ComponentError(retVal.val);
+    return retVal.val;
+}
+const $init = (()=>{
+    let gen = function*() {
+        const module0 = fetchCompile(new URL('./objdiff.core.wasm', import.meta.url));
+        const module1 = base64Compile('AGFzbQEAAAABDQJgAX8AYAV/f39/fwADBQQBAAAABAUBcAEEBAccBQEwAAABMQABATIAAgEzAAMIJGltcG9ydHMBAAoxBBEAIAAgASACIAMgBEEAEQEACwkAIABBAREAAAsJACAAQQIRAAALCQAgAEEDEQAACwAvCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BzAuMjIzLjA');
+        const module2 = base64Compile('AGFzbQEAAAABDQJgAX8AYAV/f39/fwACJAUAATAAAQABMQAAAAEyAAAAATMAAAAIJGltcG9ydHMBcAEEBAkKAQBBAAsEAAECAwAvCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BzAuMjIzLjA');
+        ({ exports: exports0 } = yield instantiateCore((yield module1)));
+        ({ exports: exports1 } = yield instantiateCore((yield module0), {
+            '[export]objdiff:core/diff': {
+                '[resource-new]diff-config': trampoline2,
+                '[resource-new]object': trampoline1,
+                '[resource-new]object-diff': trampoline0
+            },
+            'wasi:logging/logging@0.1.0-draft': {
+                log: exports0['0']
+            }
+        }));
+        memory0 = exports1.memory;
+        ({ exports: exports2 } = yield instantiateCore((yield module2), {
+            '': {
+                $imports: exports0.$imports,
+                0: trampoline3,
+                1: exports1['objdiff:core/diff#[dtor]diff-config'],
+                2: exports1['objdiff:core/diff#[dtor]object'],
+                3: exports1['objdiff:core/diff#[dtor]object-diff']
+            }
+        }));
+        postReturn0 = exports1.cabi_post_version;
+        realloc0 = exports1.cabi_realloc;
+        postReturn1 = exports1['cabi_post_objdiff:core/diff#[method]diff-config.set-property'];
+        postReturn2 = exports1['cabi_post_objdiff:core/diff#[method]diff-config.get-property'];
+        postReturn3 = exports1['cabi_post_objdiff:core/display#display-sections'];
+        postReturn4 = exports1['cabi_post_objdiff:core/display#display-symbol'];
+        postReturn5 = exports1['cabi_post_objdiff:core/display#display-instruction-row'];
+        postReturn6 = exports1['cabi_post_objdiff:core/display#symbol-context'];
+        postReturn7 = exports1['cabi_post_objdiff:core/display#symbol-hover'];
+        postReturn8 = exports1['cabi_post_objdiff:core/display#instruction-context'];
+        postReturn9 = exports1['cabi_post_objdiff:core/display#instruction-hover'];
+        exports1Init = exports1.init;
+        exports1Version = exports1.version;
+        diffConstructorDiffConfig = exports1['objdiff:core/diff#[constructor]diff-config'];
+        diffMethodDiffConfigSetProperty = exports1['objdiff:core/diff#[method]diff-config.set-property'];
+        diffMethodDiffConfigGetProperty = exports1['objdiff:core/diff#[method]diff-config.get-property'];
+        diffStaticObjectParse = exports1['objdiff:core/diff#[static]object.parse'];
+        diffMethodObjectDiffFindSymbol = exports1['objdiff:core/diff#[method]object-diff.find-symbol'];
+        diffRunDiff = exports1['objdiff:core/diff#run-diff'];
+        displayDisplaySections = exports1['objdiff:core/display#display-sections'];
+        displayDisplaySymbol = exports1['objdiff:core/display#display-symbol'];
+        displayDisplayInstructionRow = exports1['objdiff:core/display#display-instruction-row'];
+        displaySymbolContext = exports1['objdiff:core/display#symbol-context'];
+        displaySymbolHover = exports1['objdiff:core/display#symbol-hover'];
+        displayInstructionContext = exports1['objdiff:core/display#instruction-context'];
+        displayInstructionHover = exports1['objdiff:core/display#instruction-hover'];
+    }();
+    let promise, resolve, reject;
+    function runNext(value) {
+        try {
+            let done;
+            do ({ value, done } = gen.next(value));
+            while (!(value instanceof Promise) && !done);
+            if (done) {
+                if (!resolve) return value;
+                resolve(value);
+            }
+            if (!promise) promise = new Promise((_resolve, _reject)=>(resolve = _resolve, reject = _reject));
+            value.then(runNext, reject);
+        } catch (e) {
+            if (reject) reject(e);
+            else throw e;
+        }
+    }
+    const maybeSyncReturn = runNext(null);
+    return promise || maybeSyncReturn;
+})();
+await $init;
+const diff = {
+    DiffConfig: DiffConfig,
+    Object: Object$1,
+    ObjectDiff: ObjectDiff,
+    runDiff: runDiff
+};
+const display = {
+    displayInstructionRow: displayInstructionRow,
+    displaySections: displaySections,
+    displaySymbol: displaySymbol,
+    instructionContext: instructionContext,
+    instructionHover: instructionHover,
+    symbolContext: symbolContext,
+    symbolHover: symbolHover
+};
+export { diff, display, init, version };