jsilnet 0.0.0-stage → 0.2.0

package/src/assembly/portable-pdb-editing.js

@@ -0,0 +1,441 @@
+import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
+import { parseEmbeddedPortablePdbData } from "../pe/headers.js";
+import {
+  addEmbeddedPortablePdbDocument as addPortablePdbDocument,
+  insertEmbeddedPortablePdbDocument as insertPortablePdbDocument,
+  addEmbeddedPortablePdbTypeDefinitionDocuments as addPortablePdbTypeDefinitionDocuments,
+  removeEmbeddedPortablePdbDocument as removePortablePdbDocument,
+  replaceEmbeddedPortablePdbTypeDefinitionDocuments as replacePortablePdbTypeDefinitionDocuments,
+  replaceEmbeddedPortablePdbDocumentMetadata as replacePortablePdbDocumentMetadata,
+  replaceEmbeddedPortablePdbDocumentName as replacePortablePdbDocumentName,
+  replaceEmbeddedPortablePdbSequencePoints as replacePortablePdbSequencePoints,
+  replaceEmbeddedPortablePdbMethodDocument as replacePortablePdbMethodDocument,
+  replaceEmbeddedPortablePdbImportScope as replacePortablePdbImportScope,
+  replaceEmbeddedPortablePdbLocalScope as replacePortablePdbLocalScope,
+  replaceEmbeddedPortablePdbLocalVariable as replacePortablePdbLocalVariable,
+  replaceEmbeddedPortablePdbLocalConstant as replacePortablePdbLocalConstant,
+  replaceEmbeddedPortablePdbCustomDebugInformation as replacePortablePdbCustomDebugInformation,
+  replaceEmbeddedPortablePdbSource as replacePortablePdbSource,
+  addEmbeddedPortablePdbSource as addPortablePdbSource,
+  removeEmbeddedPortablePdbSource as removePortablePdbSource,
+  removeEmbeddedPortablePdbCustomDebugInformation as removePortablePdbCustomDebugInformation,
+  replaceEmbeddedPortablePdbSourceLink as replacePortablePdbSourceLink,
+  removeEmbeddedPortablePdbSourceLink as removePortablePdbSourceLink,
+  addEmbeddedPortablePdbSourceLink as addPortablePdbSourceLink
+} from "../metadata/portable-pdb.js";
+
+export function createPortablePdbEditor(hooks) {
+  return {
+    addEmbeddedPortablePdbDocument(debugEntryIndex, name, options) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        name,
+        options
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    insertEmbeddedPortablePdbDocument(debugEntryIndex, options) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        options
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    addEmbeddedPortablePdbTypeDefinitionDocuments(
+      debugEntryIndex,
+      typeRid,
+      documentRids
+    ) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        typeRid,
+        documentRids
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    removeEmbeddedPortablePdbDocument(debugEntryIndex, documentRid) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        documentRid
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbTypeDefinitionDocuments(
+      debugEntryIndex,
+      typeRid,
+      documentRids
+    ) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        typeRid,
+        documentRids
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbDocumentMetadata(debugEntryIndex, documentRid, options) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        documentRid,
+        options
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbDocumentName(debugEntryIndex, documentRid, name, separator) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        documentRid,
+        name,
+        separator
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbSequencePoints(debugEntryIndex, methodRid, sequencePoints) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        methodRid,
+        sequencePoints
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbMethodDocument(debugEntryIndex, methodRid, documentRid) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        methodRid,
+        documentRid
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbImportScope(debugEntryIndex, importScopeRid, options) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        importScopeRid,
+        options
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbLocalScope(debugEntryIndex, localScopeRid, options) {
+      hooks.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 = hooks.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);
+    },
+
+    replaceEmbeddedPortablePdbLocalVariable(debugEntryIndex, localVariableRid, options) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        localVariableRid,
+        options
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbLocalConstant(debugEntryIndex, localConstantRid, options) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        localConstantRid,
+        options
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbCustomDebugInformation(
+      debugEntryIndex,
+      customDebugInformationRid,
+      value
+    ) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        customDebugInformationRid,
+        value
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbSource(debugEntryIndex, documentRid, source, options) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        documentRid,
+        source,
+        options
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    addEmbeddedPortablePdbSource(debugEntryIndex, documentRid, source, options) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        documentRid,
+        source,
+        options
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    removeEmbeddedPortablePdbSource(debugEntryIndex, documentRid) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        documentRid
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    removeEmbeddedPortablePdbCustomDebugInformation(debugEntryIndex, recordRid) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        recordRid
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    replaceEmbeddedPortablePdbSourceLink(debugEntryIndex, sourceLink) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        sourceLink
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    removeEmbeddedPortablePdbSourceLink(debugEntryIndex) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry)
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    },
+
+    addEmbeddedPortablePdbSourceLink(debugEntryIndex, sourceLink) {
+      hooks.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(
+        hooks.getPortablePdbForEdit(debugEntryIndex, entry),
+        sourceLink
+      );
+      return this.replaceEmbeddedPortablePdb(debugEntryIndex, data);
+    }
+  };
+}

package/src/binary/errors.js

@@ -0,0 +1,17 @@
+export class FormatError extends Error {
+  constructor(message, { offset, context } = {}) {
+    const location = Number.isInteger(offset) ? ` at file offset 0x${offset.toString(16)}` : "";
+    const scope = context ? ` (${context})` : "";
+    super(`${message}${location}${scope}`);
+    this.name = "FormatError";
+    this.offset = offset;
+    this.context = context;
+  }
+}
+
+export class UnsupportedFormatError extends FormatError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "UnsupportedFormatError";
+  }
+}

package/src/binary/reader.js

@@ -0,0 +1,206 @@
+import { FormatError } from "./errors.js";
+
+export class BinaryReader {
+  constructor(input, { start = 0, length, baseOffset = 0, context } = {}) {
+    const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+    const available = bytes.byteLength - start;
+    const size = length ?? available;
+    if (!Number.isInteger(start) || !Number.isInteger(size) || start < 0 || size < 0 || size > available) {
+      throw new RangeError("Invalid binary reader range");
+    }
+    this.bytes = bytes.subarray(start, start + size);
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+    this.baseOffset = baseOffset;
+    this.context = context;
+    this.position = 0;
+  }
+
+  get remaining() {
+    return this.bytes.length - this.position;
+  }
+
+  get absoluteOffset() {
+    return this.baseOffset + this.position;
+  }
+
+  ensure(size) {
+    if (!Number.isInteger(size) || size < 0 || size > this.remaining) {
+      throw new FormatError(`Read of ${size} byte(s) exceeds the available ${this.remaining}`, {
+        offset: this.absoluteOffset,
+        context: this.context
+      });
+    }
+  }
+
+  seek(position) {
+    if (!Number.isInteger(position) || position < 0 || position > this.bytes.length) {
+      throw new FormatError(`Invalid seek position ${position}`, {
+        offset: this.baseOffset + Math.max(0, position || 0),
+        context: this.context
+      });
+    }
+    this.position = position;
+  }
+
+  skip(size) {
+    this.ensure(size);
+    this.position += size;
+  }
+
+  align(alignment) {
+    if (!Number.isInteger(alignment) || alignment < 1 || (alignment & (alignment - 1)) !== 0) {
+      throw new RangeError("Alignment must be a positive power of two");
+    }
+    this.skip((-this.position) & (alignment - 1));
+  }
+
+  u1() {
+    this.ensure(1);
+    return this.view.getUint8(this.position++);
+  }
+
+  i1() {
+    this.ensure(1);
+    return this.view.getInt8(this.position++);
+  }
+
+  u2() {
+    this.ensure(2);
+    const value = this.view.getUint16(this.position, true);
+    this.position += 2;
+    return value;
+  }
+
+  i2() {
+    this.ensure(2);
+    const value = this.view.getInt16(this.position, true);
+    this.position += 2;
+    return value;
+  }
+
+  u4() {
+    this.ensure(4);
+    const value = this.view.getUint32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+
+  i4() {
+    this.ensure(4);
+    const value = this.view.getInt32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+
+  u8() {
+    this.ensure(8);
+    const value = this.view.getBigUint64(this.position, true);
+    this.position += 8;
+    return value;
+  }
+
+  f4() {
+    this.ensure(4);
+    const value = this.view.getFloat32(this.position, true);
+    this.position += 4;
+    return value;
+  }
+
+  f8() {
+    this.ensure(8);
+    const value = this.view.getFloat64(this.position, true);
+    this.position += 8;
+    return value;
+  }
+
+  take(size) {
+    this.ensure(size);
+    const result = this.bytes.subarray(this.position, this.position + size);
+    this.position += size;
+    return result;
+  }
+
+  slice(size, context = this.context) {
+    const start = this.position;
+    this.ensure(size);
+    this.position += size;
+    return new BinaryReader(this.bytes, {
+      start,
+      length: size,
+      baseOffset: this.baseOffset + start,
+      context
+    });
+  }
+}
+
+export function readCompressedUInt(reader) {
+  const first = reader.u1();
+  if ((first & 0x80) === 0) return first;
+  const offset = reader.absoluteOffset - 1;
+  let value;
+  if ((first & 0xc0) === 0x80) {
+    value = ((first & 0x3f) << 8) | reader.u1();
+    if (value < 0x80) {
+      throw new FormatError("Non-canonical compressed unsigned integer", {
+        offset,
+        context: reader.context
+      });
+    }
+    return value;
+  }
+  if ((first & 0xe0) === 0xc0) {
+    value = ((first & 0x1f) * 0x1000000) +
+      (reader.u1() << 16) +
+      (reader.u1() << 8) +
+      reader.u1();
+    if (value < 0x4000) {
+      throw new FormatError("Non-canonical compressed unsigned integer", {
+        offset,
+        context: reader.context
+      });
+    }
+    return value;
+  }
+  throw new FormatError("Invalid compressed unsigned integer prefix", {
+    offset,
+    context: reader.context
+  });
+}
+
+export function readCompressedInt(reader) {
+  const first = reader.u1();
+  let encoded;
+  let signOffset;
+  let width;
+  if ((first & 0x80) === 0) {
+    encoded = first;
+    signOffset = 0x40;
+    width = 1;
+  } else if ((first & 0xc0) === 0x80) {
+    encoded = ((first & 0x3f) << 8) | reader.u1();
+    signOffset = 0x2000;
+    width = 2;
+  } else if ((first & 0xe0) === 0xc0) {
+    encoded = (first & 0x1f) * 0x1000000 +
+      reader.u1() * 0x10000 +
+      reader.u1() * 0x100 +
+      reader.u1();
+    signOffset = 0x10000000;
+    width = 4;
+  } else {
+    throw new FormatError("Invalid compressed signed integer prefix", {
+      offset: reader.absoluteOffset - 1,
+      context: reader.context
+    });
+  }
+  const value = Math.floor(encoded / 2);
+  const signedValue = (encoded & 1) === 0 ? value : value - signOffset;
+  if ((width === 2 && signedValue >= -64 && signedValue <= 63) ||
+      (width === 4 && signedValue >= -0x2000 && signedValue <= 0x1fff)) {
+    throw new FormatError("Non-canonical compressed signed integer", {
+      offset: reader.absoluteOffset - width,
+      context: reader.context
+    });
+  }
+  return signedValue;
+}