objdiff-wasm 2.0.0-beta.9 → 3.0.0-alpha.1

package/dist/main.js

@@ -1,1415 +0,0 @@
-// gen/diff_pb.ts
-import { WireType } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MessageType } from "@protobuf-ts/runtime";
-var SymbolFlag = /* @__PURE__ */ ((SymbolFlag2) => {
-  SymbolFlag2[SymbolFlag2["SYMBOL_NONE"] = 0] = "SYMBOL_NONE";
-  SymbolFlag2[SymbolFlag2["SYMBOL_GLOBAL"] = 1] = "SYMBOL_GLOBAL";
-  SymbolFlag2[SymbolFlag2["SYMBOL_LOCAL"] = 2] = "SYMBOL_LOCAL";
-  SymbolFlag2[SymbolFlag2["SYMBOL_WEAK"] = 3] = "SYMBOL_WEAK";
-  SymbolFlag2[SymbolFlag2["SYMBOL_COMMON"] = 4] = "SYMBOL_COMMON";
-  SymbolFlag2[SymbolFlag2["SYMBOL_HIDDEN"] = 5] = "SYMBOL_HIDDEN";
-  return SymbolFlag2;
-})(SymbolFlag || {});
-var DiffKind = /* @__PURE__ */ ((DiffKind2) => {
-  DiffKind2[DiffKind2["DIFF_NONE"] = 0] = "DIFF_NONE";
-  DiffKind2[DiffKind2["DIFF_REPLACE"] = 1] = "DIFF_REPLACE";
-  DiffKind2[DiffKind2["DIFF_DELETE"] = 2] = "DIFF_DELETE";
-  DiffKind2[DiffKind2["DIFF_INSERT"] = 3] = "DIFF_INSERT";
-  DiffKind2[DiffKind2["DIFF_OP_MISMATCH"] = 4] = "DIFF_OP_MISMATCH";
-  DiffKind2[DiffKind2["DIFF_ARG_MISMATCH"] = 5] = "DIFF_ARG_MISMATCH";
-  return DiffKind2;
-})(DiffKind || {});
-var SectionKind = /* @__PURE__ */ ((SectionKind2) => {
-  SectionKind2[SectionKind2["SECTION_UNKNOWN"] = 0] = "SECTION_UNKNOWN";
-  SectionKind2[SectionKind2["SECTION_TEXT"] = 1] = "SECTION_TEXT";
-  SectionKind2[SectionKind2["SECTION_DATA"] = 2] = "SECTION_DATA";
-  SectionKind2[SectionKind2["SECTION_BSS"] = 3] = "SECTION_BSS";
-  SectionKind2[SectionKind2["SECTION_COMMON"] = 4] = "SECTION_COMMON";
-  return SectionKind2;
-})(SectionKind || {});
-var Symbol$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.Symbol", [
-      {
-        no: 1,
-        name: "name",
-        kind: "scalar",
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      {
-        no: 2,
-        name: "demangled_name",
-        kind: "scalar",
-        localName: "demangled_name",
-        opt: true,
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      {
-        no: 3,
-        name: "address",
-        kind: "scalar",
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      },
-      {
-        no: 4,
-        name: "size",
-        kind: "scalar",
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      },
-      {
-        no: 5,
-        name: "flags",
-        kind: "scalar",
-        T: 13
-        /*ScalarType.UINT32*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.name = "";
-    message.address = 0n;
-    message.size = 0n;
-    message.flags = 0;
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* string name */
-        1:
-          message.name = reader.string();
-          break;
-        case /* optional string demangled_name */
-        2:
-          message.demangled_name = reader.string();
-          break;
-        case /* uint64 address */
-        3:
-          message.address = reader.uint64().toBigInt();
-          break;
-        case /* uint64 size */
-        4:
-          message.size = reader.uint64().toBigInt();
-          break;
-        case /* uint32 flags */
-        5:
-          message.flags = reader.uint32();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.name !== "")
-      writer.tag(1, WireType.LengthDelimited).string(message.name);
-    if (message.demangled_name !== void 0)
-      writer.tag(2, WireType.LengthDelimited).string(message.demangled_name);
-    if (message.address !== 0n)
-      writer.tag(3, WireType.Varint).uint64(message.address);
-    if (message.size !== 0n)
-      writer.tag(4, WireType.Varint).uint64(message.size);
-    if (message.flags !== 0)
-      writer.tag(5, WireType.Varint).uint32(message.flags);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var Symbol = new Symbol$Type();
-var Instruction$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.Instruction", [
-      {
-        no: 1,
-        name: "address",
-        kind: "scalar",
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      },
-      {
-        no: 2,
-        name: "size",
-        kind: "scalar",
-        T: 13
-        /*ScalarType.UINT32*/
-      },
-      {
-        no: 3,
-        name: "opcode",
-        kind: "scalar",
-        T: 13
-        /*ScalarType.UINT32*/
-      },
-      {
-        no: 4,
-        name: "mnemonic",
-        kind: "scalar",
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      {
-        no: 5,
-        name: "formatted",
-        kind: "scalar",
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      {
-        no: 6,
-        name: "original",
-        kind: "scalar",
-        opt: true,
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      { no: 7, name: "arguments", kind: "message", repeat: 1, T: () => Argument },
-      { no: 8, name: "relocation", kind: "message", T: () => Relocation },
-      {
-        no: 9,
-        name: "branch_dest",
-        kind: "scalar",
-        localName: "branch_dest",
-        opt: true,
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      },
-      {
-        no: 10,
-        name: "line_number",
-        kind: "scalar",
-        localName: "line_number",
-        opt: true,
-        T: 13
-        /*ScalarType.UINT32*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.address = 0n;
-    message.size = 0;
-    message.opcode = 0;
-    message.mnemonic = "";
-    message.formatted = "";
-    message.arguments = [];
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* uint64 address */
-        1:
-          message.address = reader.uint64().toBigInt();
-          break;
-        case /* uint32 size */
-        2:
-          message.size = reader.uint32();
-          break;
-        case /* uint32 opcode */
-        3:
-          message.opcode = reader.uint32();
-          break;
-        case /* string mnemonic */
-        4:
-          message.mnemonic = reader.string();
-          break;
-        case /* string formatted */
-        5:
-          message.formatted = reader.string();
-          break;
-        case /* optional string original */
-        6:
-          message.original = reader.string();
-          break;
-        case /* repeated objdiff.diff.Argument arguments */
-        7:
-          message.arguments.push(Argument.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        case /* optional objdiff.diff.Relocation relocation */
-        8:
-          message.relocation = Relocation.internalBinaryRead(reader, reader.uint32(), options, message.relocation);
-          break;
-        case /* optional uint64 branch_dest */
-        9:
-          message.branch_dest = reader.uint64().toBigInt();
-          break;
-        case /* optional uint32 line_number */
-        10:
-          message.line_number = reader.uint32();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.address !== 0n)
-      writer.tag(1, WireType.Varint).uint64(message.address);
-    if (message.size !== 0)
-      writer.tag(2, WireType.Varint).uint32(message.size);
-    if (message.opcode !== 0)
-      writer.tag(3, WireType.Varint).uint32(message.opcode);
-    if (message.mnemonic !== "")
-      writer.tag(4, WireType.LengthDelimited).string(message.mnemonic);
-    if (message.formatted !== "")
-      writer.tag(5, WireType.LengthDelimited).string(message.formatted);
-    if (message.original !== void 0)
-      writer.tag(6, WireType.LengthDelimited).string(message.original);
-    for (let i = 0; i < message.arguments.length; i++)
-      Argument.internalBinaryWrite(message.arguments[i], writer.tag(7, WireType.LengthDelimited).fork(), options).join();
-    if (message.relocation)
-      Relocation.internalBinaryWrite(message.relocation, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
-    if (message.branch_dest !== void 0)
-      writer.tag(9, WireType.Varint).uint64(message.branch_dest);
-    if (message.line_number !== void 0)
-      writer.tag(10, WireType.Varint).uint32(message.line_number);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var Instruction = new Instruction$Type();
-var Argument$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.Argument", [
-      {
-        no: 1,
-        name: "plain_text",
-        kind: "scalar",
-        localName: "plain_text",
-        oneof: "value",
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      { no: 2, name: "argument", kind: "message", oneof: "value", T: () => ArgumentValue },
-      { no: 3, name: "relocation", kind: "message", oneof: "value", T: () => ArgumentRelocation },
-      {
-        no: 4,
-        name: "branch_dest",
-        kind: "scalar",
-        localName: "branch_dest",
-        oneof: "value",
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.value = { oneofKind: void 0 };
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* string plain_text */
-        1:
-          message.value = {
-            oneofKind: "plain_text",
-            plain_text: reader.string()
-          };
-          break;
-        case /* objdiff.diff.ArgumentValue argument */
-        2:
-          message.value = {
-            oneofKind: "argument",
-            argument: ArgumentValue.internalBinaryRead(reader, reader.uint32(), options, message.value.argument)
-          };
-          break;
-        case /* objdiff.diff.ArgumentRelocation relocation */
-        3:
-          message.value = {
-            oneofKind: "relocation",
-            relocation: ArgumentRelocation.internalBinaryRead(reader, reader.uint32(), options, message.value.relocation)
-          };
-          break;
-        case /* uint64 branch_dest */
-        4:
-          message.value = {
-            oneofKind: "branch_dest",
-            branch_dest: reader.uint64().toBigInt()
-          };
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.value.oneofKind === "plain_text")
-      writer.tag(1, WireType.LengthDelimited).string(message.value.plain_text);
-    if (message.value.oneofKind === "argument")
-      ArgumentValue.internalBinaryWrite(message.value.argument, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
-    if (message.value.oneofKind === "relocation")
-      ArgumentRelocation.internalBinaryWrite(message.value.relocation, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
-    if (message.value.oneofKind === "branch_dest")
-      writer.tag(4, WireType.Varint).uint64(message.value.branch_dest);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var Argument = new Argument$Type();
-var ArgumentValue$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.ArgumentValue", [
-      {
-        no: 1,
-        name: "signed",
-        kind: "scalar",
-        oneof: "value",
-        T: 3,
-        L: 0
-        /*LongType.BIGINT*/
-      },
-      {
-        no: 2,
-        name: "unsigned",
-        kind: "scalar",
-        oneof: "value",
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      },
-      {
-        no: 3,
-        name: "opaque",
-        kind: "scalar",
-        oneof: "value",
-        T: 9
-        /*ScalarType.STRING*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.value = { oneofKind: void 0 };
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* int64 signed */
-        1:
-          message.value = {
-            oneofKind: "signed",
-            signed: reader.int64().toBigInt()
-          };
-          break;
-        case /* uint64 unsigned */
-        2:
-          message.value = {
-            oneofKind: "unsigned",
-            unsigned: reader.uint64().toBigInt()
-          };
-          break;
-        case /* string opaque */
-        3:
-          message.value = {
-            oneofKind: "opaque",
-            opaque: reader.string()
-          };
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.value.oneofKind === "signed")
-      writer.tag(1, WireType.Varint).int64(message.value.signed);
-    if (message.value.oneofKind === "unsigned")
-      writer.tag(2, WireType.Varint).uint64(message.value.unsigned);
-    if (message.value.oneofKind === "opaque")
-      writer.tag(3, WireType.LengthDelimited).string(message.value.opaque);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var ArgumentValue = new ArgumentValue$Type();
-var ArgumentRelocation$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.ArgumentRelocation", []);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    return target ?? this.create();
-  }
-  internalBinaryWrite(message, writer, options) {
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var ArgumentRelocation = new ArgumentRelocation$Type();
-var Relocation$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.Relocation", [
-      {
-        no: 1,
-        name: "type",
-        kind: "scalar",
-        T: 13
-        /*ScalarType.UINT32*/
-      },
-      {
-        no: 2,
-        name: "type_name",
-        kind: "scalar",
-        localName: "type_name",
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      { no: 3, name: "target", kind: "message", T: () => RelocationTarget }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.type = 0;
-    message.type_name = "";
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* uint32 type */
-        1:
-          message.type = reader.uint32();
-          break;
-        case /* string type_name */
-        2:
-          message.type_name = reader.string();
-          break;
-        case /* objdiff.diff.RelocationTarget target */
-        3:
-          message.target = RelocationTarget.internalBinaryRead(reader, reader.uint32(), options, message.target);
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.type !== 0)
-      writer.tag(1, WireType.Varint).uint32(message.type);
-    if (message.type_name !== "")
-      writer.tag(2, WireType.LengthDelimited).string(message.type_name);
-    if (message.target)
-      RelocationTarget.internalBinaryWrite(message.target, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var Relocation = new Relocation$Type();
-var RelocationTarget$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.RelocationTarget", [
-      { no: 1, name: "symbol", kind: "message", T: () => Symbol },
-      {
-        no: 2,
-        name: "addend",
-        kind: "scalar",
-        T: 3,
-        L: 0
-        /*LongType.BIGINT*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.addend = 0n;
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* objdiff.diff.Symbol symbol */
-        1:
-          message.symbol = Symbol.internalBinaryRead(reader, reader.uint32(), options, message.symbol);
-          break;
-        case /* int64 addend */
-        2:
-          message.addend = reader.int64().toBigInt();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.symbol)
-      Symbol.internalBinaryWrite(message.symbol, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-    if (message.addend !== 0n)
-      writer.tag(2, WireType.Varint).int64(message.addend);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var RelocationTarget = new RelocationTarget$Type();
-var InstructionDiff$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.InstructionDiff", [
-      { no: 1, name: "diff_kind", kind: "enum", localName: "diff_kind", T: () => ["objdiff.diff.DiffKind", DiffKind] },
-      { no: 2, name: "instruction", kind: "message", T: () => Instruction },
-      { no: 3, name: "branch_from", kind: "message", localName: "branch_from", T: () => InstructionBranchFrom },
-      { no: 4, name: "branch_to", kind: "message", localName: "branch_to", T: () => InstructionBranchTo },
-      { no: 5, name: "arg_diff", kind: "message", localName: "arg_diff", repeat: 1, T: () => ArgumentDiff }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.diff_kind = 0;
-    message.arg_diff = [];
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* objdiff.diff.DiffKind diff_kind */
-        1:
-          message.diff_kind = reader.int32();
-          break;
-        case /* optional objdiff.diff.Instruction instruction */
-        2:
-          message.instruction = Instruction.internalBinaryRead(reader, reader.uint32(), options, message.instruction);
-          break;
-        case /* optional objdiff.diff.InstructionBranchFrom branch_from */
-        3:
-          message.branch_from = InstructionBranchFrom.internalBinaryRead(reader, reader.uint32(), options, message.branch_from);
-          break;
-        case /* optional objdiff.diff.InstructionBranchTo branch_to */
-        4:
-          message.branch_to = InstructionBranchTo.internalBinaryRead(reader, reader.uint32(), options, message.branch_to);
-          break;
-        case /* repeated objdiff.diff.ArgumentDiff arg_diff */
-        5:
-          message.arg_diff.push(ArgumentDiff.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.diff_kind !== 0)
-      writer.tag(1, WireType.Varint).int32(message.diff_kind);
-    if (message.instruction)
-      Instruction.internalBinaryWrite(message.instruction, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
-    if (message.branch_from)
-      InstructionBranchFrom.internalBinaryWrite(message.branch_from, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
-    if (message.branch_to)
-      InstructionBranchTo.internalBinaryWrite(message.branch_to, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
-    for (let i = 0; i < message.arg_diff.length; i++)
-      ArgumentDiff.internalBinaryWrite(message.arg_diff[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var InstructionDiff = new InstructionDiff$Type();
-var ArgumentDiff$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.ArgumentDiff", [
-      {
-        no: 1,
-        name: "diff_index",
-        kind: "scalar",
-        localName: "diff_index",
-        opt: true,
-        T: 13
-        /*ScalarType.UINT32*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* optional uint32 diff_index */
-        1:
-          message.diff_index = reader.uint32();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.diff_index !== void 0)
-      writer.tag(1, WireType.Varint).uint32(message.diff_index);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var ArgumentDiff = new ArgumentDiff$Type();
-var InstructionBranchFrom$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.InstructionBranchFrom", [
-      {
-        no: 1,
-        name: "instruction_index",
-        kind: "scalar",
-        localName: "instruction_index",
-        repeat: 1,
-        T: 13
-        /*ScalarType.UINT32*/
-      },
-      {
-        no: 2,
-        name: "branch_index",
-        kind: "scalar",
-        localName: "branch_index",
-        T: 13
-        /*ScalarType.UINT32*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.instruction_index = [];
-    message.branch_index = 0;
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* repeated uint32 instruction_index */
-        1:
-          if (wireType === WireType.LengthDelimited)
-            for (let e = reader.int32() + reader.pos; reader.pos < e; )
-              message.instruction_index.push(reader.uint32());
-          else
-            message.instruction_index.push(reader.uint32());
-          break;
-        case /* uint32 branch_index */
-        2:
-          message.branch_index = reader.uint32();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.instruction_index.length) {
-      writer.tag(1, WireType.LengthDelimited).fork();
-      for (let i = 0; i < message.instruction_index.length; i++)
-        writer.uint32(message.instruction_index[i]);
-      writer.join();
-    }
-    if (message.branch_index !== 0)
-      writer.tag(2, WireType.Varint).uint32(message.branch_index);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var InstructionBranchFrom = new InstructionBranchFrom$Type();
-var InstructionBranchTo$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.InstructionBranchTo", [
-      {
-        no: 1,
-        name: "instruction_index",
-        kind: "scalar",
-        localName: "instruction_index",
-        T: 13
-        /*ScalarType.UINT32*/
-      },
-      {
-        no: 2,
-        name: "branch_index",
-        kind: "scalar",
-        localName: "branch_index",
-        T: 13
-        /*ScalarType.UINT32*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.instruction_index = 0;
-    message.branch_index = 0;
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* uint32 instruction_index */
-        1:
-          message.instruction_index = reader.uint32();
-          break;
-        case /* uint32 branch_index */
-        2:
-          message.branch_index = reader.uint32();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.instruction_index !== 0)
-      writer.tag(1, WireType.Varint).uint32(message.instruction_index);
-    if (message.branch_index !== 0)
-      writer.tag(2, WireType.Varint).uint32(message.branch_index);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var InstructionBranchTo = new InstructionBranchTo$Type();
-var FunctionDiff$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.FunctionDiff", [
-      { no: 1, name: "symbol", kind: "message", T: () => Symbol },
-      { no: 2, name: "instructions", kind: "message", repeat: 1, T: () => InstructionDiff },
-      {
-        no: 3,
-        name: "match_percent",
-        kind: "scalar",
-        localName: "match_percent",
-        opt: true,
-        T: 2
-        /*ScalarType.FLOAT*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.instructions = [];
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* objdiff.diff.Symbol symbol */
-        1:
-          message.symbol = Symbol.internalBinaryRead(reader, reader.uint32(), options, message.symbol);
-          break;
-        case /* repeated objdiff.diff.InstructionDiff instructions */
-        2:
-          message.instructions.push(InstructionDiff.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        case /* optional float match_percent */
-        3:
-          message.match_percent = reader.float();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.symbol)
-      Symbol.internalBinaryWrite(message.symbol, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-    for (let i = 0; i < message.instructions.length; i++)
-      InstructionDiff.internalBinaryWrite(message.instructions[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
-    if (message.match_percent !== void 0)
-      writer.tag(3, WireType.Bit32).float(message.match_percent);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var FunctionDiff = new FunctionDiff$Type();
-var DataDiff$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.DataDiff", [
-      { no: 1, name: "kind", kind: "enum", T: () => ["objdiff.diff.DiffKind", DiffKind] },
-      {
-        no: 2,
-        name: "data",
-        kind: "scalar",
-        T: 12
-        /*ScalarType.BYTES*/
-      },
-      {
-        no: 3,
-        name: "size",
-        kind: "scalar",
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.kind = 0;
-    message.data = new Uint8Array(0);
-    message.size = 0n;
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* objdiff.diff.DiffKind kind */
-        1:
-          message.kind = reader.int32();
-          break;
-        case /* bytes data */
-        2:
-          message.data = reader.bytes();
-          break;
-        case /* uint64 size */
-        3:
-          message.size = reader.uint64().toBigInt();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.kind !== 0)
-      writer.tag(1, WireType.Varint).int32(message.kind);
-    if (message.data.length)
-      writer.tag(2, WireType.LengthDelimited).bytes(message.data);
-    if (message.size !== 0n)
-      writer.tag(3, WireType.Varint).uint64(message.size);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var DataDiff = new DataDiff$Type();
-var SectionDiff$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.SectionDiff", [
-      {
-        no: 1,
-        name: "name",
-        kind: "scalar",
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      { no: 2, name: "kind", kind: "enum", T: () => ["objdiff.diff.SectionKind", SectionKind] },
-      {
-        no: 3,
-        name: "size",
-        kind: "scalar",
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      },
-      {
-        no: 4,
-        name: "address",
-        kind: "scalar",
-        T: 4,
-        L: 0
-        /*LongType.BIGINT*/
-      },
-      { no: 5, name: "functions", kind: "message", repeat: 1, T: () => FunctionDiff },
-      { no: 6, name: "data", kind: "message", repeat: 1, T: () => DataDiff },
-      {
-        no: 7,
-        name: "match_percent",
-        kind: "scalar",
-        localName: "match_percent",
-        opt: true,
-        T: 2
-        /*ScalarType.FLOAT*/
-      }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.name = "";
-    message.kind = 0;
-    message.size = 0n;
-    message.address = 0n;
-    message.functions = [];
-    message.data = [];
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* string name */
-        1:
-          message.name = reader.string();
-          break;
-        case /* objdiff.diff.SectionKind kind */
-        2:
-          message.kind = reader.int32();
-          break;
-        case /* uint64 size */
-        3:
-          message.size = reader.uint64().toBigInt();
-          break;
-        case /* uint64 address */
-        4:
-          message.address = reader.uint64().toBigInt();
-          break;
-        case /* repeated objdiff.diff.FunctionDiff functions */
-        5:
-          message.functions.push(FunctionDiff.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        case /* repeated objdiff.diff.DataDiff data */
-        6:
-          message.data.push(DataDiff.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        case /* optional float match_percent */
-        7:
-          message.match_percent = reader.float();
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.name !== "")
-      writer.tag(1, WireType.LengthDelimited).string(message.name);
-    if (message.kind !== 0)
-      writer.tag(2, WireType.Varint).int32(message.kind);
-    if (message.size !== 0n)
-      writer.tag(3, WireType.Varint).uint64(message.size);
-    if (message.address !== 0n)
-      writer.tag(4, WireType.Varint).uint64(message.address);
-    for (let i = 0; i < message.functions.length; i++)
-      FunctionDiff.internalBinaryWrite(message.functions[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
-    for (let i = 0; i < message.data.length; i++)
-      DataDiff.internalBinaryWrite(message.data[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
-    if (message.match_percent !== void 0)
-      writer.tag(7, WireType.Bit32).float(message.match_percent);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var SectionDiff = new SectionDiff$Type();
-var ObjectDiff$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.ObjectDiff", [
-      { no: 1, name: "sections", kind: "message", repeat: 1, T: () => SectionDiff }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.sections = [];
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* repeated objdiff.diff.SectionDiff sections */
-        1:
-          message.sections.push(SectionDiff.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    for (let i = 0; i < message.sections.length; i++)
-      SectionDiff.internalBinaryWrite(message.sections[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var ObjectDiff = new ObjectDiff$Type();
-var DiffResult$Type = class extends MessageType {
-  constructor() {
-    super("objdiff.diff.DiffResult", [
-      { no: 1, name: "left", kind: "message", T: () => ObjectDiff },
-      { no: 2, name: "right", kind: "message", T: () => ObjectDiff }
-    ]);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case /* optional objdiff.diff.ObjectDiff left */
-        1:
-          message.left = ObjectDiff.internalBinaryRead(reader, reader.uint32(), options, message.left);
-          break;
-        case /* optional objdiff.diff.ObjectDiff right */
-        2:
-          message.right = ObjectDiff.internalBinaryRead(reader, reader.uint32(), options, message.right);
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
-  }
-  internalBinaryWrite(message, writer, options) {
-    if (message.left)
-      ObjectDiff.internalBinaryWrite(message.left, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-    if (message.right)
-      ObjectDiff.internalBinaryWrite(message.right, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-};
-var DiffResult = new DiffResult$Type();
-
-// src/main.ts
-var workerInit = false;
-var workerCallbacks = null;
-var workerReady = new Promise((resolve, reject) => {
-  workerCallbacks = { start: performance.now(), resolve, reject };
-});
-async function initialize(data) {
-  if (workerInit) {
-    return workerReady;
-  }
-  workerInit = true;
-  let { workerUrl, wasmUrl } = data || {};
-  if (!workerUrl) {
-    try {
-      workerUrl = new URL("./worker.js", import.meta.url);
-    } catch (_) {
-      workerUrl = "worker.js";
-    }
-  }
-  if (!wasmUrl) {
-    try {
-      wasmUrl = new URL("./objdiff_core_bg.wasm", import.meta.url);
-    } catch (_) {
-      wasmUrl = "objdiff_core_bg.js";
-    }
-  }
-  const worker = new Worker(workerUrl, {
-    name: "objdiff",
-    type: "module"
-  });
-  worker.onmessage = onMessage;
-  worker.onerror = (event) => {
-    console.error("Worker error", event);
-    workerCallbacks.reject("Worker failed to initialize, wrong URL?");
-  };
-  defer({
-    type: "init",
-    // URL can't be sent directly
-    wasmUrl: wasmUrl.toString()
-  }, worker).then(() => {
-    workerCallbacks.resolve(worker);
-  }, (e) => {
-    workerCallbacks.reject(e);
-    throw e;
-  });
-  return workerReady;
-}
-var globalMessageId = 0;
-var messageCallbacks = /* @__PURE__ */ new Map();
-function onMessage(event) {
-  switch (event.data.type) {
-    case "result": {
-      const { result, error, messageId } = event.data;
-      const callbacks = messageCallbacks.get(messageId);
-      if (callbacks) {
-        const end = performance.now();
-        console.debug(`Message ${messageId} took ${end - callbacks.start}ms`);
-        messageCallbacks.delete(messageId);
-        if (error != null) {
-          callbacks.reject(error);
-        } else {
-          callbacks.resolve(result);
-        }
-      } else {
-        console.warn(`Unknown message ID ${messageId}`);
-      }
-      break;
-    }
-  }
-}
-async function defer(message, worker) {
-  worker = worker || await initialize();
-  const messageId = globalMessageId++;
-  const promise = new Promise((resolve, reject) => {
-    messageCallbacks.set(messageId, { start: performance.now(), resolve, reject });
-  });
-  worker.postMessage({
-    ...message,
-    messageId
-  });
-  return promise;
-}
-async function runDiff(left, right, config) {
-  const data = await defer({
-    type: "run_diff_proto",
-    left,
-    right,
-    config
-  });
-  const parseStart = performance.now();
-  const result = DiffResult.fromBinary(data, { readUnknownField: false });
-  const end = performance.now();
-  console.debug(`Parsing message took ${end - parseStart}ms`);
-  return result;
-}
-function oneof(type) {
-  return type;
-}
-function displayDiff(diff, baseAddr, cb) {
-  const ins = diff.instruction;
-  if (!ins) {
-    return;
-  }
-  if (ins.line_number != null) {
-    cb({ type: "line", line_number: ins.line_number });
-  }
-  cb({ type: "address", address: ins.address - baseAddr });
-  if (diff.branch_from) {
-    cb({ type: "basic_color", text: " ~> ", index: diff.branch_from.branch_index });
-  } else {
-    cb({ type: "spacing", count: 4 });
-  }
-  cb({ type: "opcode", mnemonic: ins.mnemonic, opcode: ins.opcode });
-  for (let i = 0; i < ins.arguments.length; i++) {
-    if (i === 0) {
-      cb({ type: "spacing", count: 1 });
-    }
-    const arg = oneof(ins.arguments[i].value);
-    const diff_index = diff.arg_diff[i]?.diff_index;
-    switch (arg.oneofKind) {
-      case "plain_text":
-        cb({ type: "basic", text: arg.plain_text, diff_index });
-        break;
-      case "argument":
-        cb({ type: "argument", value: arg.argument, diff_index });
-        break;
-      case "relocation": {
-        const reloc = ins.relocation;
-        cb({ type: "symbol", target: reloc.target, diff_index });
-        break;
-      }
-      case "branch_dest":
-        if (arg.branch_dest < baseAddr) {
-          cb({ type: "basic", text: "<unknown>", diff_index });
-        } else {
-          cb({ type: "branch_dest", address: arg.branch_dest - baseAddr, diff_index });
-        }
-        break;
-    }
-  }
-  if (diff.branch_to) {
-    cb({ type: "basic_color", text: " ~> ", index: diff.branch_to.branch_index });
-  }
-}
-export {
-  Argument,
-  ArgumentDiff,
-  ArgumentRelocation,
-  ArgumentValue,
-  DataDiff,
-  DiffKind,
-  DiffResult,
-  FunctionDiff,
-  Instruction,
-  InstructionBranchFrom,
-  InstructionBranchTo,
-  InstructionDiff,
-  ObjectDiff,
-  Relocation,
-  RelocationTarget,
-  SectionDiff,
-  SectionKind,
-  Symbol,
-  SymbolFlag,
-  displayDiff,
-  initialize,
-  oneof,
-  runDiff
-};
-//# sourceMappingURL=main.js.map