jsilnet 0.0.0-stage → 0.2.0

package/src/pe/headers.js

@@ -0,0 +1,491 @@
+import { inflateRawSync } from "../platform/compression.js";
+import { BinaryReader } from "../binary/reader.js";
+import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
+import { MetadataHeaps, parseMetadataRoot } from "../metadata/streams.js";
+import { parseTablesStream } from "../metadata/tables.js";
+import { parsePortablePdbTables } from "../metadata/portable-pdb.js";
+
+const maxEmbeddedPortablePdbSize = 0x10000000;
+
+function requireSignature(actual, expected, offset, name) {
+  if (actual !== expected) throw new FormatError(`Invalid ${name} signature`, { offset });
+}
+
+function isPowerOfTwo(value) {
+  return value !== 0 && (value & (value - 1)) === 0;
+}
+
+function parseCodeViewData(bytes, offset, size) {
+  if (size < 4) {
+    throw new FormatError("CodeView debug record is shorter than its signature", {
+      offset,
+      context: "PE CodeView data"
+    });
+  }
+  const signature = new TextDecoder("ascii").decode(bytes.subarray(offset, offset + 4));
+  const view = new DataView(bytes.buffer, bytes.byteOffset + offset, size);
+  let format;
+  let pathOffset;
+  let identity;
+  if (signature === "RSDS") {
+    if (size < 25) {
+      throw new FormatError("RSDS CodeView debug record is truncated", {
+        offset,
+        context: "PE CodeView data"
+      });
+    }
+    const data1 = view.getUint32(4, true).toString(16).padStart(8, "0");
+    const data2 = view.getUint16(8, true).toString(16).padStart(4, "0");
+    const data3 = view.getUint16(10, true).toString(16).padStart(4, "0");
+    const data4 = [...bytes.subarray(offset + 12, offset + 20)]
+      .map((byte) => byte.toString(16).padStart(2, "0"))
+      .join("");
+    identity = {
+      guid: `${data1}-${data2}-${data3}-${data4.slice(0, 4)}-${data4.slice(4)}`,
+      age: view.getUint32(20, true)
+    };
+    format = "RSDS";
+    pathOffset = 24;
+  } else if (signature === "NB10") {
+    if (size < 17) {
+      throw new FormatError("NB10 CodeView debug record is truncated", {
+        offset,
+        context: "PE CodeView data"
+      });
+    }
+    identity = {
+      offset: view.getUint32(4, true),
+      timeDateStamp: view.getUint32(8, true),
+      age: view.getUint32(12, true)
+    };
+    format = "NB10";
+    pathOffset = 16;
+  } else {
+    return { format: "unknown", signature };
+  }
+
+  const pathBytes = bytes.subarray(offset + pathOffset, offset + size);
+  const terminator = pathBytes.indexOf(0);
+  if (terminator < 0 || pathBytes.subarray(terminator + 1).some((byte) => byte !== 0)) {
+    throw new FormatError("CodeView PDB path is not null-terminated or has nonzero trailing data", {
+      offset: offset + pathOffset,
+      context: "PE CodeView data"
+    });
+  }
+  return {
+    format,
+    ...identity,
+    path: new TextDecoder("utf-8", { ignoreBOM: true }).decode(pathBytes.subarray(0, terminator)),
+    pathOffset,
+    pathByteLength: terminator
+  };
+}
+
+function parsePortablePdbStream(metadataRoot) {
+  const stream = metadataRoot.streams.get("#Pdb");
+  if (!stream) throw new FormatError("Embedded Portable PDB is missing its #Pdb stream");
+  if (!metadataRoot.streams.has("#~")) {
+    throw new FormatError("Embedded Portable PDB is missing its #~ tables stream");
+  }
+  const reader = new BinaryReader(stream.bytes, { context: "Portable PDB #Pdb stream" });
+  if (reader.remaining < 32) throw new FormatError("Portable PDB #Pdb stream is truncated");
+  const id = Uint8Array.from(reader.take(20));
+  const entryPointToken = reader.u4();
+  if (entryPointToken !== 0 &&
+      ((entryPointToken >>> 24) !== 6 || (entryPointToken & 0x00ffffff) === 0)) {
+    throw new FormatError("Portable PDB entry point must be a MethodDef token or nil");
+  }
+  const referencedTypeSystemTables = BigInt(reader.u4()) | (BigInt(reader.u4()) << 32n);
+  const rowCounts = new Map();
+  for (let table = 0; table < 64; table++) {
+    if ((referencedTypeSystemTables & (1n << BigInt(table))) !== 0n) {
+      if (table >= 45) {
+        throw new FormatError("Portable PDB #Pdb references a non-type-system metadata table");
+      }
+      rowCounts.set(table, reader.u4());
+    }
+  }
+  if (reader.remaining !== 0) {
+    throw new FormatError("Trailing bytes after Portable PDB #Pdb stream data");
+  }
+  return { id, entryPointToken, referencedTypeSystemTables, rowCounts };
+}
+
+export function parseEmbeddedPortablePdbData(bytes, offset, size) {
+  const reader = new BinaryReader(bytes, {
+    start: offset,
+    length: size,
+    baseOffset: offset,
+    context: "embedded Portable PDB"
+  });
+  if (reader.remaining < 9 || new TextDecoder("ascii").decode(reader.take(4)) !== "MPDB") {
+    throw new FormatError("Embedded Portable PDB has an invalid or truncated MPDB header", {
+      offset,
+      context: "embedded Portable PDB"
+    });
+  }
+  const uncompressedSize = reader.u4();
+  if (uncompressedSize === 0) {
+    throw new FormatError("Embedded Portable PDB declares an empty metadata root", {
+      offset: offset + 4,
+      context: "embedded Portable PDB"
+    });
+  }
+  if (uncompressedSize > maxEmbeddedPortablePdbSize) {
+    throw new UnsupportedFormatError(
+      `Embedded Portable PDB exceeds the ${maxEmbeddedPortablePdbSize}-byte decompression limit`,
+      { offset: offset + 4, context: "embedded Portable PDB" }
+    );
+  }
+  let metadataBytes;
+  try {
+    metadataBytes = inflateRawSync(reader.take(reader.remaining), {
+      maxOutputLength: uncompressedSize
+    });
+  } catch (error) {
+    throw new FormatError(`Embedded Portable PDB deflate stream is invalid: ${error.message}`, {
+      offset: reader.absoluteOffset,
+      context: "embedded Portable PDB"
+    });
+  }
+  if (metadataBytes.length !== uncompressedSize) {
+    throw new FormatError("Embedded Portable PDB decompressed size does not match its header", {
+      offset,
+      context: "embedded Portable PDB"
+    });
+  }
+  const metadataRoot = parseMetadataRoot(metadataBytes, 0, metadataBytes.length);
+  const pdb = parsePortablePdbStream(metadataRoot);
+  const externalCounts = new Array(64).fill(0);
+  for (const [table, count] of pdb.rowCounts) externalCounts[table] = count;
+  const tables = parseTablesStream(metadataRoot.streams.get("#~"), externalCounts);
+  if ((tables.valid & ((1n << 45n) - 1n)) !== 0n) {
+    throw new FormatError("Portable PDB #~ stream contains type-system metadata tables");
+  }
+  const heaps = new MetadataHeaps(metadataRoot.streams);
+  const decoded = parsePortablePdbTables(tables, heaps, externalCounts);
+  return {
+    uncompressedSize,
+    bytes: Uint8Array.from(metadataBytes),
+    metadataRoot,
+    tables,
+    heaps,
+    ...decoded,
+    ...pdb
+  };
+}
+
+export function parsePE(input) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const reader = new BinaryReader(bytes, { context: "PE headers" });
+  requireSignature(reader.u2(), 0x5a4d, 0, "DOS");
+  reader.seek(0x3c);
+  const peOffset = reader.u4();
+  if (peOffset > bytes.length - 24) {
+    throw new FormatError("PE header offset is outside the file", { offset: 0x3c, context: "DOS header" });
+  }
+
+  reader.seek(peOffset);
+  requireSignature(reader.u4(), 0x00004550, peOffset, "PE");
+  const machine = reader.u2();
+  const sectionCount = reader.u2();
+  reader.u4();
+  const symbolTablePointer = reader.u4();
+  const symbolCount = reader.u4();
+  const optionalHeaderSize = reader.u2();
+  const characteristics = reader.u2();
+  const optionalOffset = reader.position;
+  const optional = reader.slice(optionalHeaderSize, "PE optional header");
+  const magic = optional.u2();
+  let directoryCountOffset;
+  let directoryOffset;
+  if (magic === 0x10b) {
+    directoryCountOffset = 92;
+    directoryOffset = 96;
+  } else if (magic === 0x20b) {
+    directoryCountOffset = 108;
+    directoryOffset = 112;
+  } else {
+    throw new UnsupportedFormatError(`Unsupported PE optional-header magic 0x${magic.toString(16)}`, {
+      offset: optionalOffset
+    });
+  }
+  if (optionalHeaderSize < directoryCountOffset + 4) {
+    throw new FormatError("Optional header is too short to contain data directories", { offset: optionalOffset });
+  }
+  optional.seek(directoryCountOffset);
+  const declaredDirectories = optional.u4();
+  const availableDirectories = Math.floor((optionalHeaderSize - directoryOffset) / 8);
+  if (declaredDirectories > availableDirectories) {
+    throw new FormatError("Optional header declares data directories that do not fit in the header", {
+      offset: optionalOffset + directoryCountOffset,
+      context: "PE optional header"
+    });
+  }
+  const directoryCount = declaredDirectories;
+  optional.seek(directoryOffset);
+  const directories = Array.from({ length: directoryCount }, () => ({
+    rva: optional.u4(),
+    size: optional.u4()
+  }));
+  const sectionOffset = optionalOffset + optionalHeaderSize;
+  const sectionsReader = new BinaryReader(bytes, {
+    start: sectionOffset,
+    length: bytes.length - sectionOffset,
+    baseOffset: sectionOffset,
+    context: "PE section table"
+  });
+  const sections = [];
+  for (let i = 0; i < sectionCount; i++) {
+    const nameBytes = sectionsReader.take(8);
+    const nul = nameBytes.indexOf(0);
+    const name = new TextDecoder().decode(nul < 0 ? nameBytes : nameBytes.subarray(0, nul));
+    const virtualSize = sectionsReader.u4();
+    const virtualAddress = sectionsReader.u4();
+    const rawSize = sectionsReader.u4();
+    const rawPointer = sectionsReader.u4();
+    sectionsReader.skip(16);
+    sections.push({ name, virtualSize, virtualAddress, rawSize, rawPointer });
+  }
+  optional.seek(4);
+  const sizeOfCode = optional.u4();
+  const sizeOfInitializedData = optional.u4();
+  optional.seek(32);
+  const sectionAlignment = optional.u4();
+  const fileAlignment = optional.u4();
+  if (!isPowerOfTwo(sectionAlignment) || !isPowerOfTwo(fileAlignment)) {
+    throw new FormatError("PE section and file alignments must be nonzero powers of two", {
+      offset: optionalOffset + 32,
+      context: "PE optional header"
+    });
+  }
+  if ((sectionAlignment < 0x1000 && sectionAlignment !== fileAlignment) ||
+      (sectionAlignment >= 0x1000 && sectionAlignment < fileAlignment)) {
+    throw new FormatError("PE section and file alignments are inconsistent", {
+      offset: optionalOffset + 32,
+      context: "PE optional header"
+    });
+  }
+  if (sectionAlignment >= 0x1000 && (fileAlignment < 0x200 || fileAlignment > 0x10000)) {
+    throw new FormatError("PE file alignment is outside the supported range", {
+      offset: optionalOffset + 36,
+      context: "PE optional header"
+    });
+  }
+  optional.seek(56);
+  const sizeOfImage = optional.u4();
+  const sizeOfHeaders = optional.u4();
+  const checksumOffset = optionalOffset + 64;
+  const sectionTableEnd = sectionOffset + sectionCount * 40;
+  if (sizeOfHeaders < sectionTableEnd || sizeOfHeaders > bytes.length) {
+    throw new FormatError("PE SizeOfHeaders does not cover the PE headers", {
+      offset: optionalOffset + 60,
+      context: "PE optional header"
+    });
+  }
+  if (sizeOfHeaders % fileAlignment !== 0 || sizeOfImage === 0 ||
+      sizeOfImage % sectionAlignment !== 0) {
+    throw new FormatError("PE header and image sizes do not follow the declared alignments", {
+      offset: optionalOffset + 56,
+      context: "PE optional header"
+    });
+  }
+
+  const rawRanges = [];
+  const virtualRanges = [];
+  const firstSectionAddress = Math.ceil(sizeOfHeaders / sectionAlignment) * sectionAlignment;
+  let virtualImageEnd = sizeOfHeaders;
+  for (const section of sections) {
+    if (section.virtualAddress % sectionAlignment !== 0) {
+      throw new FormatError(`Section ${section.name} virtual address is not section-aligned`);
+    }
+    const virtualSize = Math.max(section.virtualSize, section.rawSize);
+    if (virtualSize > 0) {
+      if (section.virtualAddress < firstSectionAddress) {
+        throw new FormatError(`Section ${section.name} virtual range overlaps the PE headers`);
+      }
+      const end = section.virtualAddress + virtualSize;
+      if (end > 0x100000000) {
+        throw new FormatError(`Section ${section.name} virtual range overflows the RVA space`);
+      }
+      virtualImageEnd = Math.max(virtualImageEnd, end);
+      virtualRanges.push({ start: section.virtualAddress, end, name: section.name });
+    }
+    if (section.rawSize > 0) {
+      if (section.rawPointer % fileAlignment !== 0 || section.rawSize % fileAlignment !== 0) {
+        throw new FormatError(`Section ${section.name} raw range is not file-aligned`);
+      }
+      const end = section.rawPointer + section.rawSize;
+      if (section.rawPointer < sizeOfHeaders || end > bytes.length) {
+        throw new FormatError(`Section ${section.name} raw range is outside file data`);
+      }
+      rawRanges.push({ start: section.rawPointer, end, name: section.name });
+    }
+  }
+  const minimumImageSize = Math.ceil(virtualImageEnd / sectionAlignment) * sectionAlignment;
+  if (sizeOfImage < minimumImageSize) {
+    throw new FormatError("PE SizeOfImage does not cover the aligned headers and section ranges", {
+      offset: optionalOffset + 56,
+      context: "PE optional header"
+    });
+  }
+  for (const [ranges, label] of [[rawRanges, "raw"], [virtualRanges, "virtual"]]) {
+    ranges.sort((left, right) => left.start - right.start || left.end - right.end);
+    for (let index = 1; index < ranges.length; index++) {
+      if (ranges[index - 1].end > ranges[index].start) {
+        throw new FormatError(`PE sections ${ranges[index - 1].name} and ${ranges[index].name} have overlapping ${label} ranges`);
+      }
+    }
+  }
+
+  function rvaToOffset(rva, size = 1) {
+    if (!Number.isInteger(rva) || !Number.isInteger(size) || rva < 0 || size < 0) {
+      throw new FormatError("Invalid RVA range", { context: "RVA mapping" });
+    }
+    if (rva === 0 && size === 0) return 0;
+    for (const section of sections) {
+      const span = Math.max(section.virtualSize, section.rawSize);
+      if (rva < section.virtualAddress || rva - section.virtualAddress >= span) continue;
+      const delta = rva - section.virtualAddress;
+      if (delta + size > section.rawSize || section.rawPointer + delta + size > bytes.length) {
+        throw new FormatError("RVA range is not backed by file data", {
+          offset: section.rawPointer + delta,
+          context: `section ${section.name}`
+        });
+      }
+      return section.rawPointer + delta;
+    }
+    if (rva < sectionOffset && rva + size <= bytes.length) return rva;
+    throw new FormatError(`RVA 0x${rva.toString(16)} is not mapped by a PE section`, { context: "RVA mapping" });
+  }
+
+  const debugDirectory = directories[6] ?? { rva: 0, size: 0 };
+  if ((debugDirectory.rva === 0) !== (debugDirectory.size === 0)) {
+    throw new FormatError("PE debug directory must have both an RVA and a size", {
+      context: "PE debug directory"
+    });
+  }
+  const debugDirectoryEntries = [];
+  if (debugDirectory.size > 0) {
+    if (debugDirectory.size % 28 !== 0) {
+      throw new FormatError("Debug directory size is not a multiple of IMAGE_DEBUG_DIRECTORY", {
+        context: "PE debug directory"
+      });
+    }
+    const debugOffset = rvaToOffset(debugDirectory.rva, debugDirectory.size);
+    const debugReader = new BinaryReader(bytes, {
+      start: debugOffset,
+      length: debugDirectory.size,
+      baseOffset: debugOffset,
+      context: "PE debug directory"
+    });
+    while (debugReader.remaining > 0) {
+      const entryOffset = debugReader.position;
+      const characteristics = debugReader.u4();
+      const timeDateStamp = debugReader.u4();
+      const majorVersion = debugReader.u2();
+      const minorVersion = debugReader.u2();
+      const type = debugReader.u4();
+      const sizeOfData = debugReader.u4();
+      const addressOfRawData = debugReader.u4();
+      const pointerToRawData = debugReader.u4();
+      if (sizeOfData > 0) {
+        if (addressOfRawData !== 0) rvaToOffset(addressOfRawData, sizeOfData);
+        if (pointerToRawData !== 0 && pointerToRawData + sizeOfData > bytes.length) {
+          throw new FormatError("Debug data raw range is outside file data", {
+            offset: pointerToRawData,
+            context: "PE debug directory"
+          });
+        }
+        if (addressOfRawData === 0 && pointerToRawData === 0) {
+          throw new FormatError("Debug entry has data size but no data location", {
+            offset: entryOffset,
+            context: "PE debug directory"
+          });
+        }
+      }
+      const debugDataOffset = pointerToRawData !== 0
+        ? pointerToRawData
+        : sizeOfData > 0
+          ? rvaToOffset(addressOfRawData, sizeOfData)
+          : 0;
+      const codeView = type === 2 && sizeOfData > 0
+        ? parseCodeViewData(bytes, debugDataOffset, sizeOfData)
+        : null;
+      const embeddedPortablePdb = type === 17 && sizeOfData > 0
+        ? parseEmbeddedPortablePdbData(bytes, debugDataOffset, sizeOfData)
+        : null;
+      debugDirectoryEntries.push({
+        characteristics,
+        timeDateStamp,
+        majorVersion,
+        minorVersion,
+        type,
+        sizeOfData,
+        addressOfRawData,
+        pointerToRawData,
+        codeView,
+        embeddedPortablePdb
+      });
+    }
+  }
+
+  return {
+    bytes,
+    peOffset,
+    machine,
+    sectionCount,
+    symbolTablePointer,
+    symbolCount,
+    characteristics,
+    optionalHeaderOffset: optionalOffset,
+    optionalHeaderSize,
+    optionalHeaderMagic: magic,
+    sectionOffset,
+    sizeOfCode,
+    sizeOfInitializedData,
+    sectionAlignment,
+    fileAlignment,
+    sizeOfImage,
+    sizeOfHeaders,
+    checksumOffset,
+    directories,
+    debugDirectoryEntries,
+    sections,
+    rvaToOffset
+  };
+}
+
+export function parseCliHeader(pe) {
+  const directory = pe.directories[14];
+  if (!directory || directory.rva === 0 || directory.size < 72) {
+    throw new FormatError("PE does not contain a complete CLI data directory", { context: "CLI header" });
+  }
+  const offset = pe.rvaToOffset(directory.rva, Math.min(directory.size, 72));
+  const reader = new BinaryReader(pe.bytes, { start: offset, length: 72, baseOffset: offset, context: "CLI header" });
+  const headerSize = reader.u4();
+  if (headerSize < 72) throw new FormatError("CLI header is smaller than 72 bytes", { offset, context: "CLI header" });
+  if (headerSize > directory.size) throw new FormatError("CLI header exceeds its data directory", { offset, context: "CLI header" });
+  const majorRuntimeVersion = reader.u2();
+  const minorRuntimeVersion = reader.u2();
+  const metadataRva = reader.u4();
+  const metadataSize = reader.u4();
+  const flags = reader.u4();
+  const entryPointToken = reader.u4();
+  const resources = { rva: reader.u4(), size: reader.u4() };
+  const strongNameSignature = { rva: reader.u4(), size: reader.u4() };
+  return {
+    offset,
+    headerSize,
+    majorRuntimeVersion,
+    minorRuntimeVersion,
+    metadataRva,
+    metadataSize,
+    flags,
+    entryPointToken,
+    resources,
+    strongNameSignature,
+    strongNameFlagOffset: offset + 16,
+    strongNameDirectoryOffset: offset + 32
+  };
+}

package/src/platform/bytes.js

@@ -0,0 +1,21 @@
+export function bytesToBinaryString(bytes) {
+  const chunks = [];
+  const chunkSize = 0x8000;
+  for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+    chunks.push(String.fromCharCode(...bytes.subarray(offset, offset + chunkSize)));
+  }
+  return chunks.join("");
+}
+
+export function binaryStringToBytes(value) {
+  const bytes = new Uint8Array(value.length);
+  for (let index = 0; index < value.length; index++) bytes[index] = value.charCodeAt(index);
+  return bytes;
+}
+
+export function equalBytes(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index++) difference |= left[index] ^ right[index];
+  return difference === 0;
+}

package/src/platform/compression.js

@@ -0,0 +1,24 @@
+import { deflateSync, inflateSync } from "fflate";
+
+export function deflateRawSync(bytes) {
+  return deflateSync(bytes);
+}
+
+export function inflateRawSync(bytes, options = {}) {
+  const { maxOutputLength } = options;
+  if (maxOutputLength === undefined) return inflateSync(bytes);
+  if (!Number.isSafeInteger(maxOutputLength) || maxOutputLength < 0 ||
+      maxOutputLength === Number.MAX_SAFE_INTEGER) {
+    throw new RangeError("maxOutputLength must be a nonnegative safe integer");
+  }
+  const maximum = maxOutputLength + 1;
+  let capacity = Math.min(maximum, 0x10000);
+  while (true) {
+    const output = inflateSync(bytes, { out: new Uint8Array(capacity) });
+    if (output.length < capacity) return output;
+    if (capacity === maximum) {
+      throw new RangeError(`Decompressed data exceeds ${maxOutputLength} bytes`);
+    }
+    capacity = Math.min(maximum, capacity * 2);
+  }
+}

package/src/platform/crypto.js

@@ -0,0 +1,17 @@
+import forge from "node-forge";
+import { binaryStringToBytes, bytesToBinaryString } from "./bytes.js";
+
+export function createHash(name) {
+  const factory = forge.md[name];
+  if (!factory) throw new RangeError(`Unsupported hash algorithm ${name}`);
+  const digest = factory.create();
+  return {
+    update(bytes) {
+      digest.update(bytesToBinaryString(bytes));
+      return this;
+    },
+    digest() {
+      return binaryStringToBytes(digest.digest().getBytes());
+    }
+  };
+}

package/src/resolution/module.js

@@ -0,0 +1,64 @@
+import { FormatError } from "../binary/errors.js";
+
+function listRids(tables, startRef, endRef, table, pointerTable) {
+  const start = startRef?.rid ?? 0;
+  const indexTable = startRef?.table === pointerTable ? pointerTable : table;
+  const end = endRef?.rid ?? tables.counts[indexTable] + 1;
+  if (start <= 0 || end < start) return [];
+  if (startRef?.table === pointerTable) {
+    const pointerRows = tables.get(pointerTable);
+    return pointerRows.slice(start - 1, end - 1).map((row) => row[table === 4 ? "Field" :
+      table === 6 ? "Method" : table === 8 ? "Param" : table === 20 ? "Event" : "Property"].rid);
+  }
+  return Array.from({ length: end - start }, (_, index) => start + index);
+}
+
+export function resolveTypes(metadata, heaps) {
+  const typeDefs = metadata.get("TypeDef");
+  const types = [];
+  for (let index = 0; index < typeDefs.length; index++) {
+    const row = typeDefs[index];
+    const next = typeDefs[index + 1];
+    types.push({
+      rid: row.rid,
+      flags: row.Flags,
+      name: heaps.getString(row.TypeName),
+      namespace: heaps.getString(row.TypeNamespace),
+      extends: row.Extends.target,
+      fieldRids: listRids(metadata, row.FieldList, next?.FieldList, 4, 3),
+      methodRids: listRids(metadata, row.MethodList, next?.MethodList, 6, 5),
+      eventRids: [],
+      propertyRids: []
+    });
+  }
+  const eventMaps = metadata.get("EventMap");
+  const eventOwners = new Set();
+  for (let index = 0; index < eventMaps.length; index++) {
+    const row = eventMaps[index];
+    const next = eventMaps[index + 1];
+    const type = types[row.Parent.rid - 1];
+    if (!type) throw new FormatError(`EventMap row ${row.rid} references a missing TypeDef`);
+    if (eventOwners.has(type.rid)) throw new FormatError(`TypeDef row ${type.rid} has multiple EventMap rows`);
+    eventOwners.add(type.rid);
+    type.eventRids = listRids(metadata, row.EventList, next?.EventList, 20, 19);
+  }
+  const propertyMaps = metadata.get("PropertyMap");
+  const propertyOwners = new Set();
+  for (let index = 0; index < propertyMaps.length; index++) {
+    const row = propertyMaps[index];
+    const next = propertyMaps[index + 1];
+    const type = types[row.Parent.rid - 1];
+    if (!type) throw new FormatError(`PropertyMap row ${row.rid} references a missing TypeDef`);
+    if (propertyOwners.has(type.rid)) throw new FormatError(`TypeDef row ${type.rid} has multiple PropertyMap rows`);
+    propertyOwners.add(type.rid);
+    type.propertyRids = listRids(metadata, row.PropertyList, next?.PropertyList, 23, 22);
+  }
+  return types;
+}
+
+export function resolveMethodParameters(metadata) {
+  const methods = metadata.get("MethodDef");
+  return methods.map((row, index) =>
+    listRids(metadata, row.ParamList, methods[index + 1]?.ParamList, 8, 7)
+  );
+}

package/src/types/assembly/instruction-editing.d.ts

@@ -0,0 +1,33 @@
+export function createInstructionEditor(assembly: any, hooks: any): {
+    setInstructionOperand(methodRid: any, instructionOffset: any, value: any): any;
+    setInstructionOpcode(methodRid: any, instructionOffset: any, opcodeNameOrCode: any): any;
+    insertInstruction(methodRid: any, beforeOffset: any, opcodeNameOrCode: any, operand: any): {
+        opcode: any;
+        operand: {
+            kind: string;
+            targetOffset: any;
+            targetOffsets?: undefined;
+            value?: undefined;
+        } | {
+            kind: string;
+            targetOffsets: any[];
+            targetOffset?: undefined;
+            value?: undefined;
+        } | {
+            kind: any;
+            value: any;
+            targetOffset?: undefined;
+            targetOffsets?: undefined;
+        };
+        offset: number;
+        size: any;
+        opcodeSize: number;
+        opcodeOffset: any;
+        operandOffset: any;
+        patchOffsets: any[];
+        originalOffset: any;
+        isNew: boolean;
+    };
+    removeInstruction(methodRid: any, instructionOffset: any): any;
+    setMethodMaxStack(methodRid: any, maxStack: any): any;
+};

package/src/types/assembly/method-removal.d.ts

@@ -0,0 +1,3 @@
+export function createMethodRemovalEditor(hooks: any): {
+    removeMethod(rid: any): Map<any, any>;
+};

package/src/types/assembly/pointer-table-editing.d.ts

@@ -0,0 +1,3 @@
+export function createPointerTableEditor(hooks: any): {
+    reorderPointerTable(pointerTable: any, targetRids: any): /*elided*/ any;
+};

package/src/types/assembly/portable-pdb-editing.d.ts

@@ -0,0 +1,23 @@
+export function createPortablePdbEditor(hooks: any): {
+    addEmbeddedPortablePdbDocument(debugEntryIndex: any, name: any, options: any): any;
+    insertEmbeddedPortablePdbDocument(debugEntryIndex: any, options: any): any;
+    addEmbeddedPortablePdbTypeDefinitionDocuments(debugEntryIndex: any, typeRid: any, documentRids: any): any;
+    removeEmbeddedPortablePdbDocument(debugEntryIndex: any, documentRid: any): any;
+    replaceEmbeddedPortablePdbTypeDefinitionDocuments(debugEntryIndex: any, typeRid: any, documentRids: any): any;
+    replaceEmbeddedPortablePdbDocumentMetadata(debugEntryIndex: any, documentRid: any, options: any): any;
+    replaceEmbeddedPortablePdbDocumentName(debugEntryIndex: any, documentRid: any, name: any, separator: any): any;
+    replaceEmbeddedPortablePdbSequencePoints(debugEntryIndex: any, methodRid: any, sequencePoints: any): any;
+    replaceEmbeddedPortablePdbMethodDocument(debugEntryIndex: any, methodRid: any, documentRid: any): any;
+    replaceEmbeddedPortablePdbImportScope(debugEntryIndex: any, importScopeRid: any, options: any): any;
+    replaceEmbeddedPortablePdbLocalScope(debugEntryIndex: any, localScopeRid: any, options: any): any;
+    replaceEmbeddedPortablePdbLocalVariable(debugEntryIndex: any, localVariableRid: any, options: any): any;
+    replaceEmbeddedPortablePdbLocalConstant(debugEntryIndex: any, localConstantRid: any, options: any): any;
+    replaceEmbeddedPortablePdbCustomDebugInformation(debugEntryIndex: any, customDebugInformationRid: any, value: any): any;
+    replaceEmbeddedPortablePdbSource(debugEntryIndex: any, documentRid: any, source: any, options: any): any;
+    addEmbeddedPortablePdbSource(debugEntryIndex: any, documentRid: any, source: any, options: any): any;
+    removeEmbeddedPortablePdbSource(debugEntryIndex: any, documentRid: any): any;
+    removeEmbeddedPortablePdbCustomDebugInformation(debugEntryIndex: any, recordRid: any): any;
+    replaceEmbeddedPortablePdbSourceLink(debugEntryIndex: any, sourceLink: any): any;
+    removeEmbeddedPortablePdbSourceLink(debugEntryIndex: any): any;
+    addEmbeddedPortablePdbSourceLink(debugEntryIndex: any, sourceLink: any): any;
+};