objdiff-wasm 2.0.0-beta.5 → 2.0.0-beta.7

package/dist/main.js

@@ -1242,678 +1242,6 @@ var DiffResult$Type = class extends MessageType {
   }
 };
 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;
@@ -1921,43 +1249,64 @@ var workerCallbacks = null;
 var workerReady = new Promise((resolve, reject) => {
   workerCallbacks = { start: performance.now(), resolve, reject };
 });
-function initialize(workerUrl) {
+async function initialize(data) {
   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);
+  let { workerUrl, wasmUrl } = data || {};
+  if (!workerUrl) {
+    workerUrl = new URL("./worker.js", import.meta.url);
+  }
+  if (!wasmUrl) {
+    wasmUrl = new URL("./objdiff_core_bg.wasm", import.meta.url);
+  }
+  const worker = new Worker(workerUrl, { type: "module" });
+  worker.onmessage = onMessage;
+  worker.onerror = (event) => {
+    console.error("Worker error", event);
+    workerCallbacks.reject(event);
   };
+  await defer({
+    type: "init",
+    wasmUrl
+  }, worker).then(() => {
+    workerCallbacks.resolve(worker);
+  }, (e) => {
+    workerCallbacks.reject(e);
+    throw e;
+  });
 }
 var globalMessageId = 0;
 var messageCallbacks = /* @__PURE__ */ new Map();
-function onMessage(worker, event) {
+function onMessage(event) {
   switch (event.data.type) {
-    case "ready":
-      workerCallbacks.resolve(worker);
-      break;
     case "result": {
-      const { messageId, result } = event.data;
+      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);
-        callbacks.resolve(result);
+        if (error != null) {
+          callbacks.reject(error);
+        } else {
+          callbacks.resolve(result);
+        }
+      } else {
+        console.warn(`Unknown message ID ${messageId}`);
       }
       break;
     }
   }
 }
-async function defer(message) {
-  if (!workerInit) {
-    throw new Error("Worker not initialized");
+async function defer(message, worker) {
+  if (worker == null) {
+    if (!workerInit) {
+      throw new Error("Worker not initialized");
+    }
+    worker = await workerReady;
   }
-  const worker = await workerReady;
   const messageId = globalMessageId++;
   const promise = new Promise((resolve, reject) => {
     messageCallbacks.set(messageId, { start: performance.now(), resolve, reject });
@@ -1970,7 +1319,7 @@ async function defer(message) {
 }
 async function runDiff(left, right, config) {
   const data = await defer({
-    type: "run_diff",
+    type: "run_diff_proto",
     left,
     right,
     config
@@ -1981,26 +1330,63 @@ async function runDiff(left, right, config) {
   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,
-  DiffDisplay,
   DiffKind,
   DiffResult,
-  DiffText,
-  DiffTextAddress,
-  DiffTextArgument,
-  DiffTextBasic,
-  DiffTextBasicColor,
-  DiffTextBranchDest,
-  DiffTextEol,
-  DiffTextLine,
-  DiffTextOpcode,
-  DiffTextSpacing,
-  DiffTextSymbol,
   FunctionDiff,
   Instruction,
   InstructionBranchFrom,
@@ -2013,7 +1399,9 @@ export {
   SectionKind,
   Symbol,
   SymbolFlag,
+  displayDiff,
   initialize,
+  oneof,
   runDiff
 };
 //# sourceMappingURL=main.js.map