objdiff-wasm 2.0.0-beta.4

package/dist/main.js

@@ -0,0 +1,1955 @@
+// 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: "display", kind: "message", repeat: 1, T: () => DiffDisplay }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.diff_kind = 0;
+    message.display = [];
+    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.DiffDisplay display */
+        5:
+          message.display.push(DiffDisplay.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.display.length; i++)
+      DiffDisplay.internalBinaryWrite(message.display[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 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();
+var DiffDisplay$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffDisplay", [
+      { no: 1, name: "text", kind: "message", T: () => DiffText },
+      {
+        no: 2,
+        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 /* objdiff.diff.DiffText text */
+        1:
+          message.text = DiffText.internalBinaryRead(reader, reader.uint32(), options, message.text);
+          break;
+        case /* optional uint32 diff_index */
+        2:
+          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.text)
+      DiffText.internalBinaryWrite(message.text, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    if (message.diff_index !== void 0)
+      writer.tag(2, 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 DiffDisplay = new DiffDisplay$Type();
+var DiffText$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffText", [
+      { no: 1, name: "basic", kind: "message", oneof: "text", T: () => DiffTextBasic },
+      { no: 2, name: "basic_color", kind: "message", localName: "basic_color", oneof: "text", T: () => DiffTextBasicColor },
+      { no: 3, name: "line", kind: "message", oneof: "text", T: () => DiffTextLine },
+      { no: 4, name: "address", kind: "message", oneof: "text", T: () => DiffTextAddress },
+      { no: 5, name: "opcode", kind: "message", oneof: "text", T: () => DiffTextOpcode },
+      { no: 6, name: "argument", kind: "message", oneof: "text", T: () => DiffTextArgument },
+      { no: 7, name: "branch_dest", kind: "message", localName: "branch_dest", oneof: "text", T: () => DiffTextBranchDest },
+      { no: 8, name: "symbol", kind: "message", oneof: "text", T: () => DiffTextSymbol },
+      { no: 9, name: "spacing", kind: "message", oneof: "text", T: () => DiffTextSpacing },
+      { no: 10, name: "eol", kind: "message", oneof: "text", T: () => DiffTextEol }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.text = { 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 /* objdiff.diff.DiffTextBasic basic */
+        1:
+          message.text = {
+            oneofKind: "basic",
+            basic: DiffTextBasic.internalBinaryRead(reader, reader.uint32(), options, message.text.basic)
+          };
+          break;
+        case /* objdiff.diff.DiffTextBasicColor basic_color */
+        2:
+          message.text = {
+            oneofKind: "basic_color",
+            basic_color: DiffTextBasicColor.internalBinaryRead(reader, reader.uint32(), options, message.text.basic_color)
+          };
+          break;
+        case /* objdiff.diff.DiffTextLine line */
+        3:
+          message.text = {
+            oneofKind: "line",
+            line: DiffTextLine.internalBinaryRead(reader, reader.uint32(), options, message.text.line)
+          };
+          break;
+        case /* objdiff.diff.DiffTextAddress address */
+        4:
+          message.text = {
+            oneofKind: "address",
+            address: DiffTextAddress.internalBinaryRead(reader, reader.uint32(), options, message.text.address)
+          };
+          break;
+        case /* objdiff.diff.DiffTextOpcode opcode */
+        5:
+          message.text = {
+            oneofKind: "opcode",
+            opcode: DiffTextOpcode.internalBinaryRead(reader, reader.uint32(), options, message.text.opcode)
+          };
+          break;
+        case /* objdiff.diff.DiffTextArgument argument */
+        6:
+          message.text = {
+            oneofKind: "argument",
+            argument: DiffTextArgument.internalBinaryRead(reader, reader.uint32(), options, message.text.argument)
+          };
+          break;
+        case /* objdiff.diff.DiffTextBranchDest branch_dest */
+        7:
+          message.text = {
+            oneofKind: "branch_dest",
+            branch_dest: DiffTextBranchDest.internalBinaryRead(reader, reader.uint32(), options, message.text.branch_dest)
+          };
+          break;
+        case /* objdiff.diff.DiffTextSymbol symbol */
+        8:
+          message.text = {
+            oneofKind: "symbol",
+            symbol: DiffTextSymbol.internalBinaryRead(reader, reader.uint32(), options, message.text.symbol)
+          };
+          break;
+        case /* objdiff.diff.DiffTextSpacing spacing */
+        9:
+          message.text = {
+            oneofKind: "spacing",
+            spacing: DiffTextSpacing.internalBinaryRead(reader, reader.uint32(), options, message.text.spacing)
+          };
+          break;
+        case /* objdiff.diff.DiffTextEol eol */
+        10:
+          message.text = {
+            oneofKind: "eol",
+            eol: DiffTextEol.internalBinaryRead(reader, reader.uint32(), options, message.text.eol)
+          };
+          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.text.oneofKind === "basic")
+      DiffTextBasic.internalBinaryWrite(message.text.basic, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "basic_color")
+      DiffTextBasicColor.internalBinaryWrite(message.text.basic_color, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "line")
+      DiffTextLine.internalBinaryWrite(message.text.line, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "address")
+      DiffTextAddress.internalBinaryWrite(message.text.address, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "opcode")
+      DiffTextOpcode.internalBinaryWrite(message.text.opcode, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "argument")
+      DiffTextArgument.internalBinaryWrite(message.text.argument, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "branch_dest")
+      DiffTextBranchDest.internalBinaryWrite(message.text.branch_dest, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "symbol")
+      DiffTextSymbol.internalBinaryWrite(message.text.symbol, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "spacing")
+      DiffTextSpacing.internalBinaryWrite(message.text.spacing, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+    if (message.text.oneofKind === "eol")
+      DiffTextEol.internalBinaryWrite(message.text.eol, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DiffText = new DiffText$Type();
+var DiffTextBasic$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextBasic", [
+      {
+        no: 1,
+        name: "text",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.text = "";
+    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 text */
+        1:
+          message.text = 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.text !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.text);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DiffTextBasic = new DiffTextBasic$Type();
+var DiffTextBasicColor$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextBasicColor", [
+      {
+        no: 1,
+        name: "text",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "index",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.text = "";
+    message.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 /* string text */
+        1:
+          message.text = reader.string();
+          break;
+        case /* uint32 index */
+        2:
+          message.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.text !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.text);
+    if (message.index !== 0)
+      writer.tag(2, WireType.Varint).uint32(message.index);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DiffTextBasicColor = new DiffTextBasicColor$Type();
+var DiffTextLine$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextLine", [
+      {
+        no: 1,
+        name: "line_number",
+        kind: "scalar",
+        localName: "line_number",
+        T: 13
+        /*ScalarType.UINT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.line_number = 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 line_number */
+        1:
+          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.line_number !== 0)
+      writer.tag(1, 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 DiffTextLine = new DiffTextLine$Type();
+var DiffTextAddress$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextAddress", [
+      {
+        no: 1,
+        name: "address",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.address = 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 /* uint64 address */
+        1:
+          message.address = 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.address !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.address);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DiffTextAddress = new DiffTextAddress$Type();
+var DiffTextOpcode$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextOpcode", [
+      {
+        no: 1,
+        name: "mnemonic",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "opcode",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.mnemonic = "";
+    message.opcode = 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 mnemonic */
+        1:
+          message.mnemonic = reader.string();
+          break;
+        case /* uint32 opcode */
+        2:
+          message.opcode = 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.mnemonic !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.mnemonic);
+    if (message.opcode !== 0)
+      writer.tag(2, WireType.Varint).uint32(message.opcode);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DiffTextOpcode = new DiffTextOpcode$Type();
+var DiffTextArgument$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextArgument", [
+      { no: 1, name: "value", kind: "message", T: () => ArgumentValue }
+    ]);
+  }
+  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 /* objdiff.diff.ArgumentValue value */
+        1:
+          message.value = ArgumentValue.internalBinaryRead(reader, reader.uint32(), options, message.value);
+          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)
+      ArgumentValue.internalBinaryWrite(message.value, 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 DiffTextArgument = new DiffTextArgument$Type();
+var DiffTextBranchDest$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextBranchDest", [
+      {
+        no: 1,
+        name: "address",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.address = 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 /* uint64 address */
+        1:
+          message.address = 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.address !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.address);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DiffTextBranchDest = new DiffTextBranchDest$Type();
+var DiffTextSymbol$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextSymbol", [
+      { no: 1, name: "target", kind: "message", T: () => RelocationTarget }
+    ]);
+  }
+  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 /* objdiff.diff.RelocationTarget target */
+        1:
+          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.target)
+      RelocationTarget.internalBinaryWrite(message.target, 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 DiffTextSymbol = new DiffTextSymbol$Type();
+var DiffTextSpacing$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextSpacing", [
+      {
+        no: 1,
+        name: "count",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.count = 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 count */
+        1:
+          message.count = 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.count !== 0)
+      writer.tag(1, WireType.Varint).uint32(message.count);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DiffTextSpacing = new DiffTextSpacing$Type();
+var DiffTextEol$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.DiffTextEol", []);
+  }
+  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 DiffTextEol = new DiffTextEol$Type();
+
+// src/main.ts
+var workerInit = false;
+var workerCallbacks = null;
+var workerReady = new Promise((resolve, reject) => {
+  workerCallbacks = { start: performance.now(), resolve, reject };
+});
+function initialize(workerUrl) {
+  if (workerInit) {
+    return;
+  }
+  workerInit = true;
+  const worker = new Worker(workerUrl || "worker.js", { type: "module" });
+  worker.onmessage = onMessage.bind(null, worker);
+  worker.onerror = (error) => {
+    console.error("Worker error", error);
+    workerCallbacks.reject(error);
+  };
+}
+var globalMessageId = 0;
+var messageCallbacks = /* @__PURE__ */ new Map();
+function onMessage(worker, event) {
+  switch (event.data.type) {
+    case "ready":
+      workerCallbacks.resolve(worker);
+      break;
+    case "result": {
+      const { messageId, result } = 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);
+        callbacks.resolve(result);
+      }
+      break;
+    }
+  }
+}
+async function defer(message) {
+  if (!workerInit) {
+    throw new Error("Worker not initialized");
+  }
+  const worker = await workerReady;
+  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",
+    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;
+}
+export {
+  Argument,
+  ArgumentRelocation,
+  ArgumentValue,
+  DataDiff,
+  DiffKind,
+  DiffResult,
+  Instruction,
+  InstructionBranchFrom,
+  InstructionBranchTo,
+  InstructionDiff,
+  ObjectDiff,
+  Relocation,
+  RelocationTarget,
+  SectionDiff,
+  SectionKind,
+  Symbol,
+  SymbolFlag,
+  initialize,
+  runDiff
+};
+//# sourceMappingURL=main.js.map