jsilnet 0.1.0 → 0.2.0

package/src/index.js

@@ -1,4 +1,5 @@
-import { createHash } from "node:crypto";
+import { createHash } from "./platform/crypto.js";
+import { equalBytes } from "./platform/bytes.js";
 import { FormatError, UnsupportedFormatError } from "./binary/errors.js";
 import {
   parseEmbeddedPortablePdbData,
@@ -31,17 +32,14 @@ import {
 } from "./metadata/classic-pdb.js";
 import { parseMethodBody } from "./il/body.js";
 import { encodeInstruction, encodeOpcode, formatInstruction, getInstructionSize } from "./il/instructions.js";
-import { listOpcodes } from "./il/opcodes.js";
-import {
-  createStructuralState,
-  insertInstruction as insertStructuralInstruction,
-  layoutStructuralState,
-  removeInstruction as removeStructuralInstruction,
-  updateStructuralOperand
-} from "./il/rewrite.js";
+import { createStructuralState } from "./il/rewrite.js";
 import { resolveMethodParameters, resolveTypes } from "./resolution/module.js";
 import { applyPatches, createOperandPatches } from "./writer/patch.js";
 import { serializeStructural } from "./writer/structural.js";
+import { createInstructionEditor } from "./assembly/instruction-editing.js";
+import { createPointerTableEditor } from "./assembly/pointer-table-editing.js";
+import { createPortablePdbEditor } from "./assembly/portable-pdb-editing.js";
+import { createMethodRemovalEditor } from "./assembly/method-removal.js";
 import { appendBlobHeap, appendStringHeap, appendUserStringHeap } from "./metadata/writer.js";
 import { parseManifestResources } from "./metadata/resources.js";
 import {
@@ -53,28 +51,7 @@ import {
   remapEmbeddedPortablePdbTypeDefinitions as remapPortablePdbTypeDefinitions,
   removeEmbeddedPortablePdbMethod as removePortablePdbMethod,
   refreshEmbeddedPortablePdbId,
-  addEmbeddedPortablePdbSourceLink as addPortablePdbSourceLink,
-  addEmbeddedPortablePdbSource as addPortablePdbSource,
-  removeEmbeddedPortablePdbSourceLink as removePortablePdbSourceLink,
-  removeEmbeddedPortablePdbSource as removePortablePdbSource,
-  removeEmbeddedPortablePdbCustomDebugInformation as removePortablePdbCustomDebugInformation,
-  replaceEmbeddedPortablePdbMethodOffsets as replacePortablePdbMethodOffsets,
-  addEmbeddedPortablePdbDocument as addPortablePdbDocument,
-  insertEmbeddedPortablePdbDocument as insertPortablePdbDocument,
-  addEmbeddedPortablePdbTypeDefinitionDocuments as addPortablePdbTypeDefinitionDocuments,
-  removeEmbeddedPortablePdbDocument as removePortablePdbDocument,
-  replaceEmbeddedPortablePdbDocumentMetadata as replacePortablePdbDocumentMetadata,
-  replaceEmbeddedPortablePdbTypeDefinitionDocuments as replacePortablePdbTypeDefinitionDocuments,
-  replaceEmbeddedPortablePdbDocumentName as replacePortablePdbDocumentName,
-  replaceEmbeddedPortablePdbLocalScope as replacePortablePdbLocalScope,
-  replaceEmbeddedPortablePdbLocalVariable as replacePortablePdbLocalVariable,
-  replaceEmbeddedPortablePdbLocalConstant as replacePortablePdbLocalConstant,
-  replaceEmbeddedPortablePdbCustomDebugInformation as replacePortablePdbCustomDebugInformation,
-  replaceEmbeddedPortablePdbMethodDocument as replacePortablePdbMethodDocument,
-  replaceEmbeddedPortablePdbImportScope as replacePortablePdbImportScope,
-  replaceEmbeddedPortablePdbSequencePoints as replacePortablePdbSequencePoints,
-  replaceEmbeddedPortablePdbSource as replacePortablePdbSource,
-  replaceEmbeddedPortablePdbSourceLink as replacePortablePdbSourceLink
+  replaceEmbeddedPortablePdbMethodOffsets as replacePortablePdbMethodOffsets
 } from "./metadata/portable-pdb.js";
 import {
   assertStrongNamePEProfile,
@@ -1999,6 +1976,33 @@ export class Assembly {
   #strongNameSignatureSize = 0;
   #hasAuthenticodeCertificate;
   #hasDebugDirectory;
+  #instructionEditor = createInstructionEditor(this, {
+    ensureEditable: () => this.#ensureEditable(),
+    validateBranchTarget: (body, target) => this.#validateBranchTarget(body, target),
+    createStructuralState: (methodRid) => this.#createStructuralState(methodRid),
+    commitStructuralState: (methodRid, state) => this.#commitStructuralState(methodRid, state),
+    allowedTokenTables,
+    validateInstructionGenericContext
+  });
+  #pointerTableEditor = createPointerTableEditor({
+    ensureEditable: () => this.#ensureEditable(),
+    getBijectivePointerRows,
+    validateGenericVariableReferences,
+    getGenericParameterArity,
+    validateTypeSpecDefinitions,
+    validateTypeSpecGenericContext
+  });
+  #portablePdbEditor = createPortablePdbEditor({
+    ensureEditable: () => this.#ensureEditable(),
+    getPortablePdbForEdit: (...args) => this.#getPortablePdbForEdit(...args)
+  });
+  #methodRemovalEditor = createMethodRemovalEditor({
+    ensureEditable: () => this.#ensureEditable(),
+    ensureTokenRemappingSafe: (...args) => this.#ensureTokenRemappingSafe(...args),
+    getPortablePdbForEdit: (...args) => this.#getPortablePdbForEdit(...args),
+    replaceEmbeddedPortablePdb: (...args) => this.#replaceEmbeddedPortablePdb(...args),
+    getBijectivePointerRows
+  });
 
   constructor(input) {
     this.#bytes = input instanceof Uint8Array ? Uint8Array.from(input) : new Uint8Array(input);
@@ -4038,416 +4042,88 @@ export class Assembly {
     );
   }
 
-  addEmbeddedPortablePdbDocument(debugEntryIndex, name, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = addPortablePdbDocument(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      name,
-      options
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    addEmbeddedPortablePdbDocument(debugEntryIndex, name, options) {
+    return this.#portablePdbEditor.addEmbeddedPortablePdbDocument.call(this, debugEntryIndex, name, options);
   }
 
-  insertEmbeddedPortablePdbDocument(debugEntryIndex, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = insertPortablePdbDocument(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      options
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    insertEmbeddedPortablePdbDocument(debugEntryIndex, options) {
+    return this.#portablePdbEditor.insertEmbeddedPortablePdbDocument.call(this, debugEntryIndex, options);
   }
 
-  addEmbeddedPortablePdbTypeDefinitionDocuments(
-    debugEntryIndex,
-    typeRid,
-    documentRids
-  ) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = addPortablePdbTypeDefinitionDocuments(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      typeRid,
-      documentRids
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    addEmbeddedPortablePdbTypeDefinitionDocuments(debugEntryIndex, typeRid, documentRids) {
+    return this.#portablePdbEditor.addEmbeddedPortablePdbTypeDefinitionDocuments.call(this, debugEntryIndex, typeRid, documentRids);
   }
 
-  removeEmbeddedPortablePdbDocument(debugEntryIndex, documentRid) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = removePortablePdbDocument(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      documentRid
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    removeEmbeddedPortablePdbDocument(debugEntryIndex, documentRid) {
+    return this.#portablePdbEditor.removeEmbeddedPortablePdbDocument.call(this, debugEntryIndex, documentRid);
   }
 
-  replaceEmbeddedPortablePdbTypeDefinitionDocuments(
-    debugEntryIndex,
-    typeRid,
-    documentRids
-  ) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbTypeDefinitionDocuments(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      typeRid,
-      documentRids
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbTypeDefinitionDocuments(debugEntryIndex, typeRid, documentRids) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbTypeDefinitionDocuments.call(this, debugEntryIndex, typeRid, documentRids);
   }
 
-  replaceEmbeddedPortablePdbDocumentMetadata(debugEntryIndex, documentRid, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbDocumentMetadata(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      documentRid,
-      options
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbDocumentMetadata(debugEntryIndex, documentRid, options) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbDocumentMetadata.call(this, debugEntryIndex, documentRid, options);
   }
 
-  replaceEmbeddedPortablePdbDocumentName(debugEntryIndex, documentRid, name, separator) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbDocumentName(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      documentRid,
-      name,
-      separator
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbDocumentName(debugEntryIndex, documentRid, name, separator) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbDocumentName.call(this, debugEntryIndex, documentRid, name, separator);
   }
 
-  replaceEmbeddedPortablePdbSequencePoints(debugEntryIndex, methodRid, sequencePoints) {
-    this.#ensureEditable();
-    if (this._portablePdbOffsetBaselines.has(methodRid)) {
-      throw new UnsupportedFormatError(
-        "Portable PDB sequence points cannot be replaced after IL offset remapping has been staged"
-      );
-    }
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbSequencePoints(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      methodRid,
-      sequencePoints
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbSequencePoints(debugEntryIndex, methodRid, sequencePoints) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbSequencePoints.call(this, debugEntryIndex, methodRid, sequencePoints);
   }
 
-  replaceEmbeddedPortablePdbMethodDocument(debugEntryIndex, methodRid, documentRid) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbMethodDocument(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      methodRid,
-      documentRid
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbMethodDocument(debugEntryIndex, methodRid, documentRid) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbMethodDocument.call(this, debugEntryIndex, methodRid, documentRid);
   }
 
-  replaceEmbeddedPortablePdbImportScope(debugEntryIndex, importScopeRid, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbImportScope(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      importScopeRid,
-      options
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbImportScope(debugEntryIndex, importScopeRid, options) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbImportScope.call(this, debugEntryIndex, importScopeRid, options);
   }
 
-  replaceEmbeddedPortablePdbLocalScope(debugEntryIndex, localScopeRid, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const pdb = this.#getPortablePdbForEdit(debugEntryIndex, entry);
-    const localScope = pdb.tables.rows.get(50)?.[localScopeRid - 1];
-    if (!localScope || localScope.rid !== localScopeRid) {
-      throw new RangeError(`Invalid Portable PDB LocalScope row ID ${localScopeRid}`);
-    }
-    if (this._portablePdbOffsetBaselines.has(localScope.Method.rid)) {
-      throw new UnsupportedFormatError(
-        "Portable PDB LocalScope offsets cannot be replaced after IL offset remapping has been staged"
-      );
-    }
-    const data = replacePortablePdbLocalScope(pdb, localScopeRid, options);
-    const updatedPdb = parseEmbeddedPortablePdbData(data, 0, data.length);
-    const updatedScope = updatedPdb.tables.rows.get(50)?.[localScopeRid - 1];
-    const body = this.getMethodBody(localScope.Method.rid);
-    if (!updatedScope || !body) {
-      throw new FormatError(
-        `Portable PDB LocalScope row ${localScopeRid} does not resolve to a method body`
-      );
-    }
-    const isBoundary = (offset) => offset === body.codeSize ||
-      body.instructions.some((instruction) => instruction.offset === offset);
-    const endOffset = updatedScope.StartOffset + updatedScope.Length;
-    if (!isBoundary(updatedScope.StartOffset) || !isBoundary(endOffset)) {
-      throw new FormatError(
-        `Portable PDB LocalScope row ${localScopeRid} does not align with MethodDef ${localScope.Method.rid} instruction boundaries`
-      );
-    }
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbLocalScope(debugEntryIndex, localScopeRid, options) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbLocalScope.call(this, debugEntryIndex, localScopeRid, options);
   }
 
-  replaceEmbeddedPortablePdbLocalVariable(debugEntryIndex, localVariableRid, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbLocalVariable(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      localVariableRid,
-      options
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbLocalVariable(debugEntryIndex, localVariableRid, options) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbLocalVariable.call(this, debugEntryIndex, localVariableRid, options);
   }
 
-  replaceEmbeddedPortablePdbLocalConstant(debugEntryIndex, localConstantRid, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbLocalConstant(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      localConstantRid,
-      options
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbLocalConstant(debugEntryIndex, localConstantRid, options) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbLocalConstant.call(this, debugEntryIndex, localConstantRid, options);
   }
 
-  replaceEmbeddedPortablePdbCustomDebugInformation(
-    debugEntryIndex,
-    customDebugInformationRid,
-    value
-  ) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbCustomDebugInformation(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      customDebugInformationRid,
-      value
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbCustomDebugInformation(debugEntryIndex, customDebugInformationRid, value) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbCustomDebugInformation.call(this, debugEntryIndex, customDebugInformationRid, value);
   }
 
-  replaceEmbeddedPortablePdbSource(debugEntryIndex, documentRid, source, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbSource(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      documentRid,
-      source,
-      options
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbSource(debugEntryIndex, documentRid, source, options) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbSource.call(this, debugEntryIndex, documentRid, source, options);
   }
 
-  addEmbeddedPortablePdbSource(debugEntryIndex, documentRid, source, options) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = addPortablePdbSource(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      documentRid,
-      source,
-      options
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    addEmbeddedPortablePdbSource(debugEntryIndex, documentRid, source, options) {
+    return this.#portablePdbEditor.addEmbeddedPortablePdbSource.call(this, debugEntryIndex, documentRid, source, options);
   }
 
-  removeEmbeddedPortablePdbSource(debugEntryIndex, documentRid) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = removePortablePdbSource(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      documentRid
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    removeEmbeddedPortablePdbSource(debugEntryIndex, documentRid) {
+    return this.#portablePdbEditor.removeEmbeddedPortablePdbSource.call(this, debugEntryIndex, documentRid);
   }
 
-  removeEmbeddedPortablePdbCustomDebugInformation(debugEntryIndex, recordRid) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = removePortablePdbCustomDebugInformation(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      recordRid
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    removeEmbeddedPortablePdbCustomDebugInformation(debugEntryIndex, recordRid) {
+    return this.#portablePdbEditor.removeEmbeddedPortablePdbCustomDebugInformation.call(this, debugEntryIndex, recordRid);
   }
 
-  replaceEmbeddedPortablePdbSourceLink(debugEntryIndex, sourceLink) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = replacePortablePdbSourceLink(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      sourceLink
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    replaceEmbeddedPortablePdbSourceLink(debugEntryIndex, sourceLink) {
+    return this.#portablePdbEditor.replaceEmbeddedPortablePdbSourceLink.call(this, debugEntryIndex, sourceLink);
   }
 
-  removeEmbeddedPortablePdbSourceLink(debugEntryIndex) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = removePortablePdbSourceLink(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry)
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    removeEmbeddedPortablePdbSourceLink(debugEntryIndex) {
+    return this.#portablePdbEditor.removeEmbeddedPortablePdbSourceLink.call(this, debugEntryIndex);
   }
 
-  addEmbeddedPortablePdbSourceLink(debugEntryIndex, sourceLink) {
-    this.#ensureEditable();
-    if (!Number.isInteger(debugEntryIndex) || debugEntryIndex < 0 ||
-        debugEntryIndex >= this.pe.debugDirectoryEntries.length) {
-      throw new RangeError(`Invalid debug-directory entry index ${debugEntryIndex}`);
-    }
-    const entry = this.pe.debugDirectoryEntries[debugEntryIndex];
-    if (entry.type !== 17 || !entry.embeddedPortablePdb) {
-      throw new UnsupportedFormatError("Debug-directory entry is not an embedded Portable PDB");
-    }
-    const data = addPortablePdbSourceLink(
-      this.#getPortablePdbForEdit(debugEntryIndex, entry),
-      sourceLink
-    );
-    return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    addEmbeddedPortablePdbSourceLink(debugEntryIndex, sourceLink) {
+    return this.#portablePdbEditor.addEmbeddedPortablePdbSourceLink.call(this, debugEntryIndex, sourceLink);
   }
 
   replaceFieldSignature(rid, signature) {
@@ -6141,801 +5817,26 @@ export class Assembly {
   }
 
   removeMethod(rid) {
+    return this.#methodRemovalEditor.removeMethod.call(this, rid);
+  }
+
+  addParam({ owner, name = "", sequence, flags = 0 }) {
+    return this.#writeParam({ owner, name, sequence, flags }, false).rid;
+  }
+
+  insertParam({ owner, name = "", sequence, flags = 0 }) {
+    return this.#writeParam({ owner, name, sequence, flags }, true);
+  }
+
+  #writeParam({ owner, name = "", sequence, flags = 0 }, insertIntoOwner) {
     this.#ensureEditable();
-    if (this._structuralBodies.size > 0) {
-      throw new UnsupportedFormatError("Method removal cannot be combined with structural method edits");
+    const ownerRid = metadataTableId(owner?.table) === 6 ? owner.rid : 0;
+    const method = this.methods[ownerRid - 1];
+    if (!Number.isInteger(ownerRid) || ownerRid < 1 || !method) {
+      throw new RangeError("Param owner must identify an existing MethodDef");
     }
-    const embeddedPdbIndices = this.pe.debugDirectoryEntries.flatMap((entry, index) =>
-      entry.embeddedPortablePdb ? [index] : []
-    );
-    this.#ensureTokenRemappingSafe("MethodDef", {
-      allowEmbeddedPortablePdb: embeddedPdbIndices.length === 1
-    });
-    const rows = this.tables.rows.get(6) ?? [];
-    if (rows.length !== this.tables.counts[6] || rows.length !== this.methods.length) {
-      throw new FormatError("MethodDef row count is inconsistent with the metadata table header");
-    }
-    if (!Number.isInteger(rid) || rid < 1 || rid > rows.length) {
-      throw new RangeError(`Invalid MethodDef row ID ${rid}`);
-    }
-    const cliEntryPointToken = this._cliEntryPointToken ?? this.cli.entryPointToken;
-    const isManagedMethodEntryPoint =
-      (this.cli.flags & 0x10) === 0 &&
-      (cliEntryPointToken >>> 24) === 6;
-    const cliEntryPointRid = cliEntryPointToken & 0x00ffffff;
-    if (isManagedMethodEntryPoint &&
-        (cliEntryPointRid === 0 || cliEntryPointRid > rows.length)) {
-      throw new FormatError("CLI entry point references a missing MethodDef");
-    }
-    if (isManagedMethodEntryPoint && cliEntryPointRid === rid) {
-      throw new FormatError(`MethodDef row ${rid} is the CLI entry point`);
-    }
-    const remappedCliEntryPointToken = isManagedMethodEntryPoint &&
-      cliEntryPointRid > rid
-      ? cliEntryPointToken - 1
-      : cliEntryPointToken;
-    const shiftsMethodRids = rid < rows.length;
-    if (shiftsMethodRids && this._addedMethodBodies.size > 0) {
-      throw new UnsupportedFormatError(
-        "MethodDef RID remapping cannot be combined with added method bodies"
-      );
-    }
-    const method = this.methods[rid - 1];
-    if (method?.rid !== rid) throw new FormatError(`MethodDef row ${rid} has inconsistent semantic records`);
-    const genericParamRows = this.tables.rows.get(42) ?? [];
-    if (genericParamRows.length !== (this.tables.counts[42] ?? 0)) {
-      throw new FormatError("GenericParam row count is inconsistent with the metadata table header");
-    }
-    const genericParamRids = new Set(method.genericParams.map((parameter) => parameter.rid));
-    if (genericParamRids.size !== method.genericParams.length ||
-        method.genericParams.length !== this.genericParams.filter(
-          (parameter) => parameter.owner.table === 6 && parameter.owner.rid === rid
-        ).length) {
-      throw new FormatError(`MethodDef row ${rid} has inconsistent GenericParam ownership`);
-    }
-    if (genericParamRids.size > 0) {
-      const sortedGenericParamRids = [...genericParamRids].sort((a, b) => a - b);
-      const firstGenericParamRid = sortedGenericParamRids[0];
-      if (firstGenericParamRid < 1 ||
-          sortedGenericParamRids.some((parameterRid, index) =>
-            parameterRid !== firstGenericParamRid + index
-          ) || sortedGenericParamRids.at(-1) > genericParamRows.length) {
-        throw new UnsupportedFormatError(
-          "MethodDef removal requires its GenericParam rows to form a contiguous table range"
-        );
-      }
-    }
-    const genericParamConstraintRows = this.tables.rows.get(44) ?? [];
-    if (genericParamConstraintRows.length !== (this.tables.counts[44] ?? 0) ||
-        genericParamConstraintRows.length !== this.genericParamConstraints.length) {
-      throw new FormatError("GenericParamConstraint row count is inconsistent with the metadata table header");
-    }
-    const genericParamConstraintRids = new Set(
-      this.genericParamConstraints
-        .filter((constraint) => genericParamRids.has(constraint.ownerRid))
-        .map((constraint) => constraint.rid)
-    );
-    if (genericParamConstraintRids.size > 0) {
-      for (const [tableId, tableRows] of this.tables.rows) {
-        const schema = metadataTableSchemas[tableId];
-        if (!schema) {
-          throw new UnsupportedFormatError(
-            `Cannot remove MethodDef row ${rid} with unknown metadata table ${tableId}`
-          );
-        }
-        for (const row of tableRows) {
-          if (tableId === 44 && genericParamConstraintRids.has(row.rid)) continue;
-          for (const [kind, value, name] of schema) {
-            const columnName = name ?? value;
-            const column = row[columnName];
-            const target = kind === "coded"
-              ? column?.target
-              : kind === "table" ? { table: value, rid: column?.rid } : null;
-            if (target?.table === 44 && genericParamConstraintRids.has(target.rid)) {
-              throw new FormatError(
-                `GenericParamConstraint row ${target.rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-              );
-            }
-            if (kind === "u4" && (tableId === 30 || tableId === 31) &&
-                columnName === "Token" && row[columnName] >>> 24 === 44 &&
-                genericParamConstraintRids.has(row[columnName] & 0x00ffffff)) {
-              throw new FormatError(
-                `GenericParamConstraint row ${row[columnName] & 0x00ffffff} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-              );
-            }
-          }
-        }
-      }
-      for (const candidate of this.methods) {
-        for (const instruction of this.getMethodBody(candidate.rid)?.instructions ?? []) {
-          const token = instruction.operand?.kind === "token" ? instruction.operand.value : 0;
-          if ((token >>> 24) === 44 && genericParamConstraintRids.has(token & 0x00ffffff)) {
-            throw new FormatError(
-              `GenericParamConstraint row ${token & 0x00ffffff} is referenced by CIL in MethodDef row ${candidate.rid}`
-            );
-          }
-        }
-      }
-    }
-    const parameterRows = this.tables.rows.get(8) ?? [];
-    if (parameterRows.length !== (this.tables.counts[8] ?? 0)) {
-      throw new FormatError("Param row count is inconsistent with the metadata table header");
-    }
-    const parameterRids = new Set(method.parameterRids);
-    if (method.parameterRids.length !== method.parameters.length ||
-        parameterRids.size !== method.parameterRids.length) {
-      throw new FormatError(`MethodDef row ${rid} has inconsistent Param ownership`);
-    }
-    if (parameterRids.size > 0) {
-      const sortedParameterRids = [...parameterRids].sort((a, b) => a - b);
-      const firstParameterRid = sortedParameterRids[0];
-      if (firstParameterRid < 1 ||
-          sortedParameterRids.some((parameterRid, index) => parameterRid !== firstParameterRid + index) ||
-          sortedParameterRids.at(-1) > parameterRows.length) {
-        throw new UnsupportedFormatError(
-          "MethodDef removal requires its Param rows to form a contiguous table range"
-        );
-      }
-    }
-    const owners = this.types.filter((type) => type.methodRids.includes(rid));
-    if (owners.length !== 1 || !owners[0].methods.some((candidate) => candidate.rid === rid)) {
-      throw new FormatError(`MethodDef row ${rid} has no unique resolved TypeDef owner`);
-    }
-    const supportedStreams = new Set(["#~", "#-", "#Strings", "#US", "#GUID", "#Blob"]);
-    for (const streamName of this.metadataRoot.streams.keys()) {
-      if (!supportedStreams.has(streamName)) {
-        throw new UnsupportedFormatError(
-          `Cannot remove MethodDef row ${rid} with unrecognized metadata stream ${streamName}`
-        );
-      }
-    }
-
-    const paramPointerRows = parameterRids.size > 0
-      ? getBijectivePointerRows(this, 7, 8, "Param")
-      : null;
-    if (parameterRids.size > 0 && (this.tables.valid & (1n << 7n)) !== 0n) {
-      const pointerRids = paramPointerRows
-        .filter((pointer) => parameterRids.has(pointer.Param.rid))
-        .map((pointer) => pointer.rid);
-      const firstPointerRid = Math.min(...pointerRids);
-      if (pointerRids.length !== parameterRids.size ||
-          [...pointerRids].sort((a, b) => a - b)
-            .some((pointerRid, index) => pointerRid !== firstPointerRid + index)) {
-        throw new UnsupportedFormatError(
-          "MethodDef removal requires its ParamPtr rows to form a contiguous pointer range"
-        );
-      }
-    }
-    if (parameterRids.size > 0) {
-      for (const [tableId, tableRows] of this.tables.rows) {
-        const schema = metadataTableSchemas[tableId];
-        if (!schema) {
-          throw new UnsupportedFormatError(
-            `Cannot remove MethodDef row ${rid} with unknown metadata table ${tableId}`
-          );
-        }
-        for (const row of tableRows) {
-          for (const [kind, value, name, pointer] of schema) {
-            const columnName = name ?? value;
-            if (kind === "coded" && row[columnName]?.target?.table === 8 &&
-                parameterRids.has(row[columnName].target.rid)) {
-              throw new FormatError(
-                `Param row ${row[columnName].target.rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-              );
-            }
-            if (kind === "table") {
-              const targetTable = pointer !== undefined &&
-                (this.tables.valid & (1n << BigInt(pointer))) !== 0n ? pointer : value;
-              if (targetTable !== 8 || (tableId === 6 && columnName === "ParamList") ||
-                  (tableId === 7 && columnName === "Param")) continue;
-              if (parameterRids.has(row[columnName]?.rid)) {
-                throw new FormatError(
-                  `Param row ${row[columnName].rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-                );
-              }
-            }
-            if (kind === "u4" && (tableId === 30 || tableId === 31) &&
-                columnName === "Token" && row[columnName] >>> 24 === 8 &&
-                parameterRids.has(row[columnName] & 0x00ffffff)) {
-              throw new FormatError(
-                `Param row ${row[columnName] & 0x00ffffff} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-              );
-            }
-          }
-        }
-      }
-    }
-    if (genericParamRids.size > 0) {
-      for (const [tableId, tableRows] of this.tables.rows) {
-        const schema = metadataTableSchemas[tableId];
-        if (!schema) {
-          throw new UnsupportedFormatError(
-            `Cannot remove MethodDef row ${rid} with unknown metadata table ${tableId}`
-          );
-        }
-        for (const row of tableRows) {
-          if (tableId === 44 && genericParamConstraintRids.has(row.rid)) continue;
-          for (const [kind, value, name] of schema) {
-            const columnName = name ?? value;
-            const column = row[columnName];
-            const target = kind === "coded"
-              ? column?.target
-              : kind === "table" ? { table: value, rid: column?.rid } : null;
-            if (target?.table === 42 && genericParamRids.has(target.rid)) {
-              throw new FormatError(
-                `GenericParam row ${target.rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-              );
-            }
-            if (kind === "u4" && (tableId === 30 || tableId === 31) &&
-                columnName === "Token" && row[columnName] >>> 24 === 42 &&
-                genericParamRids.has(row[columnName] & 0x00ffffff)) {
-              throw new FormatError(
-                `GenericParam row ${row[columnName] & 0x00ffffff} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-              );
-            }
-          }
-        }
-      }
-    }
-
-    const pointerRows = getBijectivePointerRows(this, 5, 6, "Method");
-    const pointerRid = pointerRows
-      ? pointerRows.findIndex((pointer) => pointer.Method.rid === rid) + 1
-      : 0;
-    if (pointerRows && pointerRid === 0) {
-      throw new FormatError(`MethodPtr has no pointer to MethodDef row ${rid}`);
-    }
-    const tokenMap = new Map();
-    for (let oldRid = rid + 1; oldRid <= rows.length; oldRid++) {
-      tokenMap.set(0x06000000 + oldRid, 0x06000000 + oldRid - 1);
-    }
-    const lastParameterRid = parameterRids.size > 0
-      ? Math.max(...parameterRids)
-      : 0;
-    const remapParameterRid = (oldRid) =>
-      oldRid > lastParameterRid ? oldRid - parameterRids.size : oldRid;
-    if (parameterRids.size > 0) {
-      for (let oldRid = lastParameterRid + 1; oldRid <= parameterRows.length; oldRid++) {
-        tokenMap.set(0x08000000 + oldRid, 0x08000000 + remapParameterRid(oldRid));
-      }
-    }
-    const lastGenericParamRid = genericParamRids.size > 0
-      ? Math.max(...genericParamRids)
-      : 0;
-    const remapGenericParamRid = (oldRid) =>
-      oldRid > lastGenericParamRid ? oldRid - genericParamRids.size : oldRid;
-    if (genericParamRids.size > 0) {
-      for (let oldRid = lastGenericParamRid + 1; oldRid <= genericParamRows.length; oldRid++) {
-        tokenMap.set(0x2a000000 + oldRid, 0x2a000000 + remapGenericParamRid(oldRid));
-      }
-    }
-    const remapGenericParamConstraintRid = (oldRid) => oldRid -
-      [...genericParamConstraintRids].filter((constraintRid) => constraintRid < oldRid).length;
-    if (genericParamConstraintRids.size > 0) {
-      for (let oldRid = 1; oldRid <= genericParamConstraintRows.length; oldRid++) {
-        if (genericParamConstraintRids.has(oldRid)) continue;
-        tokenMap.set(
-          0x2c000000 + oldRid,
-          0x2c000000 + remapGenericParamConstraintRid(oldRid)
-        );
-      }
-    }
-    const rowChanges = [];
-    for (const [tableId, tableRows] of this.tables.rows) {
-      const schema = metadataTableSchemas[tableId];
-      if (!schema) {
-        throw new UnsupportedFormatError(
-          `Cannot remove MethodDef row ${rid} with unknown metadata table ${tableId}`
-        );
-      }
-      for (const row of tableRows) {
-        if (tableId === 44 && genericParamConstraintRids.has(row.rid)) continue;
-        for (const [kind, value, name, pointer] of schema) {
-          const columnName = name ?? value;
-          if (kind === "coded") {
-            const target = row[columnName]?.target;
-            if (target?.table === 44) {
-              if (genericParamConstraintRids.has(target.rid)) {
-                throw new FormatError(
-                  `GenericParamConstraint row ${target.rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-                );
-              }
-              const remappedRid = remapGenericParamConstraintRid(target.rid);
-              if (remappedRid !== target.rid) {
-                const remappedTarget = { ...target, rid: remappedRid };
-                rowChanges.push({
-                  row,
-                  columnName,
-                  value: {
-                    raw: encodeCodedIndex(44, remappedRid, value),
-                    target: remappedTarget
-                  }
-                });
-              }
-              continue;
-            }
-            if (target?.table === 8 || target?.table === 42) {
-              const removedRids = target.table === 8 ? parameterRids : genericParamRids;
-              if (removedRids.has(target.rid)) {
-                throw new FormatError(
-                  `${metadataTableNames[target.table]} row ${target.rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-                );
-              }
-              const remappedRid = target.table === 8
-                ? remapParameterRid(target.rid)
-                : remapGenericParamRid(target.rid);
-              if (remappedRid !== target.rid) {
-                const remappedTarget = { ...target, rid: remappedRid };
-                rowChanges.push({
-                  row,
-                  columnName,
-                  value: {
-                    raw: encodeCodedIndex(target.table, remappedRid, value),
-                    target: remappedTarget
-                  }
-                });
-              }
-              continue;
-            }
-            if (target?.table !== 6) continue;
-            if (tableId === 42 && columnName === "Owner" &&
-                genericParamRids.has(row.rid)) continue;
-            if (target.rid === rid) {
-              throw new FormatError(`MethodDef row ${rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`);
-            }
-            if (target.rid > rid) {
-              const remappedTarget = { ...target, rid: target.rid - 1 };
-              rowChanges.push({
-                row,
-                columnName,
-                value: {
-                  raw: encodeCodedIndex(6, remappedTarget.rid, value),
-                  target: remappedTarget
-                }
-              });
-            }
-          } else if (kind === "u4" && (tableId === 30 || tableId === 31) &&
-              columnName === "Token" && [8, 42].includes(row[columnName] >>> 24)) {
-            const tokenTable = row[columnName] >>> 24;
-            const targetRid = row[columnName] & 0x00ffffff;
-            const removedRids = tokenTable === 8 ? parameterRids : genericParamRids;
-            if (removedRids.has(targetRid)) {
-              throw new FormatError(
-                `${metadataTableNames[tokenTable]} row ${targetRid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-              );
-            }
-            const remappedRid = tokenTable === 8
-              ? remapParameterRid(targetRid)
-              : remapGenericParamRid(targetRid);
-            if (remappedRid !== targetRid) {
-              rowChanges.push({
-                row,
-                columnName,
-                value: (tokenTable << 24) | remappedRid
-              });
-            }
-          } else if (kind === "u4" && (tableId === 30 || tableId === 31) &&
-              columnName === "Token" && row[columnName] >>> 24 === 44) {
-            const targetRid = row[columnName] & 0x00ffffff;
-            if (genericParamConstraintRids.has(targetRid)) {
-              throw new FormatError(
-                `GenericParamConstraint row ${targetRid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-              );
-            }
-            const remappedRid = remapGenericParamConstraintRid(targetRid);
-            if (remappedRid !== targetRid) {
-              rowChanges.push({
-                row,
-                columnName,
-                value: 0x2c000000 | remappedRid
-              });
-            }
-          } else if (kind === "u4" && (tableId === 30 || tableId === 31) &&
-              columnName === "Token" && row[columnName] >>> 24 === 6 &&
-              (row[columnName] & 0x00ffffff) === rid) {
-            throw new FormatError(`MethodDef row ${rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`);
-          } else if (kind === "u4" && (tableId === 30 || tableId === 31) &&
-              columnName === "Token" && row[columnName] >>> 24 === 6 &&
-              (row[columnName] & 0x00ffffff) > rid) {
-            const oldToken = row[columnName];
-            rowChanges.push({ row, columnName, value: oldToken - 1 });
-          } else if (kind === "table") {
-            if (tableId === 2 && columnName === "MethodList") continue;
-            const targetTable = pointer !== undefined &&
-              (this.tables.valid & (1n << BigInt(pointer))) !== 0n ? pointer : value;
-            const targetRid = row[columnName]?.rid;
-            if (targetTable === 8) {
-              if ((tableId === 6 && columnName === "ParamList") ||
-                  (tableId === 7 && columnName === "Param")) continue;
-              if (parameterRids.has(targetRid)) {
-                throw new FormatError(
-                  `Param row ${targetRid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-                );
-              }
-              const remappedRid = remapParameterRid(targetRid);
-              if (remappedRid !== targetRid) {
-                rowChanges.push({
-                  row,
-                  columnName,
-                  value: { ...row[columnName], raw: remappedRid, rid: remappedRid }
-                });
-              }
-              continue;
-            }
-            if (targetTable === 42) {
-              if (genericParamRids.has(targetRid)) {
-                throw new FormatError(
-                  `GenericParam row ${targetRid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-                );
-              }
-              const remappedRid = remapGenericParamRid(targetRid);
-              if (remappedRid !== targetRid) {
-                rowChanges.push({
-                  row,
-                  columnName,
-                  value: { ...row[columnName], raw: remappedRid, rid: remappedRid }
-                });
-              }
-              continue;
-            }
-            if (targetTable === 44) {
-              if (genericParamConstraintRids.has(targetRid)) {
-                throw new FormatError(
-                  `GenericParamConstraint row ${targetRid} is referenced by ${metadataTableNames[tableId]}.${columnName}`
-                );
-              }
-              const remappedRid = remapGenericParamConstraintRid(targetRid);
-              if (remappedRid !== targetRid) {
-                rowChanges.push({
-                  row,
-                  columnName,
-                  value: { ...row[columnName], raw: remappedRid, rid: remappedRid }
-                });
-              }
-              continue;
-            }
-            if (targetTable !== 6) continue;
-            if (tableId === 5 && columnName === "Method") {
-              if (row.rid === pointerRid) continue;
-              if (targetRid === rid) {
-                throw new FormatError(`MethodDef row ${rid} is referenced by MethodPtr.Method`);
-              }
-              continue;
-            }
-            if (targetRid === rid) {
-              throw new FormatError(`MethodDef row ${rid} is referenced by ${metadataTableNames[tableId]}.${columnName}`);
-            }
-            if (targetRid > rid) {
-              rowChanges.push({
-                row,
-                columnName,
-                value: { ...row[columnName], raw: targetRid - 1, rid: targetRid - 1 }
-              });
-            }
-          }
-        }
-      }
-    }
-    const tokenUpdates = [];
-    const patches = [];
-    for (const candidate of this.methods) {
-      if (candidate.rid === rid) continue;
-      const body = this.getMethodBody(candidate.rid);
-      for (const instruction of body?.instructions ?? []) {
-        const token = instruction.operand?.kind === "token" ? instruction.operand.value : 0;
-        if ((token >>> 24) !== 6) continue;
-        const targetRid = token & 0x00ffffff;
-        if (targetRid === rid) {
-          throw new FormatError(`MethodDef row ${rid} is referenced by CIL in MethodDef row ${candidate.rid}`);
-        }
-        if (targetRid > rid) {
-          const replacement = token - 1;
-          tokenUpdates.push({ instruction, replacement });
-          patches.push(...createOperandPatches(instruction, replacement));
-        }
-      }
-    }
-    const sortedKeyColumns = new Map([
-      [10, "Class"], [11, "Parent"], [12, "Parent"], [13, "Parent"], [14, "Parent"],
-      [28, "MemberForwarded"], [42, "Owner"], [43, "Method"]
-    ]);
-    const changedSortedKeys = new Map(rowChanges
-      .filter((change) => [...sortedKeyColumns.values()].includes(change.columnName))
-      .map((change) => [change.row, change.value]));
-    for (const [tableId, keyOf] of [
-      [10, (row) => [row.Class.raw]],
-      [11, (row) => [row.Parent.raw]],
-      [12, (row) => [row.Parent.raw]],
-      [13, (row) => [row.Parent.raw]],
-      [14, (row) => [row.Parent.raw, row.Action]],
-      [28, (row) => [row.MemberForwarded.raw]],
-      [42, (row) => [row.Owner.raw, row.Number]],
-      [43, (row) => [row.Method.raw]]
-    ]) {
-      if ((this.tables.sorted & (1n << BigInt(tableId))) === 0n) continue;
-      let previous = null;
-      for (const row of this.tables.get(tableId)) {
-        const changedKey = changedSortedKeys.get(row);
-        const current = keyOf(row);
-        if (changedKey) current[0] = changedKey.raw ?? changedKey;
-        let outOfOrder = false;
-        if (previous) {
-          for (let index = 0; index < current.length; index++) {
-            if (current[index] === previous[index]) continue;
-            outOfOrder = current[index] < previous[index];
-            break;
-          }
-        }
-        if (outOfOrder) {
-          throw new FormatError(
-            `MethodDef token remapping would violate sorted ${metadataTableNames[tableId]} order`
-          );
-        }
-        previous = current;
-      }
-    }
-
-    const methodPointerPresent = pointerRows !== null;
-    if (embeddedPdbIndices.length === 1) {
-      const updatedCounts = [...this.tables.counts];
-      updatedCounts[6]--;
-      if (methodPointerPresent) updatedCounts[5]--;
-      if (parameterRids.size > 0) {
-        updatedCounts[8] -= parameterRids.size;
-        if (paramPointerRows) updatedCounts[7] -= parameterRids.size;
-      }
-      if (genericParamRids.size > 0) updatedCounts[42] -= genericParamRids.size;
-      if (genericParamConstraintRids.size > 0) {
-        updatedCounts[44] -= genericParamConstraintRids.size;
-      }
-      const debugEntryIndex = embeddedPdbIndices[0];
-      const debugEntry = this.pe.debugDirectoryEntries[debugEntryIndex];
-      const pdb = this.#getPortablePdbForEdit(debugEntryIndex, debugEntry);
-      const updatedPdb = removePortablePdbMethod(
-        pdb,
-        rid,
-        this.tables.counts,
-        updatedCounts
-      );
-      this.#replaceEmbeddedPortablePdb(debugEntryIndex, updatedPdb, updatedCounts);
-    }
-    if (remappedCliEntryPointToken !== cliEntryPointToken) {
-      const entryPointBytes = new Uint8Array(4);
-      new DataView(entryPointBytes.buffer).setUint32(0, remappedCliEntryPointToken, true);
-      patches.push({
-        offset: this.cli.offset + 20,
-        bytes: entryPointBytes
-      });
-      this._cliEntryPointToken = remappedCliEntryPointToken;
-    }
-    if (methodPointerPresent) {
-      const remainingPointers = pointerRows.filter((pointer) => pointer.rid !== pointerRid);
-      remainingPointers.forEach((pointer, index) => {
-        pointer.rid = index + 1;
-        if (pointer.Method.rid > rid) {
-          pointer.Method = {
-            ...pointer.Method,
-            raw: pointer.Method.rid - 1,
-            rid: pointer.Method.rid - 1
-          };
-        }
-      });
-      this.tables.rows.set(5, remainingPointers);
-      this.tables.counts[5] = remainingPointers.length;
-      if (remainingPointers.length === 0) this.tables.valid &= ~(1n << 5n);
-    }
-    const listBoundary = methodPointerPresent ? pointerRid : rid;
-    const listChanges = [];
-    for (const typeRow of this.tables.rows.get(2) ?? []) {
-      if (typeRow.MethodList.rid > listBoundary) {
-        listChanges.push({
-          row: typeRow,
-          value: {
-            ...typeRow.MethodList,
-            raw: typeRow.MethodList.rid - 1,
-            rid: typeRow.MethodList.rid - 1
-          }
-        });
-      }
-    }
-    const removedParamListPositions = paramPointerRows
-      ? paramPointerRows.filter((pointer) => parameterRids.has(pointer.Param.rid))
-        .map((pointer) => pointer.rid)
-      : [...parameterRids];
-    const paramListChanges = [];
-    if (removedParamListPositions.length > 0) {
-      for (const methodRow of this.tables.get(6)) {
-        const oldBoundary = methodRow.ParamList.rid;
-        const newBoundary = oldBoundary -
-          removedParamListPositions.filter((position) => position < oldBoundary).length;
-        if (newBoundary === oldBoundary) continue;
-        paramListChanges.push({
-          row: methodRow,
-          value: {
-            ...methodRow.ParamList,
-            raw: newBoundary,
-            rid: newBoundary
-          }
-        });
-      }
-    }
-    for (const change of rowChanges) change.row[change.columnName] = change.value;
-    for (const change of listChanges) change.row.MethodList = change.value;
-    for (const change of paramListChanges) change.row.ParamList = change.value;
-    for (const update of tokenUpdates) update.instruction.operand.value = update.replacement;
-    this._patches.push(...patches);
-    if (parameterRids.size > 0) {
-      const remainingParams = parameterRows.filter((parameter) => !parameterRids.has(parameter.rid));
-      remainingParams.forEach((parameter) => {
-        parameter.rid = remapParameterRid(parameter.rid);
-      });
-      this.tables.rows.set(8, remainingParams);
-      this.tables.counts[8] = remainingParams.length;
-      if (remainingParams.length === 0) this.tables.valid &= ~(1n << 8n);
-      if (paramPointerRows) {
-        const remainingParamPointers = paramPointerRows.filter((pointer) =>
-          !parameterRids.has(pointer.Param.rid)
-        );
-        remainingParamPointers.forEach((pointer, index) => {
-          pointer.rid = index + 1;
-          const remappedRid = remapParameterRid(pointer.Param.rid);
-          if (remappedRid !== pointer.Param.rid) {
-            pointer.Param = {
-              ...pointer.Param,
-              raw: remappedRid,
-              rid: remappedRid
-            };
-          }
-        });
-        this.tables.rows.set(7, remainingParamPointers);
-        this.tables.counts[7] = remainingParamPointers.length;
-        if (remainingParamPointers.length === 0) this.tables.valid &= ~(1n << 7n);
-      }
-      for (const candidate of this.methods) {
-        candidate.parameterRids = candidate.parameterRids
-          .filter((parameterRid) => !parameterRids.has(parameterRid))
-          .map(remapParameterRid);
-        candidate.parameters = candidate.parameters
-          .filter((parameter) => !parameterRids.has(parameter.rid))
-          .map((parameter) => {
-            parameter.rid = remapParameterRid(parameter.rid);
-            return parameter;
-          });
-      }
-    }
-    if (genericParamRids.size > 0) {
-      const remainingGenericParams = genericParamRows.filter((parameter) =>
-        !genericParamRids.has(parameter.rid)
-      );
-      remainingGenericParams.forEach((parameter) => {
-        parameter.rid = remapGenericParamRid(parameter.rid);
-      });
-      this.tables.rows.set(42, remainingGenericParams);
-      this.tables.counts[42] = remainingGenericParams.length;
-      if (remainingGenericParams.length === 0) this.tables.valid &= ~(1n << 42n);
-      this.genericParams = this.genericParams.filter((parameter) =>
-        !genericParamRids.has(parameter.rid)
-      );
-      for (const parameter of this.genericParams) {
-        parameter.rid = remapGenericParamRid(parameter.rid);
-      }
-      for (const constraint of this.genericParamConstraints) {
-        constraint.ownerRid = remapGenericParamRid(constraint.ownerRid);
-      }
-    }
-    if (genericParamConstraintRids.size > 0) {
-      const remainingConstraints = this.genericParamConstraints.filter((constraint) =>
-        !genericParamConstraintRids.has(constraint.rid)
-      );
-      remainingConstraints.forEach((constraint) => {
-        constraint.rid = remapGenericParamConstraintRid(constraint.rid);
-      });
-      this.genericParamConstraints.splice(
-        0,
-        this.genericParamConstraints.length,
-        ...remainingConstraints
-      );
-      const remainingConstraintRows = genericParamConstraintRows.filter((constraint) =>
-        !genericParamConstraintRids.has(constraint.rid)
-      );
-      remainingConstraintRows.forEach((constraint) => {
-        constraint.rid = remapGenericParamConstraintRid(constraint.rid);
-      });
-      this.tables.rows.set(44, remainingConstraintRows);
-      this.tables.counts[44] = remainingConstraintRows.length;
-      if (remainingConstraintRows.length === 0) this.tables.valid &= ~(1n << 44n);
-    }
-    if (parameterRids.size > 0 || genericParamRids.size > 0) {
-      for (const attribute of this.customAttributes) {
-        if (attribute.parent?.table === 8 && !parameterRids.has(attribute.parent.rid)) {
-          attribute.parent = {
-            ...attribute.parent,
-            rid: remapParameterRid(attribute.parent.rid)
-          };
-        } else if (attribute.parent?.table === 42 &&
-            !genericParamRids.has(attribute.parent.rid)) {
-          attribute.parent = {
-            ...attribute.parent,
-            rid: remapGenericParamRid(attribute.parent.rid)
-          };
-        } else if (attribute.parent?.table === 44 &&
-            !genericParamConstraintRids.has(attribute.parent.rid)) {
-          attribute.parent = {
-            ...attribute.parent,
-            rid: remapGenericParamConstraintRid(attribute.parent.rid)
-          };
-        }
-      }
-    }
-    const remainingRows = rows.filter((row) => row.rid !== rid);
-    remainingRows.forEach((row, index) => {
-      row.rid = index + 1;
-    });
-    this.tables.rows.set(6, remainingRows);
-    this.tables.counts[6] = remainingRows.length;
-    if (remainingRows.length === 0) this.tables.valid &= ~(1n << 6n);
-    for (const type of this.types) {
-      type.methodRids = type.methodRids
-        .filter((methodRid) => methodRid !== rid)
-        .map((methodRid) => methodRid > rid ? methodRid - 1 : methodRid);
-      type.methods = type.methods.filter((candidate) => candidate.rid !== rid);
-      for (const candidate of type.methods) {
-        if (candidate.rid > rid) candidate.rid--;
-      }
-    }
-    this.methods.splice(rid - 1, 1);
-    this.methods.forEach((candidate, index) => {
-      candidate.rid = index + 1;
-    });
-    for (const parameter of this.genericParams) {
-      if (parameter.owner.table === 6 && parameter.owner.rid > rid) {
-        parameter.owner = { ...parameter.owner, rid: parameter.owner.rid - 1 };
-      }
-    }
-    for (const memberRef of this.memberRefs) {
-      if (memberRef.parent?.table === 6 && memberRef.parent.rid > rid) {
-        memberRef.parent = { ...memberRef.parent, rid: memberRef.parent.rid - 1 };
-      }
-    }
-    for (const methodSpec of this.methodSpecs) {
-      if (methodSpec.method?.table === 6 && methodSpec.method.rid > rid) {
-        methodSpec.method = { ...methodSpec.method, rid: methodSpec.method.rid - 1 };
-      }
-    }
-    for (const attribute of this.customAttributes) {
-      if (attribute.parent?.table === 6 && attribute.parent.rid > rid) {
-        attribute.parent = { ...attribute.parent, rid: attribute.parent.rid - 1 };
-      }
-    }
-    const remappedBodyCache = new Map();
-    for (const [methodRid, body] of this._bodyCache) {
-      if (methodRid === rid) continue;
-      remappedBodyCache.set(methodRid > rid ? methodRid - 1 : methodRid, body);
-    }
-    this._bodyCache = remappedBodyCache;
-    this._addedMethodBodies.delete(rid);
-    this._bodyCache.delete(rid);
-    this._metadataDirty = true;
-    return tokenMap;
-  }
-
-  addParam({ owner, name = "", sequence, flags = 0 }) {
-    return this.#writeParam({ owner, name, sequence, flags }, false).rid;
-  }
-
-  insertParam({ owner, name = "", sequence, flags = 0 }) {
-    return this.#writeParam({ owner, name, sequence, flags }, true);
-  }
-
-  #writeParam({ owner, name = "", sequence, flags = 0 }, insertIntoOwner) {
-    this.#ensureEditable();
-    const ownerRid = metadataTableId(owner?.table) === 6 ? owner.rid : 0;
-    const method = this.methods[ownerRid - 1];
-    if (!Number.isInteger(ownerRid) || ownerRid < 1 || !method) {
-      throw new RangeError("Param owner must identify an existing MethodDef");
-    }
-    if (typeof name !== "string" || name.includes("\0")) {
-      throw new TypeError("Param name must be a null-free string");
+    if (typeof name !== "string" || name.includes("\0")) {
+      throw new TypeError("Param name must be a null-free string");
     }
     if (!Number.isInteger(flags) || flags < 0 || flags > 0xffff) {
       throw new RangeError("Param flags must be an unsigned 16-bit integer");
@@ -7256,252 +6157,7 @@ export class Assembly {
   }
 
   reorderPointerTable(pointerTable, targetRids) {
-    this.#ensureEditable();
-    const pointerTableId = metadataTableId(pointerTable);
-    const definitions = new Map([
-      [3, { targetTableId: 4, column: "Field", owners: this.types, list: "fieldRids", records: "fields" }],
-      [5, { targetTableId: 6, column: "Method", owners: this.types, list: "methodRids", records: "methods" }],
-      [7, {
-        targetTableId: 8,
-        column: "Param",
-        owners: this.methods,
-        list: "parameterRids",
-        records: "parameters"
-      }],
-      [19, { targetTableId: 20, column: "Event", owners: this.types, list: "eventRids", records: "events" }],
-      [22, {
-        targetTableId: 23,
-        column: "Property",
-        owners: this.types,
-        list: "propertyRids",
-        records: "properties"
-      }]
-    ]);
-    const definition = definitions.get(pointerTableId);
-    if (!definition) {
-      throw new TypeError("Pointer table must be FieldPtr, MethodPtr, ParamPtr, EventPtr, or PropertyPtr");
-    }
-    const allowsCrossOwnerFields = pointerTableId === 3;
-    const allowsCrossOwnerMethods = pointerTableId === 5;
-    const allowsCrossOwnerParameters = pointerTableId === 7;
-    const allowsCrossOwnerEvents = pointerTableId === 19;
-    const allowsCrossOwnerProperties = pointerTableId === 22;
-    if ((this.tables.valid & (1n << BigInt(pointerTableId))) === 0n) {
-      throw new UnsupportedFormatError(`${metadataTableNames[pointerTableId]} is not present`);
-    }
-    const pointerRows = getBijectivePointerRows(
-      this,
-      pointerTableId,
-      definition.targetTableId,
-      definition.column
-    );
-    if (!pointerRows) {
-      throw new FormatError(
-        `${metadataTableNames[pointerTableId]} must be a one-to-one mapping to ${metadataTableNames[definition.targetTableId]}`
-      );
-    }
-    const targetCount = this.tables.counts[definition.targetTableId] ?? 0;
-    if (!Array.isArray(targetRids) || targetRids.length !== targetCount) {
-      throw new RangeError("Pointer table order must contain every target row exactly once");
-    }
-    const newRids = [...targetRids];
-    const uniqueRids = new Set(newRids);
-    if (uniqueRids.size !== targetCount ||
-        newRids.some((rid) => !Number.isInteger(rid) || rid < 1 || rid > targetCount)) {
-      throw new RangeError("Pointer table order must contain every target row exactly once");
-    }
-
-    const ownerGroups = definition.owners.map((owner) => owner[definition.list]);
-    const currentOwnerRids = ownerGroups.flat();
-    if (currentOwnerRids.length !== targetCount ||
-        new Set(currentOwnerRids).size !== targetCount) {
-      throw new FormatError(
-        `${metadataTableNames[definition.targetTableId]} ownership does not cover every row exactly once`
-      );
-    }
-    const currentOwnerByRid = new Map();
-    for (let index = 0; index < ownerGroups.length; index++) {
-      for (const rid of ownerGroups[index]) {
-        currentOwnerByRid.set(rid, definition.owners[index].rid);
-      }
-    }
-    const assignments = [];
-    let offset = 0;
-    const recordsByRid = new Map(
-      definition.owners.flatMap((owner) =>
-        owner[definition.records].map((record) => [record.rid, record])
-      )
-    );
-    for (let index = 0; index < definition.owners.length; index++) {
-      const owner = definition.owners[index];
-      const oldGroup = ownerGroups[index];
-      const nextGroup = newRids.slice(offset, offset + oldGroup.length);
-      offset += oldGroup.length;
-      const oldSet = new Set(oldGroup);
-      const movesRowsAcrossOwners = nextGroup.some((rid) => !oldSet.has(rid));
-      const allowsCrossOwnerRows = allowsCrossOwnerFields || allowsCrossOwnerMethods ||
-        allowsCrossOwnerParameters || allowsCrossOwnerEvents || allowsCrossOwnerProperties;
-      if (!allowsCrossOwnerRows && movesRowsAcrossOwners) {
-        throw new UnsupportedFormatError("Pointer reordering cannot change row ownership");
-      }
-      const nextRecords = nextGroup.map((rid) => recordsByRid.get(rid));
-      if (nextRecords.some((record) => !record)) {
-        throw new FormatError(`${metadataTableNames[definition.targetTableId]} ownership has no semantic record`);
-      }
-      const movedRecords = nextRecords.filter((record) =>
-        currentOwnerByRid.get(record.rid) !== owner.rid
-      );
-      if (allowsCrossOwnerFields) {
-        for (const record of movedRecords) {
-          const parsed = parseSignature(record.signature, { counts: this.tables.counts });
-          if (parsed.kind !== "field") {
-            throw new FormatError(`Field row ${record.rid} has a non-field signature`);
-          }
-          validateGenericVariableReferences(
-            parsed,
-            getGenericParameterArity(this.genericParams, 2, owner.rid),
-            this
-          );
-          if ((this.tables.rows.get(16) ?? []).some((layout) =>
-            layout.Field.rid === record.rid
-          ) && (owner.flags & 0x0018) !== 0x0010) {
-            throw new UnsupportedFormatError(
-              `Field row ${record.rid} has an explicit offset and requires an explicit-layout owner`
-            );
-          }
-        }
-      }
-      if (allowsCrossOwnerParameters && movesRowsAcrossOwners) {
-        const signature = parseSignature(owner.signature, { counts: this.tables.counts });
-        if (signature.kind !== "method") {
-          throw new FormatError(`MethodDef row ${owner.rid} has a non-method signature`);
-        }
-        const sequences = new Set();
-        for (const record of nextRecords) {
-          if (!Number.isInteger(record.sequence) || record.sequence < 0 ||
-              record.sequence > signature.parameters.length) {
-            throw new FormatError(
-              `Param row ${record.rid} sequence exceeds MethodDef row ${owner.rid}'s signature`
-            );
-          }
-          if (sequences.has(record.sequence)) {
-            throw new FormatError(
-              `MethodDef row ${owner.rid} would have duplicate Param sequence ${record.sequence}`
-            );
-          }
-          sequences.add(record.sequence);
-        }
-      }
-      if (allowsCrossOwnerMethods && movesRowsAcrossOwners) {
-        if ((owner.flags & (0x0080 | 0x0020)) === 0) {
-          throw new UnsupportedFormatError(
-            "Pointer reordering cannot move abstract methods to a non-abstract TypeDef"
-          );
-        }
-        for (const record of movedRecords) {
-          if (record.rva !== 0 || (record.flags & 0x0440) !== 0x0440 ||
-              record.genericParams.length > 0) {
-            throw new UnsupportedFormatError(
-              "Cross-owner MethodPtr reordering supports only bodyless, non-generic abstract virtual methods"
-            );
-          }
-          const signature = parseSignature(record.signature, { counts: this.tables.counts });
-          if (signature.kind !== "method") {
-            throw new FormatError(`MethodDef row ${record.rid} has a non-method signature`);
-          }
-          if ((signature.genericParameterCount ?? 0) > 0) {
-            throw new UnsupportedFormatError(
-              "Cross-owner MethodPtr reordering does not support generic methods"
-            );
-          }
-          validateGenericVariableReferences(
-            signature,
-            getGenericParameterArity(this.genericParams, 2, owner.rid),
-            this,
-            null,
-            signature.genericParameterCount ?? 0
-          );
-          const hasMethodSemantics = (this.tables.rows.get(24) ?? []).some((row) =>
-            row.Method.rid === record.rid
-          );
-          const hasMethodImpl = (this.tables.rows.get(25) ?? []).some((row) =>
-            row.MethodBody.target?.table === 6 && row.MethodBody.target.rid === record.rid ||
-            row.MethodDeclaration.target?.table === 6 && row.MethodDeclaration.target.rid === record.rid
-          );
-          if (hasMethodSemantics || hasMethodImpl) {
-            throw new UnsupportedFormatError(
-              "Pointer reordering cannot change row ownership for methods with semantics or MethodImpl rows"
-            );
-          }
-        }
-      }
-      if (allowsCrossOwnerEvents && movesRowsAcrossOwners) {
-        for (const record of movedRecords) {
-          const hasSemantics = (this.tables.rows.get(24) ?? []).some((row) =>
-            row.Association.target?.table === 20 && row.Association.target.rid === record.rid
-          );
-          if (hasSemantics) {
-            throw new UnsupportedFormatError(
-              "Pointer reordering cannot change row ownership for events with MethodSemantics rows"
-            );
-          }
-          if (record.eventType.table === 27) {
-            const typeArity = getGenericParameterArity(this.genericParams, 2, owner.rid);
-            const typeSpec = this.typeSpecs[record.eventType.rid - 1];
-            if (!typeSpec) {
-              throw new FormatError(`Event row ${record.rid} references missing TypeSpec row ${record.eventType.rid}`);
-            }
-            validateTypeSpecDefinitions(this, typeSpec.parsedSignature);
-            validateTypeSpecGenericContext(this, record.eventType.rid, typeArity);
-          }
-        }
-      }
-      if (allowsCrossOwnerProperties && movesRowsAcrossOwners) {
-        for (const record of movedRecords) {
-          const hasSemantics = (this.tables.rows.get(24) ?? []).some((row) =>
-            row.Association.target?.table === 23 && row.Association.target.rid === record.rid
-          );
-          if (hasSemantics) {
-            throw new UnsupportedFormatError(
-              "Pointer reordering cannot change row ownership for properties with MethodSemantics rows"
-            );
-          }
-          const signature = parseSignature(record.signature, { counts: this.tables.counts });
-          if (signature.kind !== "property") {
-            throw new FormatError(`Property row ${record.rid} has a non-property signature`);
-          }
-          validateGenericVariableReferences(
-            signature,
-            getGenericParameterArity(this.genericParams, 2, owner.rid),
-            this
-          );
-        }
-      }
-      assignments.push({ owner, nextGroup, nextRecords });
-    }
-    if (offset !== targetCount) {
-      throw new FormatError(
-        `${metadataTableNames[definition.targetTableId]} ownership does not cover every row exactly once`
-      );
-    }
-
-    const nextPointerRows = newRids.map((rid, index) => ({
-      ...pointerRows[index],
-      rid: index + 1,
-      [definition.column]: {
-        raw: rid,
-        table: definition.targetTableId,
-        tableName: metadataTableNames[definition.targetTableId],
-        rid
-      }
-    }));
-    this.tables.rows.set(pointerTableId, nextPointerRows);
-    for (const assignment of assignments) {
-      assignment.owner[definition.list] = assignment.nextGroup;
-      assignment.owner[definition.records] = assignment.nextRecords;
-    }
-    this._metadataDirty = true;
-    return this;
+    return this.#pointerTableEditor.reorderPointerTable.call(this, pointerTable, targetRids);
   }
 
   addField({ owner, name, flags = 0, signature }) {
@@ -8562,147 +7218,23 @@ export class Assembly {
   }
 
   setInstructionOperand(methodRid, instructionOffset, value) {
-    this.#ensureEditable();
-    const body = this.getMethodBody(methodRid);
-    if (!body) throw new FormatError("Method has no CIL body");
-    const instruction = body.instructions.find((candidate) => candidate.offset === instructionOffset);
-    if (!instruction) throw new RangeError(`No instruction begins at IL_${instructionOffset.toString(16)}`);
-    if (!instruction.operand) throw new TypeError("Instruction has no operand");
-
-    if (instruction.operand.kind === "branch") {
-      this.#validateBranchTarget(body, value);
-    } else if (instruction.operand.kind === "switch") {
-      if (!Array.isArray(value)) throw new TypeError("Switch operand must be an array of IL target offsets");
-      for (const target of value) this.#validateBranchTarget(body, target);
-    } else if (instruction.opcode.name === "ldstr") {
-      if (!Number.isInteger(value) || (value >>> 24) !== 0x70) {
-        throw new TypeError("ldstr operand must be a 0x70-prefixed user-string token");
-      }
-      this.heaps.getUserString(value);
-    } else if (instruction.operand.kind === "token") {
-      if (!Number.isInteger(value) || value < 0 || value > 0xffffffff) {
-        throw new RangeError("Metadata token must be an unsigned 32-bit integer");
-      }
-      const table = value >>> 24;
-      const rid = value & 0x00ffffff;
-      if (!allowedTokenTables(instruction.opcode.name).includes(table)) {
-        throw new FormatError(`Metadata table ${table} is not valid for ${instruction.opcode.name}`);
-      }
-      if (rid === 0 || rid > (this.tables.counts[table] ?? 0)) {
-        throw new RangeError(`${instruction.opcode.name} references missing ${metadataTableNames[table]} row ${rid}`);
-      }
-      validateInstructionGenericContext(this, methodRid, instruction, value);
-    }
-
-    if (instruction.operand.kind === "branch" && instruction.operand.targetOffset === value) return this;
-    if (instruction.operand.kind === "switch" &&
-        instruction.operand.targetOffsets.length === value.length &&
-        instruction.operand.targetOffsets.every((target, index) => target === value[index])) return this;
-    if (instruction.operand.kind !== "branch" && instruction.operand.kind !== "switch" &&
-        instruction.operand.value === value) return this;
-
-    if (this._structuralBodies.has(methodRid) || this._addedMethodBodies.has(methodRid)) {
-      const state = this.#createStructuralState(methodRid);
-      const editableInstruction = state.instructions.find((candidate) => candidate.offset === instructionOffset);
-      updateStructuralOperand(state, editableInstruction, value);
-      this.#commitStructuralState(methodRid, state);
-    } else {
-      const patches = createOperandPatches(instruction, value);
-      for (const patch of patches) this._patches.push(patch);
-      instruction.operand = instruction.operand.kind === "branch"
-        ? { kind: "branch", targetOffset: value }
-        : instruction.operand.kind === "switch"
-          ? { kind: "switch", targetOffsets: [...value] }
-          : { ...instruction.operand, value };
-    }
-    return this;
+    return this.#instructionEditor.setInstructionOperand(methodRid, instructionOffset, value);
   }
 
   setInstructionOpcode(methodRid, instructionOffset, opcodeNameOrCode) {
-    this.#ensureEditable();
-    const body = this.getMethodBody(methodRid);
-    if (!body) throw new FormatError("Method has no CIL body");
-    const instruction = body.instructions.find((candidate) => candidate.offset === instructionOffset);
-    if (!instruction) throw new RangeError(`No instruction begins at IL_${instructionOffset.toString(16)}`);
-    const opcode = listOpcodes().find((candidate) =>
-      candidate.name === opcodeNameOrCode || candidate.code === opcodeNameOrCode
-    );
-    if (!opcode) throw new RangeError(`Unknown CIL opcode ${opcodeNameOrCode}`);
-    const encoded = encodeOpcode(opcode);
-    if (encoded.length !== instruction.opcodeSize || opcode.operand !== instruction.opcode.operand) {
-      throw new FormatError("Opcode edit must preserve the opcode and operand widths");
-    }
-    if (opcode.code === instruction.opcode.code) return this;
-    if (instruction.operand?.kind === "token") {
-      if (opcode.name !== "ldstr") {
-        const table = instruction.operand.value >>> 24;
-        const rid = instruction.operand.value & 0x00ffffff;
-        if (!allowedTokenTables(opcode.name).includes(table)) {
-          throw new FormatError(`Metadata table ${table} is not valid for ${opcode.name}`);
-        }
-        if (rid === 0 || rid > (this.tables.counts[table] ?? 0)) {
-          throw new RangeError(`${opcode.name} references missing ${metadataTableNames[table]} row ${rid}`);
-        }
-        validateInstructionGenericContext(
-          this, methodRid, { ...instruction, opcode }, instruction.operand.value
-        );
-      }
-    }
-    if (this._structuralBodies.has(methodRid) || this._addedMethodBodies.has(methodRid)) {
-      const state = this.#createStructuralState(methodRid);
-      const editableInstruction = state.instructions.find((candidate) => candidate.offset === instructionOffset);
-      editableInstruction.opcode = opcode;
-      layoutStructuralState(state);
-      this.#commitStructuralState(methodRid, state);
-    } else {
-      this._patches.push({ offset: instruction.opcodeOffset, bytes: encoded });
-      instruction.opcode = opcode;
-    }
-    return this;
+    return this.#instructionEditor.setInstructionOpcode(methodRid, instructionOffset, opcodeNameOrCode);
   }
 
   insertInstruction(methodRid, beforeOffset, opcodeNameOrCode, operand) {
-    this.#ensureEditable();
-    const opcode = listOpcodes().find((candidate) =>
-      candidate.name === opcodeNameOrCode || candidate.code === opcodeNameOrCode
-    );
-    if (!opcode) throw new RangeError(`Unknown CIL opcode ${opcodeNameOrCode}`);
-    const state = this.#createStructuralState(methodRid);
-    const instruction = insertStructuralInstruction(state, beforeOffset, opcode, operand);
-    if (instruction.operand?.kind === "token" && opcode.name !== "ldstr") {
-      const token = instruction.operand.value;
-      const table = token >>> 24;
-      const rid = token & 0x00ffffff;
-      if (!allowedTokenTables(opcode.name).includes(table)) {
-        throw new FormatError(`Metadata table ${table} is not valid for ${opcode.name}`);
-      }
-      if (rid === 0 || rid > (this.tables.counts[table] ?? 0)) {
-        throw new RangeError(`${opcode.name} references missing ${metadataTableNames[table]} row ${rid}`);
-      }
-      validateInstructionGenericContext(this, methodRid, instruction, token);
-    }
-    this.#commitStructuralState(methodRid, state);
-    return instruction;
+    return this.#instructionEditor.insertInstruction(methodRid, beforeOffset, opcodeNameOrCode, operand);
   }
 
   removeInstruction(methodRid, instructionOffset) {
-    this.#ensureEditable();
-    const state = this.#createStructuralState(methodRid);
-    const instruction = removeStructuralInstruction(state, instructionOffset);
-    this.#commitStructuralState(methodRid, state);
-    return instruction;
+    return this.#instructionEditor.removeInstruction(methodRid, instructionOffset);
   }
 
   setMethodMaxStack(methodRid, maxStack) {
-    this.#ensureEditable();
-    if (!Number.isInteger(maxStack) || maxStack < 0 || maxStack > 0xffff) {
-      throw new RangeError("maxStack must be an unsigned 16-bit integer");
-    }
-    const state = this.#createStructuralState(methodRid);
-    state.maxStack = maxStack;
-    layoutStructuralState(state);
-    this.#commitStructuralState(methodRid, state);
-    return this;
+    return this.#instructionEditor.setMethodMaxStack(methodRid, maxStack);
   }
 
   addMemberRef({ parent, name, signature }) {
@@ -14649,9 +13181,9 @@ export class Assembly {
     if (signature.rva === 0 && (this.cli.flags & 0x08) !== 0) {
       throw new FormatError("Strong-name-signed CLI header has no signature directory");
     }
-    const expectedSize = Math.ceil(privateKey.asymmetricKeyDetails.modulusLength / 8);
+    const expectedSize = Math.ceil(privateKey.n.bitLength() / 8);
     const currentPublicKey = this.heaps.getBlob(assemblyRow.PublicKey);
-    const keyChanged = !Buffer.from(currentPublicKey).equals(publicKey);
+    const keyChanged = !equalBytes(currentPublicKey, publicKey);
     const identityChanged = keyChanged ||
       assemblyRow.HashAlgId !== selectedHashAlgorithm ||
       (assemblyRow.Flags & 0x01) === 0;
@@ -14694,11 +13226,11 @@ export class Assembly {
     getStrongNameHashName(hashAlgorithm);
     const expectedPublicKey = encodeStrongNamePublicKey(privateKey, hashAlgorithm);
     const currentPublicKey = this.heaps.getBlob(assemblyRow.PublicKey);
-    if (!Buffer.from(currentPublicKey).equals(expectedPublicKey)) {
+    if (!equalBytes(currentPublicKey, expectedPublicKey)) {
       throw new FormatError("Strong-name private key does not match the Assembly public key");
     }
     const signature = this.cli.strongNameSignature;
-    const expectedSize = Math.ceil(privateKey.asymmetricKeyDetails.modulusLength / 8);
+    const expectedSize = Math.ceil(privateKey.n.bitLength() / 8);
     if ((signature.rva === 0) !== (signature.size === 0)) {
       throw new FormatError("Strong-name signature directory has only one of RVA and size set");
     }
@@ -14765,7 +13297,8 @@ export class Assembly {
   }
 
   toBuffer() {
-    return Buffer.from(this.serialize());
+    const bytes = this.serialize();
+    return typeof Buffer === "undefined" ? bytes : Buffer.from(bytes);
   }
 }