objdiff-wasm 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/main.js

@@ -641,13 +641,13 @@ var InstructionDiff$Type = class extends MessageType {
       { 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 }
+      { no: 5, name: "arg_diff", kind: "message", localName: "arg_diff", repeat: 1, T: () => ArgumentDiff }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
     message.diff_kind = 0;
-    message.display = [];
+    message.arg_diff = [];
     if (value !== void 0)
       reflectionMergePartial(this, message, value);
     return message;
@@ -673,9 +673,9 @@ var InstructionDiff$Type = class extends MessageType {
         4:
           message.branch_to = InstructionBranchTo.internalBinaryRead(reader, reader.uint32(), options, message.branch_to);
           break;
-        case /* repeated objdiff.diff.DiffDisplay display */
+        case /* repeated objdiff.diff.ArgumentDiff arg_diff */
         5:
-          message.display.push(DiffDisplay.internalBinaryRead(reader, reader.uint32(), options));
+          message.arg_diff.push(ArgumentDiff.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -697,8 +697,8 @@ var InstructionDiff$Type = class extends MessageType {
       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();
+    for (let i = 0; i < message.arg_diff.length; i++)
+      ArgumentDiff.internalBinaryWrite(message.arg_diff[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -706,6 +706,56 @@ var InstructionDiff$Type = class extends MessageType {
   }
 };
 var InstructionDiff = new InstructionDiff$Type();
+var ArgumentDiff$Type = class extends MessageType {
+  constructor() {
+    super("objdiff.diff.ArgumentDiff", [
+      {
+        no: 1,
+        name: "diff_index",
+        kind: "scalar",
+        localName: "diff_index",
+        opt: true,
+        T: 13
+        /*ScalarType.UINT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional uint32 diff_index */
+        1:
+          message.diff_index = reader.uint32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.diff_index !== void 0)
+      writer.tag(1, WireType.Varint).uint32(message.diff_index);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var ArgumentDiff = new ArgumentDiff$Type();
 var InstructionBranchFrom$Type = class extends MessageType {
   constructor() {
     super("objdiff.diff.InstructionBranchFrom", [
@@ -1192,752 +1242,134 @@ 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;
+
+// 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;
   }
-  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);
+  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);
+      } else {
+        console.warn(`Unknown message ID ${messageId}`);
       }
+      break;
     }
-    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;
+}
+async function defer(message) {
+  if (!workerInit) {
+    throw new Error("Worker not initialized");
   }
-  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;
+  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;
+}
+function oneof(type) {
+  return type;
+}
+function displayDiff(diff, baseAddr, cb) {
+  var _a;
+  const ins = diff.instruction;
+  if (!ins) {
+    return;
   }
-};
-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*/
-      }
-    ]);
+  if (ins.line_number != null) {
+    cb({ type: "line", line_number: ins.line_number });
   }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    message.text = "";
-    if (value !== void 0)
-      reflectionMergePartial(this, message, value);
-    return message;
+  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 });
   }
-  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);
+  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 = (_a = diff.arg_diff[i]) == null ? void 0 : _a.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;
     }
-    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;
+  if (diff.branch_to) {
+    cb({ type: "basic_color", text: " ~> ", index: diff.branch_to.branch_index });
   }
-};
-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,
+  ArgumentDiff,
   ArgumentRelocation,
   ArgumentValue,
   DataDiff,
   DiffKind,
   DiffResult,
+  FunctionDiff,
   Instruction,
   InstructionBranchFrom,
   InstructionBranchTo,
@@ -1949,7 +1381,9 @@ export {
   SectionKind,
   Symbol,
   SymbolFlag,
+  displayDiff,
   initialize,
+  oneof,
   runDiff
 };
 //# sourceMappingURL=main.js.map