nitro-patcher 0.2.1 → 1.0.0

package/dist/chunk-LK3JXA24.js

@@ -0,0 +1,2067 @@
+// src/runtime/node.ts
+import { createCipheriv, createHash, createHmac } from "crypto";
+
+// src/runtime/rsa.ts
+import forge from "node-forge";
+var publicKey = forge.pki.rsa.setPublicKey(
+  new forge.jsbn.BigInteger(
+    "956F790DF08BB85A76AAEFA27FE874758BED9EDF9E9A670CD818BEB9B2885203B3FA11AEAA186513B5D6BB85A384D0D0EFB366CBC6051AAA86827AB74311F59C9BFC6C7079D5F17BD0819F522056738C721F40CF2361932590A3C5DC94CFD17A8CBC954A918AA858F4D804BAF7D3C1C4D7B8F077012FA170260B2C049056F3A5",
+    16
+  ),
+  new forge.jsbn.BigInteger("10001", 16)
+);
+var verifyDsiSignature = (data, signature) => publicKey.verify(hashDigest("sha1", data).toString("latin1"), Buffer.from(signature).toString("latin1"), "NONE");
+
+// src/runtime/node.ts
+import { readFile, writeFile } from "fs/promises";
+import { readFileSync } from "fs";
+import { inflateRawSync } from "zlib";
+var hashDigest = (algorithm, data) => createHash(algorithm).update(data).digest();
+var hmacSha1 = (key2, data) => createHmac("sha1", key2).update(data).digest();
+var createAesBlockCipher = (key2) => {
+  const cipher = createCipheriv("aes-128-ecb", key2, null);
+  cipher.setAutoPadding(false);
+  return (block) => cipher.update(block);
+};
+
+// src/nitro/binary.ts
+var DEFAULT_MAX_SIZE = 1073741824;
+var bytes = (value, name = "input") => {
+  if (!(value instanceof Uint8Array)) throw new TypeError(`${name} must be a Buffer or Uint8Array`);
+  return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+};
+var range = (buffer, offset, size, name = "binary data") => {
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(size) || offset < 0 || size < 0 || offset + size > buffer.length) {
+    throw new RangeError(`Invalid ${name} range: offset=${offset}, size=${size}, available=${buffer.length}`);
+  }
+  return buffer.subarray(offset, offset + size);
+};
+var align = (value, alignment = 512) => Math.ceil(value / alignment) * alignment;
+var BinaryWriter = class {
+  maxSize;
+  buffer;
+  position;
+  length;
+  constructor(initialSize = 65536, maxSize = DEFAULT_MAX_SIZE) {
+    if (!Number.isSafeInteger(maxSize) || maxSize < 1 || maxSize > 4294967295)
+      throw new RangeError("Invalid output size limit");
+    this.maxSize = maxSize;
+    this.buffer = Buffer.alloc(Math.min(initialSize, maxSize));
+    this.position = 0;
+    this.length = 0;
+  }
+  ensure(end) {
+    if (!Number.isSafeInteger(end) || end < 0 || end > this.maxSize)
+      throw new RangeError(`Output exceeds size limit (${this.maxSize} bytes)`);
+    if (end <= this.buffer.length) return;
+    const next = Buffer.alloc(Math.min(this.maxSize, Math.max(end, this.buffer.length * 2, 1024)));
+    this.buffer.copy(next, 0, 0, this.length);
+    this.buffer = next;
+  }
+  write(data) {
+    data = bytes(data);
+    if (!Number.isSafeInteger(this.position) || this.position < 0) throw new RangeError("Invalid writer position");
+    this.ensure(this.position + data.length);
+    bytes(data).copy(this.buffer, this.position);
+    this.position += data.length;
+    this.length = Math.max(this.length, this.position);
+  }
+  fillTo(end, fill = 255) {
+    this.ensure(end);
+    if (end <= this.position) return;
+    this.buffer.fill(fill, this.position, end);
+    this.position = end;
+    this.length = Math.max(this.length, end);
+  }
+  pad(alignment, fill = 255) {
+    this.fillTo(align(this.position, alignment), fill);
+  }
+  toBuffer() {
+    return this.buffer.subarray(0, this.length);
+  }
+};
+
+// src/nitro/crc.ts
+var table16 = new Uint16Array(256);
+var table32 = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+  let a = i, b = i;
+  for (let bit = 0; bit < 8; bit++) {
+    a = a >>> 1 ^ (a & 1 ? 40961 : 0);
+    b = b >>> 1 ^ (b & 1 ? 3988292384 : 0);
+  }
+  table16[i] = a;
+  table32[i] = b;
+}
+var crc16 = (data, initial = 65535) => {
+  let crc = initial;
+  for (const byte of data) crc = crc >>> 8 ^ table16[(crc ^ byte) & 255];
+  return crc;
+};
+var crc32 = (data) => {
+  let crc = 4294967295;
+  for (const byte of data) crc = crc >>> 8 ^ table32[(crc ^ byte) & 255];
+  return (crc ^ 4294967295) >>> 0;
+};
+
+// src/nitro/banner.ts
+var titles = [
+  "japaneseTitle",
+  "englishTitle",
+  "frenchTitle",
+  "germanTitle",
+  "italianTitle",
+  "spanishTitle",
+  "chineseTitle",
+  "koreanTitle"
+];
+var Banner = class {
+  version;
+  raw;
+  bannerCRC;
+  tileData;
+  palette;
+  japaneseTitle = "";
+  englishTitle = "";
+  frenchTitle = "";
+  germanTitle = "";
+  italianTitle = "";
+  spanishTitle = "";
+  chineseTitle = "";
+  koreanTitle = "";
+  constructor(input, offset = 0, hardSize = 0) {
+    const data = bytes(input, "banner");
+    this.version = range(data, offset, 2, "banner").readUInt16LE();
+    let size = this.getDefSize(hardSize);
+    if (this.version >>> 8 === 1) size = hardSize > 0 && hardSize !== 4294967295 ? Math.min(hardSize, 9152) : 9152;
+    this.raw = Buffer.from(range(data, offset, size, "banner"));
+    this.bannerCRC = crc16(this.raw.subarray(32, 2112)) === this.raw.readUInt16LE(2);
+    this.tileData = Buffer.from(this.raw.subarray(32, 544));
+    this.palette = Buffer.from(this.raw.subarray(544, 576));
+    for (const [i, title] of titles.entries())
+      this[title] = i < this.titleCount ? this.raw.subarray(576 + i * 256, 832 + i * 256).toString("utf16le").split("\0")[0] : "";
+  }
+  get titleCount() {
+    return this.version >= 3 ? 8 : this.version >= 2 ? 7 : 6;
+  }
+  getDefSize(hardSize = 0) {
+    if (this.version === 2) return 2368;
+    if (this.version === 3) return 2624;
+    if (this.version === 259) return hardSize > 0 && hardSize !== 4294967295 ? hardSize : 9152;
+    return 2112;
+  }
+  toBuffer() {
+    const output = Buffer.from(this.raw);
+    output.writeUInt16LE(this.version);
+    if (this.tileData.length !== 512 || this.palette.length !== 32) throw new RangeError("Invalid banner icon size");
+    this.tileData.copy(output, 32);
+    this.palette.copy(output, 544);
+    for (let i = 0; i < this.titleCount; i++) {
+      const text = Buffer.from(this[titles[i]], "utf16le");
+      if (text.length > 256) throw new RangeError(`Banner ${titles[i]} exceeds 128 UTF-16 code units`);
+      output.fill(0, 576 + i * 256, 832 + i * 256);
+      text.copy(output, 576 + i * 256);
+    }
+    output.writeUInt16LE(crc16(output.subarray(32, 2112)), 2);
+    if (this.version >= 2) output.writeUInt16LE(crc16(output.subarray(32, 2368)), 4);
+    if (this.version >= 3) output.writeUInt16LE(crc16(output.subarray(32, 2624)), 6);
+    if (this.version >>> 8 >= 1) output.writeUInt16LE(crc16(output.subarray(4672, 9152)), 8);
+    return output;
+  }
+};
+
+// src/nitro/crypto.ts
+var KEY1 = Buffer.from(
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
+  "hex"
+);
+var aes128CtrCrypt = (key2, counter, data) => {
+  if (key2.length !== 16 || counter.length !== 16) throw new RangeError("AES key and counter must have 16 bytes");
+  const ctr = Buffer.from(counter).reverse();
+  const aes = createAesBlockCipher(Buffer.from(key2).reverse());
+  const output = Buffer.alloc(data.length);
+  for (let p = 0; p < data.length; p += 16) {
+    const mask = aes(ctr);
+    for (let j = 0; j < 16 && p + j < data.length; j++) output[p + j] = data[p + j] ^ mask[15 - j];
+    for (let j = 15; j >= 0; j--) {
+      ctr[j] = ctr[j] + 1 & 255;
+      if (ctr[j]) break;
+    }
+  }
+  return output;
+};
+var modcryptKey = (header) => {
+  if (typeof header.gameCode !== "string" || header.gameCode.length !== 4)
+    throw new Error("Expected four-character game code");
+  if (header.twlInternalFlags & 4 || (header.appflags?.[3] ?? 0) & 128) {
+    const key2 = Buffer.alloc(16);
+    key2.write(header.gameTitle, 0, 12, "ascii");
+    key2.write(header.gameCode, 12, 4, "ascii");
+    return key2;
+  }
+  if (!header.hmac_arm9i || header.hmac_arm9i.length < 16) throw new Error("Missing ARM9i HMAC for modcrypt key");
+  const x = Buffer.from(`Nintendo${header.gameCode}${[...header.gameCode].reverse().join("")}`, "ascii");
+  for (let i = 0; i < 16; i++) x[i] ^= header.hmac_arm9i[i];
+  const mask = (1n << 128n) - 1n;
+  let v = x.readBigUInt64LE(0) | x.readBigUInt64LE(8) << 64n;
+  v = v + 0xfffefb4e295902582a680f5f1a4f3e79n & mask;
+  v = (v << 42n | v >> 86n) & mask;
+  const out = Buffer.alloc(16);
+  out.writeBigUInt64LE(v & (1n << 64n) - 1n);
+  out.writeBigUInt64LE(v >> 64n, 8);
+  return out;
+};
+var encryptSecureArea = (gameCode, input, refreshCrc = false) => secureAreaCrypt(gameCode, input, false, refreshCrc);
+var decryptSecureArea = (gameCode, input) => secureAreaCrypt(gameCode, input, true);
+var secureAreaCrypt = (gameCode, input, decrypting, refreshCrc = false) => {
+  if (typeof gameCode !== "string" || gameCode.length !== 4) throw new Error("Expected four-character game code");
+  if (input.length < 2048) throw new RangeError("Secure area must contain at least 0x800 bytes");
+  const output = Buffer.from(input);
+  if (refreshCrc) output.writeUInt16LE(crc16(output.subarray(16, 2048)), 14);
+  let magic = new Uint32Array(1042);
+  let args = [0, 0, 0];
+  function crypt(a2, b2, reverse = false) {
+    for (let i = 0; i < 16; i++) {
+      const c = (magic[reverse ? 17 - i : i] ^ a2) >>> 0;
+      const sum = magic[18 + (c >>> 24)] + magic[274 + (c >>> 16 & 255)] >>> 0;
+      const f = magic[786 + (c & 255)] + (magic[530 + (c >>> 8 & 255)] ^ sum) >>> 0;
+      a2 = (b2 ^ f) >>> 0;
+      b2 = c;
+    }
+    return [(b2 ^ magic[reverse ? 0 : 17]) >>> 0, (a2 ^ magic[reverse ? 1 : 16]) >>> 0];
+  }
+  function init2() {
+    [args[2], args[1]] = crypt(args[2], args[1]);
+    [args[1], args[0]] = crypt(args[1], args[0]);
+    const key2 = Buffer.alloc(12);
+    args.forEach((v, i) => key2.writeUInt32LE(v, i * 4));
+    for (let j = 0; j < 18; j++) magic[j] ^= key2.readUInt32BE(j * 4 & 7);
+    let a2 = 0, b2 = 0;
+    for (let i = 0; i < 1042; i += 2) {
+      [a2, b2] = crypt(a2, b2);
+      magic[i] = a2;
+      magic[i + 1] = b2;
+    }
+  }
+  function init1() {
+    magic = Uint32Array.from({ length: 1042 }, (_, i) => KEY1.readUInt32LE(i * 4));
+    const code = Buffer.from(gameCode, "ascii").readUInt32LE();
+    args = [code, code >>> 1, code << 1 >>> 0];
+    init2();
+    init2();
+  }
+  init1();
+  if (decrypting) {
+    const [b2, a2] = crypt(output.readUInt32LE(4), output.readUInt32LE(0), true);
+    output.writeUInt32LE(a2, 0);
+    output.writeUInt32LE(b2, 4);
+  }
+  args[1] = args[1] << 1 >>> 0;
+  args[2] >>>= 1;
+  init2();
+  for (let p = decrypting ? 0 : 8; p < 2048; p += 8) {
+    const [b2, a2] = crypt(output.readUInt32LE(p + 4), output.readUInt32LE(p), decrypting);
+    output.writeUInt32LE(a2, p);
+    output.writeUInt32LE(b2, p + 4);
+  }
+  if (decrypting) {
+    if (output.readUInt32LE(0) !== 1919118949 || output.readUInt32LE(4) !== 1784827769)
+      throw new Error("Invalid KEY1 secure-area marker");
+    output.writeBigUInt64LE(0xe7ffdeffe7ffdeffn);
+    return output;
+  }
+  let [b, a] = crypt(1784827769, 1919118949);
+  init1();
+  [b, a] = crypt(b, a);
+  output.writeUInt32LE(a, 0);
+  output.writeUInt32LE(b, 4);
+  return output;
+};
+
+// src/nitro/filesystem.ts
+import iconv from "iconv-lite";
+var encodeName = (name) => {
+  const encoded = iconv.encode(name, "shift_jis");
+  if (new TextDecoder("shift_jis").decode(encoded) !== name)
+    throw new Error(`FNT name cannot be represented in Shift_JIS: ${name}`);
+  if (!encoded.length || encoded.length > 127) throw new Error("FNT name must contain 1 to 127 encoded bytes");
+  return encoded;
+};
+var FileAllocationTable = class {
+  entries;
+  sortedIDs;
+  constructor(input, offset, size) {
+    const data = bytes(input);
+    const table = range(data, offset, size, "FAT");
+    if (size % 8 || size / 8 > 65535) throw new Error("Invalid FAT entry count");
+    this.entries = [];
+    for (let p = 0; p < size; p += 8) {
+      const start = table.readUInt32LE(p), end = table.readUInt32LE(p + 4);
+      range(data, start, end - start, `FAT entry ${p / 8}`);
+      this.entries.push({ id: p / 8, offset: start, size: end - start });
+    }
+    this.sortedIDs = [...this.entries].sort((a, b) => a.offset - b.offset || a.id - b.id).map((entry) => entry.id);
+  }
+};
+var FileNameTable = class _FileNameTable {
+  root;
+  constructor(fat, input, offset, size) {
+    const table = range(bytes(input), offset, size, "FNT");
+    range(table, 0, 8, "FNT root directory");
+    const count = table.readUInt16LE(6);
+    if (count < 1 || count > 4096) throw new Error("Invalid FNT directory count");
+    range(table, 0, count * 8, "FNT directory table");
+    const decoder = new TextDecoder("shift_jis");
+    const visited = /* @__PURE__ */ new Set();
+    const fileIds = /* @__PURE__ */ new Set();
+    const parse = (index, name, depth) => {
+      if (depth > 256 || index >= count || visited.has(index)) throw new Error("Invalid FNT directory tree or cycle");
+      visited.add(index);
+      let cursor = table.readUInt32LE(index * 8);
+      let fileId = table.readUInt16LE(index * 8 + 4);
+      if (cursor < count * 8) throw new Error("FNT directory names overlap directory table");
+      const folder = {
+        name,
+        id: index === 0 ? 65535 : 61440 + index,
+        files: [],
+        folders: []
+      };
+      const names = /* @__PURE__ */ new Set();
+      while (true) {
+        const tag = range(table, cursor++, 1, "FNT name")[0];
+        if (!tag) break;
+        const length = tag & 127;
+        if (!length) throw new Error("Empty FNT directory name");
+        const nameBytes = Buffer.from(range(table, cursor, length, "FNT filename"));
+        const filename = decoder.decode(nameBytes);
+        cursor += length;
+        if (filename.includes("/") || filename.includes("\\") || filename.includes("\0") || filename === "." || filename === "..")
+          throw new Error("Invalid FNT path component");
+        const normalized = filename.toLowerCase();
+        if (names.has(normalized)) throw new Error(`Duplicate FNT path: ${filename}`);
+        names.add(normalized);
+        if (tag & 128) {
+          const id = range(table, cursor, 2, "FNT directory id").readUInt16LE();
+          cursor += 2;
+          if (id < 61440) throw new Error("Invalid FNT directory id");
+          const child = parse(id & 4095, filename, depth + 1);
+          child.nameBytes = nameBytes;
+          folder.folders.push(child);
+        } else {
+          const entry = fat.entries[fileId++];
+          if (!entry) throw new Error("FNT file id is outside FAT");
+          if (fileIds.has(entry.id)) throw new Error(`Duplicate FNT file id: ${entry.id}`);
+          fileIds.add(entry.id);
+          folder.files.push({ name: filename, nameBytes, ...entry });
+        }
+      }
+      return folder;
+    };
+    this.root = { name: "root", id: 65535, files: [], folders: [parse(0, "data", 0)] };
+  }
+  serialize(fat, overlays) {
+    const directories = [];
+    const named = [];
+    const sort = (items) => [...items].sort((a, b) => Buffer.compare(a.nameBytes ?? encodeName(a.name), b.nameBytes ?? encodeName(b.name)));
+    const visit = (folder, parent) => {
+      const index = directories.length;
+      directories.push({ folder, parent, firstId: named.length });
+      if (directories.length > 4096) throw new Error("FNT directory count exceeds 4096");
+      named.push(...sort(folder.files));
+      for (const child of sort(folder.folders)) visit(child, 61440 + index);
+    };
+    visit(this.root.folders[0], 61440);
+    const namedIds = new Set(named.filter((file) => file.id >= 0).map((file) => file.id));
+    const overlayIds = new Set(overlays.map((file) => file.id));
+    const unnamed = fat.entries.filter((entry) => !namedIds.has(entry.id)).map((entry) => ({ ...entry, name: `FAT entry ${entry.id}` }));
+    const files = [
+      ...unnamed.filter((entry) => overlayIds.has(entry.id)),
+      ...overlays.filter((file) => file.id < 0).sort(
+        (a, b) => Number(a.name.startsWith("overlay7_")) - Number(b.name.startsWith("overlay7_")) || Number(a.name.slice(a.name.indexOf("_") + 1, -4)) - Number(b.name.slice(b.name.indexOf("_") + 1, -4))
+      ),
+      ...unnamed.filter((entry) => !overlayIds.has(entry.id))
+    ];
+    const firstNamed = files.length;
+    files.push(...named);
+    if (files.length > 61440) throw new Error("Filesystem file IDs exceed 0xEFFF");
+    const ids = new Map(files.map((file, id) => [file, id]));
+    const sourceIds = new Map(files.filter((file) => file.id >= 0).map((file) => [file.id, ids.get(file)]));
+    const directoryIds = new Map(directories.map(({ folder }, index) => [folder, 61440 + index]));
+    const writer = new BinaryWriter();
+    writer.write(Buffer.alloc(directories.length * 8));
+    for (const [index, { folder, parent, firstId }] of directories.entries()) {
+      const record = Buffer.alloc(8);
+      record.writeUInt32LE(writer.position);
+      record.writeUInt16LE(firstNamed + firstId, 4);
+      record.writeUInt16LE(index === 0 ? directories.length : parent, 6);
+      record.copy(writer.buffer, index * 8);
+      for (const file of sort(folder.files)) {
+        const name = file.nameBytes ?? encodeName(file.name);
+        writer.write(Buffer.from([name.length]));
+        writer.write(name);
+      }
+      for (const child of sort(folder.folders)) {
+        const name = child.nameBytes ?? encodeName(child.name);
+        writer.write(Buffer.from([128 | name.length]));
+        writer.write(name);
+        const id = Buffer.alloc(2);
+        id.writeUInt16LE(directoryIds.get(child));
+        writer.write(id);
+      }
+      writer.write(Buffer.from([0]));
+    }
+    return { fnt: writer.toBuffer(), files, ids, sourceIds };
+  }
+  static findFile(id, folder) {
+    for (const file of folder.files) if (file.id === id) return file;
+    for (const subfolder of folder.folders) {
+      const file = _FileNameTable.findFile(id, subfolder);
+      if (file) return file;
+    }
+    return void 0;
+  }
+};
+var overlayFields = [
+  "overlayId",
+  "ramAddress",
+  "ramSize",
+  "bssSize",
+  "staticInitialiserStartAddress",
+  "staticInitialiserEndAddress",
+  "fileId",
+  "reserved"
+];
+var OverlayTable = class {
+  constructor(input, offset, size, isArm9) {
+    this.isArm9 = isArm9;
+    if (!size) return;
+    const table = range(bytes(input), offset, size, "overlay table");
+    if (size % 32) throw new Error("Invalid overlay table size");
+    for (let p = 0; p < size; p += 32) {
+      if (table.readUInt32LE(p) === 4294967295) break;
+      this.entries.push({
+        overlayId: table.readUInt32LE(p),
+        ramAddress: table.readUInt32LE(p + 4),
+        ramSize: table.readUInt32LE(p + 8),
+        bssSize: table.readUInt32LE(p + 12),
+        staticInitialiserStartAddress: table.readUInt32LE(p + 16),
+        staticInitialiserEndAddress: table.readUInt32LE(p + 20),
+        fileId: table.readUInt32LE(p + 24),
+        reserved: table.readUInt32LE(p + 28)
+      });
+    }
+  }
+  isArm9;
+  entries = [];
+  readBasicOverlays(fat) {
+    return this.entries.map((item) => {
+      const file = fat.entries[item.fileId];
+      if (!file) throw new Error("Overlay file id is outside FAT");
+      return {
+        ...file,
+        name: `overlay${this.isArm9 ? "" : "7"}_${String(item.overlayId).padStart(4, "0")}.bin`
+      };
+    });
+  }
+  toBuffer() {
+    const data = Buffer.alloc(this.entries.length * 32);
+    this.entries.forEach(
+      (entry, i) => overlayFields.forEach((field2, j) => data.writeUInt32LE(entry[field2], i * 32 + j * 4))
+    );
+    return data;
+  }
+};
+
+// src/nitro/header.ts
+var UnitCode = Object.freeze({ NDS: 0, NDS_DSi: 2, DSi: 3 });
+var Header = class {
+  raw;
+  trimmedRom;
+  doublePadding;
+  nitrocode;
+  decrypted;
+  headerCRC;
+  logoCRC;
+  secureCRC;
+  dlp_signature;
+  constructor(input) {
+    const data = bytes(input, "header");
+    range(data, 0, 368, "header");
+    const size = data.readUInt32LE(132);
+    if (size < 368 || size > data.length) throw new RangeError(`Invalid header size: ${size}`);
+    this.raw = Buffer.from(data.subarray(0, size));
+    if (this.unitCode & 2 && size > 512) range(this.raw, 0, 4096, "DSi header");
+    this.trimmedRom = this.total_rom_size ? this.total_rom_size >= data.length : data.length !== this.size;
+    this.doublePadding = this.ARM9size % 1024 < 512 && this.ARM7romOffset % 1024 === 0 && this.ARM9overlayOffset % 1024 === 0 || this.ARM7size % 1024 < 512 && this.FNToffset % 1024 === 0 && this.ARM7overlayOffset % 1024 === 0 || this.FNTsize % 1024 < 512 && this.FAToffset % 1024 === 0 || this.FATsize % 1024 < 512 && this.bannerOffset % 1024 === 0;
+    const nitroOffset = this.ARM9romOffset + this.ARM9size;
+    this.nitrocode = nitroOffset >= size && nitroOffset + 4 <= data.length && data.readUInt32LE(nitroOffset) === 3737126433;
+    this.decrypted = data.length >= 16392 && data.readBigUInt64LE(16384) === 0xe7ffdeffe7ffdeffn;
+    this.headerCRC = crc16(this.raw.subarray(0, 350)) === this.headerCRC16;
+    this.logoCRC = crc16(this.logo) === this.logoCRC16;
+    const secure = data.subarray(16384, 32768);
+    this.secureCRC = secure.length > 0 && crc16(this.decrypted ? encryptSecureArea(this.gameCode, secure) : secure) === this.secureCRC16;
+    this.dlp_signature = Buffer.alloc(0);
+    if (this.ROMsize >= size && this.ROMsize + 136 <= data.length && data.readUInt32LE(this.ROMsize) === 90977) {
+      this.dlp_signature = Buffer.from(data.subarray(this.ROMsize, this.ROMsize + 136));
+    }
+  }
+  get size() {
+    return 2 ** (17 + this.raw[20]);
+  }
+  set size(value) {
+    const power = Math.log2(value);
+    if (!Number.isInteger(power) || power < 17 || power > 32)
+      throw new RangeError("ROM capacity must be a power of two from 128 KiB to 4 GiB");
+    this.raw[20] = power - 17;
+  }
+  toBuffer() {
+    const data = Buffer.from(this.raw);
+    data.writeUInt16LE(crc16(data.subarray(192, 348)), 348);
+    data.writeUInt16LE(crc16(data.subarray(0, 350)), 350);
+    return data;
+  }
+  toString() {
+    return `NDS header: ${this.gameTitle.replace(/\0+$/, "")} (${this.gameCode})`;
+  }
+};
+function field(name, offset, length, type = "buffer", dsi = false) {
+  Object.defineProperty(Header.prototype, name, {
+    enumerable: true,
+    get() {
+      if (dsi && (!(this.unitCode & 2) || this.raw.length <= 512))
+        return type === "buffer" ? Buffer.alloc(length) : 0;
+      const data = range(this.raw, offset, length, `header ${name}`);
+      if (type === "string") return data.toString("latin1");
+      if (type === "buffer") return data;
+      return length === 8 ? data.readBigUInt64LE() : data.readUIntLE(0, length);
+    },
+    set(value) {
+      const target = range(this.raw, offset, length, `header ${name}`);
+      if (type === "string") {
+        if (typeof value !== "string" || Buffer.byteLength(value, "latin1") > length)
+          throw new TypeError(`Invalid ${name}`);
+        target.fill(0);
+        target.write(value, "latin1");
+      } else if (type === "buffer") {
+        if (!(value instanceof Uint8Array)) throw new TypeError(`Invalid ${name}`);
+        const source = bytes(value, name);
+        if (source.length !== length) throw new RangeError(`${name} must contain ${length} bytes`);
+        source.copy(target);
+      } else if (length === 8) {
+        if (typeof value !== "bigint") throw new TypeError(`Invalid ${name}`);
+        target.writeBigUInt64LE(value);
+      } else {
+        if (typeof value !== "number") throw new TypeError(`Invalid ${name}`);
+        target.writeUIntLE(value, 0, length);
+      }
+    }
+  });
+}
+field("gameTitle", 0, 12, "string");
+field("gameCode", 12, 4, "string");
+field("makerCode", 16, 2, "string");
+for (const [name, offset] of Object.entries({
+  unitCode: 18,
+  encryptionSeed: 19,
+  twlInternalFlags: 28,
+  permitsFlags: 29,
+  ROMversion: 30,
+  internalFlags: 31
+}))
+  field(name, offset, 1, "number");
+field("reserved", 21, 7);
+var ntr32 = "ARM9romOffset ARM9entryAddress ARM9ramAddress ARM9size ARM7romOffset ARM7entryAddress ARM7ramAddress ARM7size FNToffset FNTsize FAToffset FATsize ARM9overlayOffset ARM9overlaySize ARM7overlayOffset ARM7overlaySize flagsRead flagsInit bannerOffset".split(
+  " "
+);
+ntr32.forEach((name, i) => field(name, 32 + i * 4, 4, "number"));
+field("secureCRC16", 108, 2, "number");
+field("ROMtimeout", 110, 2, "number");
+field("ARM9autoload", 112, 4, "number");
+field("ARM7autoload", 116, 4, "number");
+field("secureDisable", 120, 8, "number");
+field("ROMsize", 128, 4, "number");
+field("headerSize", 132, 4, "number");
+field("reserved2", 136, 56);
+field("ntr_region_end", 144, 2, "number");
+field("twl_region_start", 146, 2, "number");
+field("logo", 192, 156);
+field("logoCRC16", 348, 2, "number");
+field("headerCRC16", 350, 2, "number");
+"debug_romOffset debug_size debug_ramAddress reserved3".split(" ").forEach((name, i) => field(name, 352 + i * 4, 4, "number"));
+field("appflags", 444, 4, "buffer", true);
+"mbk9_wramcnt_setting region_flags access_control scfg_ext_mask".split(" ").forEach((name, i) => field(name, 428 + i * 4, 4, "number", true));
+var twl32 = "dsi9_rom_offset offset_0x1C4 dsi9_ram_address dsi9_size dsi7_rom_offset offset_0x1D4 dsi7_ram_address dsi7_size digest_ntr_start digest_ntr_size digest_twl_start digest_twl_size sector_hashtable_start sector_hashtable_size block_hashtable_start block_hashtable_size digest_sector_size digest_block_sectorcount banner_size offset_0x20C total_rom_size offset_0x214 offset_0x218 offset_0x21C modcrypt1_start modcrypt1_size modcrypt2_start modcrypt2_size tid_low tid_high public_sav_size private_sav_size".split(
+  " "
+);
+twl32.forEach((name, i) => field(name, 448 + i * 4, 4, "number", true));
+"hmac_arm9 hmac_arm7 hmac_digest_master hmac_icon_title hmac_arm9i hmac_arm7i".split(" ").forEach((name, i) => field(name, 768 + i * 20, 20, "buffer", true));
+field("hmac_arm9_no_secure", 928, 20, "buffer", true);
+field("rsa_signature", 3968, 128, "buffer", true);
+
+// src/nitro/blz.ts
+var decompressBLZ = (input, maxSize = 268435456) => {
+  if (input.length < 8) throw new Error("BLZ footer is truncated");
+  const diff = input.readUInt32LE(input.length - 4);
+  const packed = input.readUInt32LE(input.length - 8), header = packed >>> 24, length = packed & 16777215;
+  const size = input.length + diff, prefix = input.length - length;
+  if (header < 8 || header > length || length > input.length || size > maxSize)
+    throw new Error("Invalid BLZ size or footer");
+  const out = Buffer.alloc(size);
+  input.copy(out, 0, 0, prefix);
+  let src = input.length - header, dst = size;
+  while (src > prefix) {
+    const flags = input[--src];
+    for (let bit = 128; bit && src > prefix; bit >>= 1) {
+      if (!(flags & bit)) {
+        if (dst <= prefix) throw new Error("BLZ output overflow");
+        out[--dst] = input[--src];
+      } else {
+        if (src - 2 < prefix) throw new Error("Truncated BLZ reference");
+        const high = input[--src], low = input[--src];
+        const count = (high >>> 4) + 3, offset = ((high & 15) << 8 | low) + 3;
+        if (dst - count < prefix || dst - 1 + offset >= size) throw new Error("Invalid BLZ reference");
+        for (let j = 0; j < count; j++) {
+          --dst;
+          out[dst] = out[dst + offset];
+        }
+      }
+    }
+  }
+  if (dst !== prefix) throw new Error("BLZ decompressed size mismatch");
+  return out;
+};
+var compressBLZ = (input) => {
+  if (input.length > 16777215) throw new Error("BLZ input exceeds 24-bit format limit");
+  const temp = Buffer.alloc(input.length);
+  let src = input.length, dst = input.length;
+  const heads = new Int32Array(256).fill(-1);
+  const next = new Int32Array(input.length);
+  let indexedFrom = input.length;
+  while (src > 0) {
+    if (dst < 1) return Buffer.alloc(0);
+    const flagPos = --dst;
+    let flags = 0;
+    for (let bit = 0; bit < 8; bit++) {
+      flags <<= 1;
+      if (!src) continue;
+      while (indexedFrom > src) {
+        const p = --indexedFrom;
+        next[p] = heads[input[p]];
+        heads[input[p]] = p;
+      }
+      const maxCount = Math.min(src, 18);
+      let best = 0, offset = 0;
+      for (let p = heads[input[src - 1]]; p >= 0; p = next[p]) {
+        const d = p - src + 1;
+        if (d > 4098) break;
+        let n = 0;
+        const limit = Math.min(d, maxCount);
+        while (n < limit && input[src - 1 - n] === input[src + d - 1 - n]) n++;
+        if (n > best) {
+          best = n;
+          offset = d;
+          if (best === maxCount) break;
+        }
+      }
+      if (best < 3) {
+        if (dst < 1) return Buffer.alloc(0);
+        temp[--dst] = input[--src];
+      } else {
+        if (dst < 2) return Buffer.alloc(0);
+        src -= best;
+        dst -= 2;
+        temp[dst] = offset - 3 & 255;
+        temp[dst + 1] = best - 3 << 4 | offset - 3 >>> 8;
+        flags |= 1;
+      }
+    }
+    temp[flagPos] = flags;
+  }
+  let packed = temp.subarray(dst), sourcePos = input.length, compressedPos = packed.length, prefix = 0, skip = 0;
+  outer: while (sourcePos > 0) {
+    const flags = packed[--compressedPos];
+    for (let bit = 128; bit && sourcePos > 0; bit >>= 1) {
+      if (!(flags & bit)) {
+        compressedPos--;
+        sourcePos--;
+      } else {
+        sourcePos -= (packed[compressedPos - 1] >>> 4) + 3;
+        compressedPos -= 2;
+        if (sourcePos < compressedPos) {
+          prefix = sourcePos;
+          skip = compressedPos;
+          break outer;
+        }
+      }
+    }
+  }
+  packed = Buffer.concat([input.subarray(0, prefix), packed.subarray(skip)]);
+  const aligned = Math.ceil(packed.length / 4) * 4, finalSize = aligned + 8;
+  if (finalSize >= input.length) return Buffer.alloc(0);
+  const out = Buffer.alloc(finalSize, 255);
+  packed.copy(out);
+  const header = finalSize - packed.length, length = packed.length - prefix + header;
+  out.writeUInt32LE((header << 24 | length) >>> 0, finalSize - 8);
+  out.writeUInt32LE(input.length - finalSize, finalSize - 4);
+  return out;
+};
+var decompressArm9 = (data, header, maxSize = 268435456) => {
+  if (data.length < 24) throw new Error("ARM9 data too short");
+  if (data.length > maxSize) throw new RangeError("ARM9 exceeds output size limit");
+  const nitro = header.nitrocode ?? data.readUInt32LE(12) === 3737126433 ? 12 : 0;
+  const init = header.reserved2.readUInt32LE(0) & 16383;
+  const ptr = init ? data.readUInt32LE(init + 20) : header.ARM9ramAddress + header.ARM9size;
+  const compressed = ptr > header.ARM9ramAddress && ptr + nitro >= header.ARM9ramAddress + data.length;
+  return {
+    compressed,
+    data: compressed ? Buffer.concat([
+      decompressBLZ(data.subarray(0, data.length - nitro), maxSize - nitro),
+      data.subarray(data.length - nitro)
+    ]) : Buffer.from(data)
+  };
+};
+var compressArm9 = (data, header, postSize = 0) => {
+  if (data.length < 16384) throw new Error("ARM9 secure area is truncated");
+  const nitro = header.nitrocode ?? data.readUInt32LE(12) === 3737126433 ? 12 : 0;
+  const packed = compressBLZ(data.subarray(16384, data.length - nitro));
+  if (!packed.length) throw new Error("ARM9 BLZ compression produced no smaller representation");
+  const out = Buffer.concat([data.subarray(0, 16384), packed, data.subarray(data.length - nitro)]);
+  const init = header.reserved2.readUInt32LE(0) & 16383;
+  if (init) out.writeUInt32LE(out.length - postSize + header.ARM9ramAddress, init + 20);
+  return out;
+};
+
+// src/nitro/twl-complete.ts
+var hash = (data) => hmacSha1(HMAC_SHA1_KEY, data);
+var check = (valid) => ({ status: valid ? "valid" : "invalid" });
+var absent = (reason) => ({ status: "not-applicable", reason });
+var fields = {
+  arm9: ["ARM9romOffset", "ARM9size", "hmac_arm9"],
+  arm7: ["ARM7romOffset", "ARM7size", "hmac_arm7"],
+  arm9i: ["dsi9_rom_offset", "dsi9_size", "hmac_arm9i"],
+  arm7i: ["dsi7_rom_offset", "dsi7_size", "hmac_arm7i"]
+};
+var digestFields = [
+  "digest_ntr_start",
+  "digest_ntr_size",
+  "digest_twl_start",
+  "digest_twl_size",
+  "sector_hashtable_start",
+  "sector_hashtable_size",
+  "block_hashtable_start",
+  "block_hashtable_size",
+  "digest_sector_size",
+  "digest_block_sectorcount"
+];
+var noDsiVerification = () => Object.fromEntries(
+  ["arm9", "arm7", "arm9i", "arm7i", "arm9NoSecure", "banner", "sectors", "blocks", "master", "signature"].map(
+    (name) => [name, absent("Not a DSi-enhanced cartridge")]
+  )
+);
+var CompleteTWL = class {
+  header;
+  programs;
+  regions;
+  hasDigests;
+  Hashtable1Data;
+  Hashtable2Data;
+  Header2Data;
+  Overlays9Sha1Hmac;
+  twlEncrypted;
+  firstDSiHashOffset;
+  dsiHashSize;
+  original;
+  limit;
+  constructor(header, overlays, original, limit) {
+    if (header.unitCode !== 2) throw new Error("Complete DSi processing requires a DSi-enhanced cartridge");
+    if (header.tid_high && header.tid_high !== 196608)
+      throw new Error("DSiWare and non-cartridge titles are unsupported");
+    this.header = new Header(header.raw);
+    this.header.decrypted = header.decrypted;
+    this.header.nitrocode = header.nitrocode;
+    this.original = original;
+    this.limit = limit;
+    this.hasDigests = digestFields.some((name) => header[name] !== 0);
+    this.validateDigests(header, original);
+    if (header.sector_hashtable_size > limit || header.block_hashtable_size > limit)
+      throw new RangeError("DSi digest table exceeds output size limit");
+    for (const name of ["dsi9_ram_address", "dsi7_ram_address"])
+      if (!header[name] || header[name] === 4294967295) throw new Error(`Missing DSi program load address: ${name}`);
+    this.Hashtable1Data = Buffer.from(
+      range(original, header.sector_hashtable_start, header.sector_hashtable_size, "DSi sector table")
+    );
+    this.Hashtable2Data = Buffer.from(
+      range(original, header.block_hashtable_start, header.block_hashtable_size, "DSi block table")
+    );
+    this.firstDSiHashOffset = this.hasDigests ? header.digest_ntr_size / header.digest_sector_size * 20 : 0;
+    this.dsiHashSize = this.hasDigests ? header.digest_twl_size / header.digest_sector_size * 20 : 0;
+    this.programs = new Map(
+      Object.entries(fields).map(([name, [offset, size]]) => {
+        const start = header[offset];
+        const length = header[size];
+        if (length && !start) throw new Error(`Missing ${name} ROM offset`);
+        if (align(length, 16) > limit) throw new RangeError(`${name} exceeds output size limit`);
+        const data = Buffer.from(range(original, start, length ? align(length, 16) : 0, name));
+        return [
+          name,
+          { name, start, length, data, original: data, replaced: false }
+        ];
+      })
+    );
+    const ordered = [...this.programs.values()].filter((program) => program.length).sort((a, b) => a.start - b.start);
+    for (let index = 1; index < ordered.length; index++)
+      if (ordered[index - 1].start + ordered[index - 1].data.length > ordered[index].start)
+        throw new Error("DSi program regions overlap");
+    this.regions = [];
+    for (const id of [1, 2]) {
+      const start = header[`modcrypt${id}_start`];
+      const length = header[`modcrypt${id}_size`];
+      if (!start && !length) continue;
+      if (!start || !length || length % 16) throw new Error(`Invalid Modcrypt region ${id}`);
+      const candidates = ordered.filter(
+        (program2) => start >= program2.start && start + length <= program2.start + program2.data.length
+      );
+      if (candidates.length !== 1)
+        throw new Error(`Modcrypt region ${id} conflicts with program ranges: ${start}..${start + length}`);
+      const program = candidates[0];
+      if (program.name === "arm9" || program.name === "arm7")
+        throw new Error(`Modcrypt region ${id} targets ${program.name}; dual-mode cartridge startup is unsupported`);
+      const offset = start - program.start;
+      this.regions.push({
+        id,
+        program: program.name,
+        offset,
+        length,
+        kind: offset === 0 && length === program.data.length ? "whole" : offset === 0 && program.name === "arm9i" && length === Math.min(16384, program.data.length) ? "secure" : "fixed"
+      });
+    }
+    this.twlEncrypted = !!(header.twlInternalFlags & 2);
+    this.decryptPrograms();
+    for (const program of this.programs.values()) program.original = Buffer.from(program.data);
+    const boundary = header.twl_region_start * 524288;
+    const first = Math.min(...ordered.filter((program) => program.name.endsWith("i")).map((program) => program.start));
+    const prefixEnd = boundary + 12288;
+    this.Header2Data = boundary && prefixEnd <= original.length && (Number.isFinite(first) && first >= prefixEnd || header.digest_twl_size && header.digest_twl_start >= prefixEnd || header.total_rom_size >= prefixEnd) ? Array.from(
+      { length: 3 },
+      (_, index) => Buffer.from(range(original, boundary + index * 4096, 4096, "TWL unreadable region"))
+    ) : [];
+    this.Overlays9Sha1Hmac = overlays.map(hash);
+  }
+  validateDigests(h, original) {
+    if (!this.hasDigests) return;
+    const s = h.digest_sector_size;
+    const b = h.digest_block_sectorcount;
+    if (!Number.isSafeInteger(s) || s <= 0 || s > 16384 || 16384 % s)
+      throw new Error("Invalid DSi digest sector size");
+    if (!b || b > 1048576) throw new Error("Invalid DSi digest block sector count");
+    if (!h.digest_ntr_start || h.digest_ntr_size < 16384 || h.digest_ntr_size % s || h.digest_twl_size % s || h.digest_twl_size && !h.digest_twl_start)
+      throw new Error("Incomplete DSi digest regions");
+    const count = (h.digest_ntr_size + h.digest_twl_size) / s;
+    if (!h.sector_hashtable_start || !h.block_hashtable_start || !h.sector_hashtable_size || h.sector_hashtable_size % (b * 20) || h.sector_hashtable_size < count * 20 || h.block_hashtable_size !== h.sector_hashtable_size / b)
+      throw new Error("Incomplete or invalid DSi digest tables");
+    for (const [start, size, label] of [
+      [h.digest_ntr_start, h.digest_ntr_size, "NTR digest region"],
+      [h.digest_twl_start, h.digest_twl_size, "TWL digest region"],
+      [h.sector_hashtable_start, h.sector_hashtable_size, "DSi sector table"],
+      [h.block_hashtable_start, h.block_hashtable_size, "DSi block table"]
+    ])
+      range(original, start, size, label);
+    if (h.digest_ntr_start + h.digest_ntr_size > h.sector_hashtable_start || h.sector_hashtable_start + h.sector_hashtable_size > h.block_hashtable_start || h.digest_twl_size && h.block_hashtable_start + h.block_hashtable_size > h.digest_twl_start)
+      throw new Error("DSi digest regions overlap");
+  }
+  decryptPrograms() {
+    if (!this.regions.length) return;
+    const h = this.header;
+    const key2 = modcryptKey(h);
+    const solutions = [];
+    const programs = [...this.programs.values()];
+    for (let mask = 0; mask < 2 ** this.regions.length; mask++) {
+      const views = programs.map((program) => Buffer.from(program.data));
+      for (let index = this.regions.length - 1; index >= 0; index--) {
+        if (!(mask & 1 << index)) continue;
+        const region = this.regions[index];
+        const data = views[programs.findIndex((program) => program.name === region.program)];
+        aes128CtrCrypt(
+          key2,
+          (region.id === 1 ? h.hmac_arm9 : h.hmac_arm7).subarray(0, 16),
+          data.subarray(region.offset, region.offset + region.length)
+        ).copy(data, region.offset);
+      }
+      const accepted = [...new Set(this.regions.map((region) => region.program))].every((name) => {
+        const index = programs.findIndex((program2) => program2.name === name);
+        const program = programs[index];
+        if (hash(views[index].subarray(0, program.length)).equals(h[fields[name][2]])) return true;
+        if (!this.hasDigests) return false;
+        const relevant = this.regions.filter((region) => region.program === name);
+        return relevant.every((region) => {
+          const address = program.start + region.offset;
+          const base = address >= h.digest_twl_start && address < h.digest_twl_start + h.digest_twl_size ? h.digest_twl_start : h.digest_ntr_start;
+          const length = base === h.digest_twl_start ? h.digest_twl_size : h.digest_ntr_size;
+          if (address < base || address >= base + length) return false;
+          const first = base + Math.floor((address - base) / h.digest_sector_size) * h.digest_sector_size;
+          const last = Math.min(base + length, align(address + region.length, h.digest_sector_size));
+          for (let sector = first; sector < last; sector += h.digest_sector_size) {
+            const bytes2 = Buffer.from(range(this.original, sector, h.digest_sector_size, "Modcrypt evidence sector"));
+            for (const [p, view] of programs.map((program2, i) => [program2, views[i]])) {
+              const start = Math.max(sector, p.start), end = Math.min(sector + bytes2.length, p.start + view.length);
+              if (end > start) view.copy(bytes2, start - sector, start - p.start, end - p.start);
+            }
+            const digest = ((base === h.digest_twl_start ? h.digest_ntr_size : 0) + sector - base) / h.digest_sector_size * 20;
+            if (hash(bytes2).equals(range(this.Hashtable1Data, digest, 20, "Modcrypt evidence hash"))) return true;
+          }
+          return false;
+        });
+      });
+      if (accepted && !solutions.some((solution) => solution.every((data, index) => data.equals(views[index]))))
+        solutions.push(views);
+    }
+    if (solutions.length !== 1)
+      throw new Error(
+        `Cannot determine Modcrypt state for regions ${this.regions.map((region) => region.id).join(", ")}`
+      );
+    programs.forEach((program, index) => {
+      program.data = solutions[0][index];
+    });
+  }
+  get DSi9Data() {
+    return this.getProgram("arm9i");
+  }
+  set DSi9Data(data) {
+    this.setProgram("arm9i", data);
+  }
+  get DSi7Data() {
+    return this.getProgram("arm7i");
+  }
+  set DSi7Data(data) {
+    this.setProgram("arm7i", data);
+  }
+  getProgram(name) {
+    const program = this.programs.get(name);
+    return program.data.subarray(0, program.length);
+  }
+  setProgram(name, data) {
+    if (align(data.length, 16) > this.limit) throw new RangeError(`${name} exceeds output size limit`);
+    const program = this.programs.get(name);
+    const stored = Buffer.alloc(align(data.length, 16), 255);
+    if (program.length === data.length) program.data.copy(stored);
+    data.copy(stored);
+    program.data = stored;
+    program.length = data.length;
+    program.replaced = true;
+  }
+  importArm9iData(data, offset = 0, size) {
+    const input = typeof data === "string" ? readFileSync(data) : data;
+    this.setProgram("arm9i", range(input, offset, size ?? input.length - offset, "ARM9i import"));
+  }
+  importArm7iData(data, offset = 0, size) {
+    const input = typeof data === "string" ? readFileSync(data) : data;
+    this.setProgram("arm7i", range(input, offset, size ?? input.length - offset, "ARM7i import"));
+  }
+  unchanged() {
+    return [...this.programs.values()].every(
+      (program) => !(program.replaced && !program.length) && program.length === this.header[fields[program.name][1]] && program.data.equals(program.original)
+    );
+  }
+  updateOverlays9Sha1Hmac(arm9, h, overlays) {
+    if (overlays.length !== this.Overlays9Sha1Hmac.length)
+      throw new Error("Changing signed ARM9 overlay count is unsupported");
+    const hashes = overlays.map(hash);
+    if (hashes.every((value, index) => value.equals(this.Overlays9Sha1Hmac[index]))) return arm9;
+    const unpacked = decompressArm9(arm9, h, this.limit);
+    const oldSequence = Buffer.concat(this.Overlays9Sha1Hmac);
+    const newSequence = Buffer.concat(hashes);
+    const matches = [];
+    for (const [sequence, current] of [
+      [oldSequence, false],
+      [newSequence, true]
+    ])
+      for (let position = unpacked.data.indexOf(sequence, 16384); position >= 0; position = unpacked.data.indexOf(sequence, position + 1))
+        matches.push({ position, current });
+    if (matches.length !== 1) throw new Error("ARM9 overlay HMAC table cannot be uniquely located");
+    if (matches[0].current) return arm9;
+    newSequence.copy(unpacked.data, matches[0].position);
+    if (!unpacked.compressed) return unpacked.data;
+    const init = h.reserved2.readUInt32LE(0) & 16383;
+    const end = init ? arm9.readUInt32LE(init + 20) - h.ARM9ramAddress : arm9.length;
+    return compressArm9(unpacked.data, h, arm9.length - end);
+  }
+  view(data, h, start, length, programs = this.programs) {
+    const output = Buffer.from(range(data, start, length, "DSi digest input"));
+    for (const program of programs.values()) {
+      const [offset, size] = fields[program.name];
+      const address = h[offset];
+      const limit = program.name === "arm9" ? h[size] : align(h[size], 16);
+      const from = Math.max(start, address), to = Math.min(start + length, address + limit);
+      if (to <= from) continue;
+      let source = program.data;
+      if (program.name === "arm9" && h.decrypted) source = encryptSecureArea(h.gameCode, source, true);
+      source.copy(output, from - start, from - address, to - address);
+    }
+    return output;
+  }
+  verify(data = this.original, h = this.header) {
+    const programCheck = (name) => {
+      const program = this.programs.get(name);
+      if (!program.length) return absent("Program has zero logical length");
+      const input = name === "arm9" && h.decrypted ? encryptSecureArea(h.gameCode, program.data, true) : program.data;
+      return check(hash(input.subarray(0, program.length)).equals(h[fields[name][2]]));
+    };
+    const result = {
+      arm9: programCheck("arm9"),
+      arm7: programCheck("arm7"),
+      arm9i: programCheck("arm9i"),
+      arm7i: programCheck("arm7i"),
+      arm9NoSecure: h.ARM9size >= 16384 ? check(hash(this.getProgram("arm9").subarray(16384)).equals(h.hmac_arm9_no_secure)) : absent("ARM9 has no complete secure area"),
+      banner: check(hash(range(data, h.bannerOffset, h.banner_size, "DSi banner")).equals(h.hmac_icon_title)),
+      sectors: absent("Digest tables omitted"),
+      blocks: absent("Digest tables omitted"),
+      master: absent("Digest tables omitted"),
+      signature: h.rsa_signature.every((value) => value === 0) ? absent("Signature omitted") : check(verifyDsiSignature(range(data, 0, 3584, "Signed DSi header"), h.rsa_signature))
+    };
+    if (this.hasDigests) {
+      let valid = true, index = 0;
+      for (const [start, size] of [
+        [h.digest_ntr_start, h.digest_ntr_size],
+        [h.digest_twl_start, h.digest_twl_size]
+      ])
+        for (let position = start; position < start + size; position += h.digest_sector_size)
+          valid = hash(this.view(data, h, position, h.digest_sector_size)).equals(
+            range(data, h.sector_hashtable_start + index++ * 20, 20, "DSi sector digest")
+          ) && valid;
+      result.sectors = check(valid);
+      valid = true;
+      for (let offset = 0; offset < h.sector_hashtable_size; offset += h.digest_block_sectorcount * 20)
+        valid = hash(
+          range(data, h.sector_hashtable_start + offset, h.digest_block_sectorcount * 20, "DSi sector block")
+        ).equals(
+          range(data, h.block_hashtable_start + offset / h.digest_block_sectorcount, 20, "DSi block digest")
+        ) && valid;
+      result.blocks = check(valid);
+      result.master = check(
+        hash(range(data, h.block_hashtable_start, h.block_hashtable_size, "DSi master input")).equals(
+          h.hmac_digest_master
+        )
+      );
+    }
+    return result;
+  }
+  serialize(h, sections, forceLayout) {
+    const originalHeader = this.header;
+    const dsiPrograms = [this.programs.get("arm9i"), this.programs.get("arm7i")];
+    const originalEnd = Math.max(
+      originalHeader.ROMsize,
+      originalHeader.total_rom_size,
+      originalHeader.dsi9_rom_offset + align(originalHeader.dsi9_size, 16),
+      originalHeader.dsi7_rom_offset + align(originalHeader.dsi7_size, 16),
+      originalHeader.digest_twl_start + originalHeader.digest_twl_size
+    );
+    const ntrLimit = this.hasDigests ? originalHeader.digest_ntr_start + originalHeader.digest_ntr_size : originalHeader.twl_region_start * 524288 || Math.min(...dsiPrograms.filter((program) => program.length).map((program) => program.start));
+    const ordered = sections.filter((section) => section.originalSize || section.data.length).sort((a, b) => a.start - b.start);
+    let preserve = !forceLayout && ordered.every((section, index) => {
+      const next = ordered[index + 1]?.start ?? ntrLimit;
+      if (section.start < h.headerSize || section.start + section.originalSize > next || section.start + section.data.length > next)
+        return false;
+      const extra = this.original.subarray(section.start + section.originalSize, section.start + section.data.length);
+      return extra.every((value) => value === 0) || extra.every((value) => value === 255);
+    });
+    const originalDsi = [...dsiPrograms].filter((program) => originalHeader[fields[program.name][1]]).sort((a, b) => a.start - b.start);
+    for (const [index, program] of originalDsi.entries()) {
+      const next = originalDsi[index + 1]?.start ?? originalEnd;
+      if (program.start + program.data.length > next) preserve = false;
+      const extra = this.original.subarray(
+        program.start + align(originalHeader[fields[program.name][1]], 16),
+        program.start + program.data.length
+      );
+      if (!(extra.every((value) => value === 0) || extra.every((value) => value === 255))) preserve = false;
+    }
+    if (dsiPrograms.some((program) => program.length && !originalHeader[fields[program.name][1]])) preserve = false;
+    let ntrEnd;
+    let end;
+    let boundary = originalHeader.twl_region_start * 524288;
+    if (preserve) {
+      for (const section of sections) section.place(section.start);
+      ntrEnd = originalHeader.ROMsize;
+      end = originalEnd;
+    } else {
+      this.checkMovableTwl(boundary, originalDsi, originalEnd);
+      let position = Math.max(h.headerSize, 16384);
+      for (const section of sections) {
+        section.start = position;
+        section.place(position);
+        position = align(position + section.data.length, 512);
+      }
+      const ntrDataEnd = position;
+      if (this.hasDigests) {
+        const s = h.digest_sector_size;
+        h.digest_ntr_start = h.ARM9romOffset;
+        h.digest_ntr_size = align(ntrDataEnd - h.digest_ntr_start, s);
+        h.sector_hashtable_start = align(h.digest_ntr_start + h.digest_ntr_size, 512);
+      }
+      let twlLength = 0;
+      for (const program of dsiPrograms) if (program.length) twlLength = align(twlLength, 1024) + program.data.length;
+      if (this.hasDigests) {
+        h.digest_twl_size = twlLength ? align(twlLength, h.digest_sector_size) : 0;
+        const count = (h.digest_ntr_size + h.digest_twl_size) / h.digest_sector_size;
+        h.sector_hashtable_size = align(count * 20, h.digest_block_sectorcount * 20);
+        h.block_hashtable_start = align(h.sector_hashtable_start + h.sector_hashtable_size, 512);
+        h.block_hashtable_size = h.sector_hashtable_size / h.digest_block_sectorcount;
+        ntrEnd = h.block_hashtable_start + h.block_hashtable_size;
+      } else ntrEnd = ntrDataEnd;
+      const originalBoundary = originalHeader.twl_region_start * 524288;
+      const boundaryAlignment = originalBoundary ? Math.max(524288, originalBoundary & -originalBoundary) : 524288;
+      boundary = align(ntrEnd, boundaryAlignment);
+      position = boundary + 12288;
+      let first = 0;
+      for (const program of dsiPrograms) {
+        const [offset] = fields[program.name];
+        if (!program.length) {
+          h[offset] = 0;
+          continue;
+        }
+        position = align(position, 1024);
+        h[offset] = position;
+        first ||= position;
+        position += program.data.length;
+      }
+      if (this.hasDigests) h.digest_twl_start = first;
+      end = this.hasDigests && first ? first + h.digest_twl_size : position;
+    }
+    h.size = Math.max(originalHeader.size, 2 ** Math.ceil(Math.log2(Math.max(end, 131072))));
+    if (h.size > this.limit) throw new RangeError("Output exceeds size limit");
+    const writer = new BinaryWriter(h.size, this.limit);
+    writer.fillTo(h.size);
+    if (preserve) this.original.copy(writer.buffer);
+    else {
+      range(this.original, 0, Math.max(h.headerSize, 16384), "DSi original header area").copy(writer.buffer);
+      if (this.hasDigests) {
+        const originalGap = this.original.subarray(
+          originalHeader.sector_hashtable_start + originalHeader.sector_hashtable_size,
+          originalHeader.block_hashtable_start
+        );
+        if (originalGap.length && originalGap.every((value) => value === 0))
+          writer.buffer.fill(0, h.sector_hashtable_start + h.sector_hashtable_size, h.block_hashtable_start);
+      }
+    }
+    for (const section of sections) {
+      writer.position = section.start;
+      writer.write(section.data);
+      if (preserve && section.data.length < section.originalSize) {
+        writer.fillTo(section.start + section.originalSize);
+      }
+    }
+    for (const program of dsiPrograms) {
+      const [offset, size, mac] = fields[program.name];
+      h[size] = program.length;
+      if (!program.length && program.replaced) {
+        h[offset] = 0;
+        h[mac] = Buffer.alloc(20);
+        if (preserve && originalHeader[size]) {
+          writer.position = originalHeader[offset];
+          writer.fillTo(originalHeader[offset] + align(originalHeader[size], 16));
+        }
+      }
+      if (program.length) {
+        writer.position = h[offset];
+        writer.write(program.data);
+        const oldSize = originalHeader[size];
+        if (preserve && align(oldSize, 16) > program.data.length) writer.fillTo(h[offset] + align(oldSize, 16));
+      }
+    }
+    const outputPrograms = new Map([...this.programs].map(([name, program]) => [name, { ...program }]));
+    for (const name of ["arm9", "arm7"]) {
+      const program = outputPrograms.get(name);
+      const [offset, size] = fields[name];
+      program.data = Buffer.from(range(writer.buffer, h[offset], h[size], name));
+      program.length = h[size];
+    }
+    for (const program of outputPrograms.values()) {
+      if (!program.length) continue;
+      const data = program.name === "arm9" && h.decrypted ? encryptSecureArea(h.gameCode, program.data, true) : program.data;
+      h[fields[program.name][2]] = hash(data.subarray(0, program.length));
+    }
+    h.hmac_arm9_no_secure = hash(outputPrograms.get("arm9").data.subarray(16384));
+    h.hmac_icon_title = hash(range(writer.buffer, h.bannerOffset, h.banner_size, "DSi output banner"));
+    if (this.hasDigests) {
+      range(writer.buffer, h.sector_hashtable_start, h.sector_hashtable_size, "DSi output sector table").fill(0);
+      range(writer.buffer, h.block_hashtable_start, h.block_hashtable_size, "DSi output block table").fill(0);
+      let index = 0;
+      for (const [start, size] of [
+        [h.digest_ntr_start, h.digest_ntr_size],
+        [h.digest_twl_start, h.digest_twl_size]
+      ])
+        for (let position = start; position < start + size; position += h.digest_sector_size)
+          hash(this.view(writer.buffer, h, position, h.digest_sector_size, outputPrograms)).copy(
+            writer.buffer,
+            h.sector_hashtable_start + index++ * 20
+          );
+      for (let offset = 0; offset < h.sector_hashtable_size; offset += h.digest_block_sectorcount * 20)
+        hash(
+          range(
+            writer.buffer,
+            h.sector_hashtable_start + offset,
+            h.digest_block_sectorcount * 20,
+            "DSi output sector block"
+          )
+        ).copy(writer.buffer, h.block_hashtable_start + offset / h.digest_block_sectorcount);
+      h.hmac_digest_master = hash(
+        range(writer.buffer, h.block_hashtable_start, h.block_hashtable_size, "DSi output master input")
+      );
+    }
+    const key2 = this.regions.length ? modcryptKey(h) : Buffer.alloc(0);
+    for (const region of this.regions) {
+      const program = this.programs.get(region.program);
+      const size = !program.length ? 0 : region.kind === "whole" ? program.data.length : region.kind === "secure" ? Math.min(16384, program.data.length) : region.length;
+      if (size && region.offset + size > program.data.length)
+        throw new Error(`Modcrypt region ${region.id} exceeds ${program.name} after replacement`);
+      const start = size ? h[fields[program.name][0]] + region.offset : 0;
+      h[`modcrypt${region.id}_start`] = start;
+      h[`modcrypt${region.id}_size`] = size;
+      if (size && h.twlInternalFlags & 2) {
+        const input = range(writer.buffer, start, size, `Output Modcrypt region ${region.id}`);
+        aes128CtrCrypt(key2, (region.id === 1 ? h.hmac_arm9 : h.hmac_arm7).subarray(0, 16), input).copy(
+          writer.buffer,
+          start
+        );
+      }
+    }
+    h.ROMsize = ntrEnd;
+    h.total_rom_size = end;
+    h.ntr_region_end = boundary / 524288;
+    h.twl_region_start = boundary / 524288;
+    h.size = Math.max(originalHeader.size, 2 ** Math.ceil(Math.log2(Math.max(end, 131072))));
+    const secure = range(writer.buffer, h.ARM9romOffset, 16384, "DSi secure area");
+    h.secureCRC16 = crc16(h.decrypted ? encryptSecureArea(h.gameCode, secure, true) : secure);
+    h.rsa_signature = originalHeader.rsa_signature;
+    writer.position = 0;
+    writer.write(h.toBuffer());
+    const originalMirror = range(this.original, 32768, 4096, "Original cartridge mirror");
+    for (let start = 4096; start < 16384; start += 4096)
+      if (range(this.original, start, 4096, "NTR unreadable region").equals(originalMirror))
+        range(writer.buffer, 32768, 4096, "Updated cartridge mirror").copy(writer.buffer, start);
+    if (this.Header2Data.length) {
+      for (const [index, data] of this.Header2Data.entries()) {
+        writer.position = boundary + index * 4096;
+        writer.write(
+          data.equals(originalMirror) ? range(writer.buffer, 32768, 4096, "Updated cartridge mirror") : data
+        );
+      }
+    }
+    return writer.toBuffer();
+  }
+  checkMovableTwl(boundary, programs, end) {
+    let position = boundary + this.Header2Data.length * 4096;
+    for (const program of programs) {
+      if (program.start < position) throw new Error("TWL input regions overlap");
+      const gap = range(this.original, position, program.start - position, "TWL preserved bytes");
+      const padding = gap;
+      if (padding.length && !(padding.every((value) => value === 0) || padding.every((value) => value === 255)))
+        throw new Error("TWL contains unrecognized bytes whose relocation is unsupported");
+      position = program.start + align(this.header[fields[program.name][1]], 16);
+    }
+    const tail = range(this.original, position, end - position, "TWL preserved tail");
+    if (tail.length && !(tail.every((value) => value === 0) || tail.every((value) => value === 255)))
+      throw new Error("TWL contains unrecognized trailing data whose relocation is unsupported");
+  }
+};
+
+// src/nitro/twl.ts
+var HMAC_SHA1_KEY = Buffer.from(
+  "2106c0deba98ce3fa692e39d46f2ed0176e3cc08562363facad4ecdf9a6278348f6d633cfe22ca9220889723d2cfaec232678dfeca836498acfd3e3787465824",
+  "hex"
+);
+var hash2 = (data) => hmacSha1(HMAC_SHA1_KEY, data);
+function slice(data, start, size, label) {
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(size) || start < 0 || size < 0 || start + size > data.length)
+    throw new RangeError(`${label} outside data range`);
+  return data.subarray(start, start + size);
+}
+function validate(h) {
+  for (const field2 of [
+    "digest_ntr_start",
+    "digest_ntr_size",
+    "digest_twl_start",
+    "digest_twl_size",
+    "sector_hashtable_start",
+    "sector_hashtable_size",
+    "block_hashtable_start",
+    "block_hashtable_size",
+    "dsi9_rom_offset",
+    "dsi9_size",
+    "dsi7_rom_offset",
+    "dsi7_size",
+    "modcrypt1_start",
+    "modcrypt1_size",
+    "modcrypt2_start",
+    "modcrypt2_size",
+    "total_rom_size"
+  ]) {
+    if (!Number.isSafeInteger(h[field2]) || h[field2] < 0 || h[field2] > 4294967295) {
+      throw new Error(`Invalid TWL ${field2}`);
+    }
+  }
+  const s = h.digest_sector_size;
+  if (!Number.isSafeInteger(s) || s <= 0 || s > 16384 || 16384 % s) throw new Error("Invalid TWL digest sector size");
+  if (!Number.isSafeInteger(h.digest_block_sectorcount) || h.digest_block_sectorcount <= 0 || h.digest_block_sectorcount > 1048576)
+    throw new Error("Invalid TWL digest block sector count");
+  if (h.digest_ntr_size < 16384 || h.digest_ntr_size % s || h.digest_twl_size % s)
+    throw new Error("Invalid TWL digest region size");
+  const hashes = (h.digest_ntr_size + h.digest_twl_size) / s;
+  if (hashes * 20 > h.sector_hashtable_size || Math.ceil(h.sector_hashtable_size / (h.digest_block_sectorcount * 20)) * 20 > h.block_hashtable_size)
+    throw new Error("TWL hash tables are too small");
+}
+var TWL = class {
+  firstDSiHashOffset;
+  dsiHashSize;
+  Hashtable1Data;
+  Hashtable2Data;
+  Header2Data;
+  Overlays9Sha1Hmac;
+  twlEncrypted;
+  complete;
+  dsi9Data = Buffer.alloc(0);
+  dsi7Data = Buffer.alloc(0);
+  get DSi9Data() {
+    return this.complete?.DSi9Data ?? this.dsi9Data;
+  }
+  set DSi9Data(data) {
+    if (this.complete) this.complete.DSi9Data = data;
+    else this.dsi9Data = data;
+  }
+  get DSi7Data() {
+    return this.complete?.DSi7Data ?? this.dsi7Data;
+  }
+  set DSi7Data(data) {
+    if (this.complete) this.complete.DSi7Data = data;
+    else this.dsi7Data = data;
+  }
+  constructor(header, overlays, original, options = {}) {
+    if (options.dsiMode === "complete") {
+      if (!(header instanceof Header)) throw new TypeError("Complete DSi handling requires a parsed Header");
+      this.complete = new CompleteTWL(
+        header,
+        overlays.map((overlay) => slice(original, overlay.offset, overlay.size, "Signed ARM9 overlay")),
+        original,
+        options.maxOutputSize ?? DEFAULT_MAX_SIZE
+      );
+      this.firstDSiHashOffset = this.complete.firstDSiHashOffset;
+      this.dsiHashSize = this.complete.dsiHashSize;
+      this.Hashtable1Data = this.complete.Hashtable1Data;
+      this.Hashtable2Data = this.complete.Hashtable2Data;
+      this.Header2Data = this.complete.Header2Data;
+      this.Overlays9Sha1Hmac = this.complete.Overlays9Sha1Hmac;
+      this.twlEncrypted = this.complete.twlEncrypted;
+      return;
+    }
+    validate(header);
+    const h = header;
+    this.firstDSiHashOffset = h.digest_ntr_size / h.digest_sector_size * 20;
+    this.dsiHashSize = h.digest_twl_size / h.digest_sector_size * 20;
+    this.Hashtable1Data = Buffer.from(
+      slice(original, h.sector_hashtable_start, h.sector_hashtable_size, "Sector hash table")
+    );
+    this.Hashtable2Data = Buffer.from(
+      slice(original, h.block_hashtable_start, h.block_hashtable_size, "Block hash table")
+    );
+    this.DSi9Data = Buffer.from(slice(original, h.dsi9_rom_offset, Math.max(h.modcrypt1_size, h.dsi9_size), "ARM9i"));
+    this.DSi7Data = Buffer.from(slice(original, h.dsi7_rom_offset, Math.max(h.modcrypt2_size, h.dsi7_size), "ARM7i"));
+    this.Header2Data = h.trimmedRom ? null : Array.from(
+      { length: 3 },
+      (_, i) => Buffer.from(slice(original, h.digest_twl_start - 12288 + 4096 * i, 4096, "Secondary header"))
+    );
+    this.Overlays9Sha1Hmac = overlays.map((o) => hash2(slice(original, o.offset, o.size, "ARM9 overlay")));
+    let encrypted = false;
+    const modcryptStart = [
+      { start: h.modcrypt1_start, size: h.modcrypt1_size },
+      { start: h.modcrypt2_start, size: h.modcrypt2_size }
+    ].find(({ start, size }) => size > 0 && start >= h.digest_twl_start && start < 4294967295)?.start;
+    if (modcryptStart !== void 0) {
+      const index = Math.floor((modcryptStart - h.digest_twl_start) / h.digest_sector_size);
+      const actual = hash2(
+        slice(original, h.digest_twl_start + index * h.digest_sector_size, h.digest_sector_size, "Modcrypt sector")
+      );
+      encrypted = !actual.equals(
+        slice(this.Hashtable1Data, this.firstDSiHashOffset + index * 20, 20, "Modcrypt sector hash")
+      );
+    }
+    if (encrypted) this.cryptSections(h);
+    this.twlEncrypted = !!(h.twlInternalFlags & 2);
+  }
+  cryptSections(h, writer) {
+    const key2 = modcryptKey(h);
+    for (const [id, data, start, counter] of [
+      [1, this.DSi9Data, h.dsi9_rom_offset, h.hmac_arm9],
+      [2, this.DSi7Data, h.dsi7_rom_offset, h.hmac_arm7]
+    ]) {
+      const size = h[`modcrypt${id}_size`];
+      if (!size) continue;
+      const off = h[`modcrypt${id}_start`] - start;
+      const result = aes128CtrCrypt(
+        key2,
+        slice(counter, 0, 16, "Modcrypt counter"),
+        slice(data, off, size, "Modcrypt payload")
+      );
+      if (writer) {
+        writer.position = start + off;
+        writer.write(result);
+      } else result.copy(data, off);
+    }
+  }
+  importArm9iData(data, offset = 0, size) {
+    if (this.complete) return this.complete.importArm9iData(data, offset, size);
+    this.DSi9Data = this.importData(data, offset, size);
+  }
+  importArm7iData(data, offset = 0, size) {
+    if (this.complete) return this.complete.importArm7iData(data, offset, size);
+    this.DSi7Data = this.importData(data, offset, size);
+  }
+  importData(data, offset, size) {
+    if (typeof data === "string") data = readFileSync(data);
+    size ??= data.length - offset;
+    const src = slice(data, offset, size, "DSi import");
+    const out = Buffer.alloc(Math.ceil(size / 16) * 16, 255);
+    src.copy(out);
+    return out;
+  }
+  updateOverlays9Sha1Hmac(arm9Data, header, overlays) {
+    if (this.complete) return this.complete.updateOverlays9Sha1Hmac(arm9Data, header, overlays);
+    if (overlays.length !== this.Overlays9Sha1Hmac.length)
+      throw new Error("Changing ARM9 overlay count is unsupported");
+    const hashes = overlays.map(hash2);
+    if (hashes.every((h, i) => h.equals(this.Overlays9Sha1Hmac[i]))) return Buffer.from(arm9Data);
+    const init = header.reserved2.readUInt32LE(0) & 16383;
+    const hdrptr = arm9Data.readUInt32LE(init + 20) - header.ARM9ramAddress;
+    const unpacked = decompressArm9(arm9Data, header);
+    const end = unpacked.data.readUInt32LE(init + 8) - header.ARM9ramAddress;
+    let found = -1;
+    for (let p = Math.min(end - hashes.length * 20, unpacked.data.length - hashes.length * 20); p >= 0; p--) {
+      if (unpacked.data.subarray(p, p + 20).equals(this.Overlays9Sha1Hmac[0])) {
+        found = p;
+        break;
+      }
+    }
+    if (found < 0) throw new Error("ARM9 overlay hashes changed but original hash table was not found");
+    hashes.forEach((h, i) => h.copy(unpacked.data, found + i * 20));
+    return unpacked.compressed ? compressArm9(unpacked.data, header, arm9Data.length - hdrptr) : unpacked.data;
+  }
+  writeTo(writer, h) {
+    if (this.complete) throw new Error("Complete DSi serialization requires NDSFile.toBuffer()");
+    validate(h);
+    if (writer.position > h.sector_hashtable_start) {
+      throw new Error("NTR output overlaps the fixed DSi sector hash table");
+    }
+    if (h.sector_hashtable_start + h.sector_hashtable_size > h.block_hashtable_start || h.block_hashtable_start + h.block_hashtable_size > h.dsi9_rom_offset || h.dsi9_rom_offset + this.DSi9Data.length > h.dsi7_rom_offset || h.dsi7_rom_offset + this.DSi7Data.length > h.total_rom_size) {
+      throw new Error("DSi sections overlap or exceed the ROM size");
+    }
+    const fill = (end) => {
+      if (writer.position < end) writer.fillTo(end, 255);
+    };
+    fill(h.sector_hashtable_start);
+    writer.position = h.sector_hashtable_start + h.sector_hashtable_size;
+    fill(h.block_hashtable_start);
+    writer.position = h.block_hashtable_start + h.block_hashtable_size;
+    fill(h.dsi9_rom_offset);
+    if (this.Header2Data && !h.trimmedRom) {
+      writer.position = h.digest_twl_start - 12288;
+      this.Header2Data.forEach((b) => writer.write(b));
+    }
+    writer.position = h.dsi9_rom_offset;
+    writer.write(this.DSi9Data);
+    fill(h.dsi7_rom_offset);
+    writer.position = h.dsi7_rom_offset;
+    writer.write(this.DSi7Data);
+    fill(h.total_rom_size);
+    const finalPosition = writer.position;
+    const read = (p, n) => slice(writer.buffer.subarray(0, writer.length), p, n, "TWL output digest");
+    let secure = Buffer.from(read(h.digest_ntr_start, 16384));
+    if (h.decrypted) secure = encryptSecureArea(h.gameCode, secure);
+    let index = 0;
+    const put = (b) => {
+      writer.position = h.sector_hashtable_start + index++ * 20;
+      writer.write(hash2(b));
+    };
+    for (let p = 0; p < 16384; p += h.digest_sector_size) put(secure.subarray(p, p + h.digest_sector_size));
+    for (let p = h.digest_ntr_start + 16384; p < h.digest_ntr_start + h.digest_ntr_size; p += h.digest_sector_size)
+      put(read(p, h.digest_sector_size));
+    for (let p = h.digest_twl_start; p < h.digest_twl_start + h.digest_twl_size; p += h.digest_sector_size)
+      put(read(p, h.digest_sector_size));
+    index = 0;
+    for (let p = h.sector_hashtable_start; p < h.sector_hashtable_start + h.sector_hashtable_size; p += h.digest_block_sectorcount * 20) {
+      const digest = hash2(read(p, h.digest_block_sectorcount * 20));
+      writer.position = h.block_hashtable_start + index++ * 20;
+      writer.write(digest);
+    }
+    h.hmac_digest_master = hash2(read(h.block_hashtable_start, h.block_hashtable_size));
+    if (this.twlEncrypted) this.cryptSections(h, writer);
+    writer.position = finalPosition;
+    return h.hmac_digest_master;
+  }
+};
+var updateHeaderSignatures = (writer, header, originalHeader, _keepOriginal = true) => {
+  const signedData = Buffer.from(slice(originalHeader, 0, 3584, "Signed header"));
+  const digest = slice(header.hmac_digest_master, 0, 20, "Master digest");
+  const signature = slice(header.rsa_signature, 0, 128, "RSA signature");
+  digest.copy(signedData, 808);
+  verifyDsiSignature(signedData, signature);
+  const position = writer.position;
+  writer.position = 808;
+  writer.write(digest);
+  writer.position = 3968;
+  writer.write(signature);
+  writer.position = position;
+};
+
+// src/nitro/nds-file.ts
+var key = (path) => path.replaceAll("\\", "/").toLowerCase();
+var NDSFile = class _NDSFile {
+  original;
+  header;
+  banner;
+  fatTable;
+  fntTable;
+  overlay9Table;
+  overlay7Table;
+  root;
+  twl;
+  warnings = [];
+  paths = /* @__PURE__ */ new Map();
+  maxOutputSize;
+  addedOverlays = /* @__PURE__ */ new Map();
+  structureChanged = false;
+  constructor(input, options = {}) {
+    this.original = bytes(input, "ROM");
+    this.maxOutputSize = options.maxOutputSize ?? DEFAULT_MAX_SIZE;
+    if (!Number.isSafeInteger(this.maxOutputSize) || this.maxOutputSize < 1 || this.maxOutputSize > 4294967295)
+      throw new RangeError("Invalid output size limit");
+    this.header = new Header(this.original);
+    const h = this.header;
+    if (options.dsiMode === "complete" && h.unitCode === 3)
+      throw new Error("DSi-exclusive cartridges and DSiWare are unsupported");
+    range(this.original, h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0), "ARM9");
+    range(this.original, h.ARM7romOffset, h.ARM7size, "ARM7");
+    this.banner = new Banner(this.original, h.bannerOffset, h.banner_size);
+    this.fatTable = new FileAllocationTable(this.original, h.FAToffset, h.FATsize);
+    this.fntTable = new FileNameTable(this.fatTable, this.original, h.FNToffset, h.FNTsize);
+    this.root = this.fntTable.root;
+    this.overlay9Table = new OverlayTable(this.original, h.ARM9overlayOffset, h.ARM9overlaySize, true);
+    this.overlay7Table = new OverlayTable(this.original, h.ARM7overlayOffset, h.ARM7overlaySize, false);
+    const arm9Overlays = this.overlay9Table.readBasicOverlays(this.fatTable);
+    this.root.folders.push({
+      name: "overlay",
+      id: 65535,
+      files: [...arm9Overlays, ...this.overlay7Table.readBasicOverlays(this.fatTable)],
+      folders: []
+    });
+    const system = (name, offset, size) => {
+      range(this.original, offset, size, name);
+      this.root.files.push({ name, id: 65535, offset, size });
+    };
+    system("header.bin", 0, h.headerSize);
+    system("banner.bin", h.bannerOffset, this.banner.raw.length);
+    system("fnt.bin", h.FNToffset, h.FNTsize);
+    system("fat.bin", h.FAToffset, h.FATsize);
+    system("arm9.bin", h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0));
+    system("arm7.bin", h.ARM7romOffset, h.ARM7size);
+    if (h.ARM9overlaySize) system("overarm9.bin", h.ARM9overlayOffset, h.ARM9overlaySize);
+    if (h.ARM7overlaySize) system("overarm7.bin", h.ARM7overlayOffset, h.ARM7overlaySize);
+    const visit = (folder, prefix) => {
+      for (const file of folder.files) {
+        const path = prefix + file.name;
+        if (this.paths.has(key(path))) throw new Error(`Duplicate ROM path: ${path}`);
+        this.paths.set(key(path), { path, file });
+      }
+      for (const child of folder.folders) visit(child, `${prefix + child.name}/`);
+    };
+    visit(this.root, "");
+    if (options.dsiMode === "complete" && h.unitCode & 2) {
+      const regions = [
+        ...this.root.files.map((file) => ({ start: file.offset, size: file.size, name: file.name })),
+        ...this.fatTable.entries.map((file) => ({
+          start: file.offset,
+          size: file.size,
+          name: `FAT ${file.id}`,
+          payload: true
+        })),
+        { start: h.dsi9_rom_offset, size: h.dsi9_size, name: "ARM9i" },
+        { start: h.dsi7_rom_offset, size: h.dsi7_size, name: "ARM7i" },
+        { start: h.sector_hashtable_start, size: h.sector_hashtable_size, name: "DSi sector table" },
+        { start: h.block_hashtable_start, size: h.block_hashtable_size, name: "DSi block table" }
+      ].filter((region) => region.size).sort((a, b) => a.start - b.start);
+      let systemEnd;
+      let payloadEnd;
+      for (const region of regions) {
+        range(this.original, region.start, region.size, region.name);
+        for (const previous of [systemEnd, region.payload ? void 0 : payloadEnd])
+          if (previous && previous.start + previous.size > region.start)
+            throw new Error(`DSi ROM regions overlap: ${previous.name} and ${region.name}`);
+        if (region.payload) {
+          if (!payloadEnd || region.start + region.size > payloadEnd.start + payloadEnd.size) payloadEnd = region;
+        } else systemEnd = region;
+      }
+      this.twl = new TWL(
+        h,
+        this.overlay9Table.entries.filter((entry) => entry.reserved & 33554432).map((entry) => {
+          const file = this.fatTable.entries[entry.fileId];
+          return { offset: file.offset, size: file.size };
+        }),
+        this.original,
+        { dsiMode: "complete", maxOutputSize: this.maxOutputSize }
+      );
+      for (const [name, offset, size] of [
+        ["arm9i.bin", h.dsi9_rom_offset, h.dsi9_size],
+        ["arm7i.bin", h.dsi7_rom_offset, h.dsi7_size]
+      ]) {
+        const file = { name, id: 65535, offset, size };
+        this.root.files.push(file);
+        this.paths.set(name, { path: name, file });
+      }
+    } else if (h.unitCode & 2 && h.twlInternalFlags & 1 && h.tid_high && h.tid_high !== 4294967295) {
+      this.twl = new TWL(h, arm9Overlays, this.original);
+    }
+  }
+  static async fromFile(path, options = {}) {
+    return new _NDSFile(await readFile(path), options);
+  }
+  get data() {
+    return this.root.folders[0];
+  }
+  get overlay() {
+    return this.root.folders[1];
+  }
+  listFiles() {
+    return [...this.paths.values()].map(({ path, file }) => ({
+      path,
+      id: file.id,
+      offset: file.offset,
+      size: this.twl?.complete && (path === "arm9i.bin" || path === "arm7i.bin") ? this.twl.complete.getProgram(path === "arm9i.bin" ? "arm9i" : "arm7i").length : this.addedOverlays.size && (path === "overarm9.bin" || path === "overarm7.bin") ? this.readOverlayTable(path === "overarm9.bin").entries.length * 32 : file.replacement?.length ?? file.size
+    }));
+  }
+  hasFile(path) {
+    return this.paths.has(key(path));
+  }
+  getFile(path) {
+    const entry = this.paths.get(key(path));
+    if (!entry) throw new Error(`ROM file not found: ${path}`);
+    return Buffer.from(this.fileBytes(entry.file));
+  }
+  /** Replace an existing file. */
+  replaceFile(path, content) {
+    let entry = this.paths.get(key(path));
+    if (!entry && (key(path) === "overarm9.bin" || key(path) === "overarm7.bin")) {
+      if (content.byteLength > this.maxOutputSize) throw new RangeError("Replacement exceeds output size limit");
+      new OverlayTable(content, 0, content.byteLength, key(path) === "overarm9.bin");
+      const file = { name: key(path), id: 65535, offset: 0, size: 0 };
+      entry = { path: file.name, file };
+      this.root.files.push(file);
+      this.paths.set(file.name, entry);
+      this.structureChanged = true;
+    }
+    if (!entry) throw new Error(`ROM file not found: ${path}`);
+    if (this.twl?.complete && content.byteLength > this.maxOutputSize)
+      throw new RangeError("Replacement exceeds output size limit");
+    if (this.twl?.complete && (key(path) === "arm9i.bin" || key(path) === "arm7i.bin")) {
+      this.twl.complete.setProgram(key(path) === "arm9i.bin" ? "arm9i" : "arm7i", bytes(content));
+      return;
+    }
+    entry.file.replacement = Buffer.from(bytes(content));
+  }
+  /** Add a NitroFS file and any missing parent directories. */
+  addFile(path, content) {
+    const components = path.replaceAll("\\", "/").split("/");
+    if (components[0]?.toLowerCase() !== "data" || components.length < 2 || components.slice(1).some((name) => !name || name === "." || name === ".." || name.includes("\0")))
+      throw new Error(`Invalid NitroFS path: ${path}`);
+    if (components.length > 258) throw new Error("FNT directory depth exceeds 256");
+    if (this.hasFile(path)) throw new Error(`ROM file already exists: ${path}`);
+    const replacement = Buffer.from(bytes(content));
+    const names = components.slice(1).map((name) => ({ name }));
+    let existing = this.data;
+    for (const [index, component] of names.entries()) {
+      const normalized = component.name.toLowerCase();
+      if (existing?.files.some((file) => file.name.toLowerCase() === normalized))
+        throw new Error(`ROM path conflicts with a file: ${path}`);
+      const child = existing?.folders.find((child2) => child2.name.toLowerCase() === normalized);
+      if (index === names.length - 1 && child) throw new Error(`ROM path conflicts with a directory: ${path}`);
+      if (!child) component.nameBytes = encodeName(component.name);
+      existing = child;
+    }
+    let folder = this.data;
+    let prefix = "data";
+    for (const [index, component] of names.entries()) {
+      const normalized = component.name.toLowerCase();
+      const child = folder.folders.find((child2) => child2.name.toLowerCase() === normalized);
+      if (index === names.length - 1) {
+        const file = { ...component, id: -1, offset: -1, size: replacement.length, replacement };
+        folder.files.push(file);
+        const outputPath = `${prefix}/${file.name}`;
+        this.paths.set(key(outputPath), { path: outputPath, file });
+      } else {
+        if (child) folder = child;
+        else {
+          const created = { ...component, id: -1, files: [], folders: [] };
+          folder.folders.push(created);
+          folder = created;
+        }
+        prefix += `/${folder.name}`;
+      }
+    }
+    this.structureChanged = true;
+  }
+  /** Add an overlay; file IDs are assigned when the ROM is serialized. */
+  addOverlay(arm9, metadata, content) {
+    const path = `overlay/overlay${arm9 ? "" : "7"}_${String(metadata.overlayId).padStart(4, "0")}.bin`;
+    if (!Number.isSafeInteger(metadata.overlayId) || metadata.overlayId < 0 || metadata.overlayId >= 4294967295)
+      throw new RangeError("Invalid overlay ID");
+    if (this.hasFile(path)) throw new Error(`ROM file already exists: ${path}`);
+    if (content.byteLength > this.maxOutputSize) throw new RangeError("Overlay exceeds output size limit");
+    const entry = { ...metadata, fileId: 0 };
+    const table = new OverlayTable(Buffer.alloc(0), 0, 0, arm9);
+    table.entries.push(entry);
+    table.toBuffer();
+    const replacement = Buffer.from(bytes(content));
+    const file = { name: path.slice(8), id: -1, offset: -1, size: replacement.length, replacement };
+    const tableName = arm9 ? "overarm9.bin" : "overarm7.bin";
+    if (!this.hasFile(tableName)) this.replaceFile(tableName, Buffer.alloc(0));
+    this.overlay.files.push(file);
+    this.paths.set(path, { path, file });
+    this.addedOverlays.set(path, { arm9, entry });
+    this.structureChanged = true;
+  }
+  readOverlayTable(arm9) {
+    const original = arm9 ? this.overlay9Table : this.overlay7Table;
+    const replacement = this.paths.get(arm9 ? "overarm9.bin" : "overarm7.bin")?.file.replacement;
+    const raw = replacement ?? original.toBuffer();
+    const table = new OverlayTable(raw, 0, raw.length, arm9);
+    for (const { arm9: target, entry } of this.addedOverlays.values()) {
+      if (target !== arm9) continue;
+      const existing = table.entries.find((item) => item.overlayId === entry.overlayId);
+      if (existing) Object.assign(existing, entry);
+      else table.entries.push({ ...entry });
+    }
+    const ids = /* @__PURE__ */ new Set();
+    for (const entry of table.entries) {
+      if (ids.has(entry.overlayId)) throw new Error(`Duplicate overlay ID: ${entry.overlayId}`);
+      ids.add(entry.overlayId);
+      const path = `overlay/overlay${arm9 ? "" : "7"}_${String(entry.overlayId).padStart(4, "0")}.bin`;
+      if (!this.hasFile(path)) throw new Error(`Overlay table entry has no payload: ${path}`);
+    }
+    if (original.entries.some((entry) => !ids.has(entry.overlayId)))
+      throw new Error("Removing overlays is unsupported");
+    return table;
+  }
+  fileBytes(file) {
+    if (this.twl?.complete && (file.name === "arm9i.bin" || file.name === "arm7i.bin"))
+      return this.twl.complete.getProgram(file.name === "arm9i.bin" ? "arm9i" : "arm7i");
+    if (this.addedOverlays.size && (file.name === "overarm9.bin" || file.name === "overarm7.bin"))
+      return this.readOverlayTable(file.name === "overarm9.bin").toBuffer();
+    return file.replacement ?? range(this.original, file.offset, file.size, file.name);
+  }
+  verifyDsi() {
+    if (this.twl?.complete) return this.twl.complete.verify();
+    if (this.header.unitCode & 2)
+      return new _NDSFile(this.original, { dsiMode: "complete", maxOutputSize: this.maxOutputSize }).verifyDsi();
+    return noDsiVerification();
+  }
+  /** Rebuild offsets, allocation table, CRCs and ROM padding. Safe to call repeatedly. */
+  toBuffer() {
+    if (this.twl?.complete && !this.structureChanged && this.twl.complete.unchanged() && this.header.raw.equals(this.original.subarray(0, this.header.raw.length)) && this.banner.toBuffer().equals(new Banner(this.original, this.header.bannerOffset, this.header.banner_size).toBuffer()) && [...this.paths.values()].every(
+      ({ file }) => !file.replacement || file.replacement.equals(range(this.original, file.offset, file.size, file.name))
+    )) {
+      if (this.original.length > this.maxOutputSize) throw new RangeError("Output exceeds size limit");
+      return Buffer.from(this.original);
+    }
+    const fntReplacement = this.root.files.find((file) => file.name === "fnt.bin")?.replacement;
+    if (this.structureChanged && fntReplacement) throw new Error("Adding files conflicts with an fnt.bin replacement");
+    if (fntReplacement) {
+      const replacementTree = new FileNameTable(this.fatTable, fntReplacement, 0, fntReplacement.length);
+      const collect = (folder) => [...folder.files.map((file) => file.id), ...folder.folders.flatMap(collect)].sort((a, b) => a - b);
+      if (collect(replacementTree.root).join(",") !== collect(this.data).join(","))
+        throw new Error("Replacement FNT must preserve existing file IDs");
+    }
+    const layout = this.structureChanged ? this.fntTable.serialize(this.fatTable, this.overlay.files) : void 0;
+    if (this.twl?.complete) return this.serializeDsi(layout);
+    const overlayFiles = new Map(this.overlay.files.map((file) => [file.id, file]));
+    const h = new Header(this.header.toBuffer());
+    h.nitrocode = this.header.nitrocode;
+    h.decrypted = this.header.decrypted;
+    h.trimmedRom = this.header.trimmedRom;
+    h.dlp_signature = this.header.dlp_signature;
+    const writer = new BinaryWriter(65536, this.maxOutputSize);
+    const system = (name) => {
+      const file = this.root.files.find((file2) => file2.name === name);
+      if (!file) throw new Error(`Missing ROM system file: ${name}`);
+      return file;
+    };
+    const replacedHeader = system("header.bin").replacement;
+    if (replacedHeader) {
+      const replacement = new Header(replacedHeader);
+      h.gameTitle = replacement.gameTitle;
+      h.gameCode = replacement.gameCode;
+    }
+    const placements = /* @__PURE__ */ new Map();
+    const write = (file, padding = true) => {
+      const id = layout ? file.id >= 0 ? layout.sourceIds.get(file.id) : layout.ids.get(file) : file.id;
+      if (layout && id !== void 0 && placements.has(id)) return;
+      if (layout && file.id >= 0) file = overlayFiles.get(file.id) ?? file;
+      const start = writer.position;
+      writer.write(this.fileBytes(file));
+      if (id !== void 0 && id !== 65535) placements.set(id, { start, end: writer.position });
+      if (padding) writer.pad(512);
+    };
+    const overlayIds = /* @__PURE__ */ new Set();
+    const writeOverlays = (arm92) => {
+      const name = arm92 ? "overarm9.bin" : "overarm7.bin";
+      const entry = this.root.files.find((file) => file.name === name);
+      if (!entry) return;
+      const table = this.readOverlayTable(arm92);
+      const files = this.overlay.files.filter((file) => file.name.startsWith(arm92 ? "overlay_" : "overlay7_")).sort((a, b) => a.id < 0 ? b.id < 0 ? 0 : 1 : b.id < 0 ? -1 : a.id - b.id);
+      for (const file of files) {
+        const item = table.entries.find(
+          (item2) => file.name === `overlay${arm92 ? "" : "7"}_${String(item2.overlayId).padStart(4, "0")}.bin`
+        );
+        const size = this.fileBytes(layout && file.id >= 0 ? overlayFiles.get(file.id) : file).length;
+        if (item.reserved >>> 24 & 1 || !arm92 && item.reserved > 0)
+          item.reserved = (item.reserved & 4278190080 | size & 16777215) >>> 0;
+        item.fileId = layout ? file.id >= 0 ? layout.sourceIds.get(file.id) : layout.ids.get(file) : file.id;
+        overlayIds.add(file.id);
+      }
+      const encoded = table.toBuffer();
+      if (arm92) {
+        h.ARM9overlayOffset = writer.position;
+        h.ARM9overlaySize = encoded.length;
+      } else {
+        h.ARM7overlayOffset = writer.position;
+        h.ARM7overlaySize = encoded.length;
+      }
+      writer.write(encoded);
+      writer.pad(512);
+      for (const file of files) write(file);
+    };
+    writer.position = h.headerSize;
+    h.ARM9romOffset = writer.position;
+    const arm9 = system("arm9.bin");
+    const arm9Bytes = this.fileBytes(arm9);
+    if (arm9.replacement) {
+      h.nitrocode = arm9Bytes.length >= 12 && arm9Bytes.readUInt32LE(arm9Bytes.length - 12) === 3737126433;
+    }
+    h.ARM9size = arm9Bytes.length - (h.nitrocode ? 12 : 0);
+    write(arm9);
+    h.ARM9overlayOffset = 0;
+    writeOverlays(true);
+    h.ARM7romOffset = writer.position;
+    h.ARM7size = this.fileBytes(system("arm7.bin")).length;
+    write(system("arm7.bin"));
+    h.ARM7overlayOffset = 0;
+    writeOverlays(false);
+    h.FNToffset = writer.position;
+    const fnt = layout?.fnt ?? this.fileBytes(system("fnt.bin"));
+    h.FNTsize = fnt.length;
+    writer.write(fnt);
+    writer.pad(512);
+    h.FAToffset = writer.position;
+    h.FATsize = (layout?.files.length ?? this.fatTable.entries.length) * 8;
+    writer.write(Buffer.alloc(h.FATsize));
+    writer.pad(512);
+    h.bannerOffset = writer.position;
+    const bannerFile = system("banner.bin");
+    const banner = bannerFile.replacement ? new Banner(bannerFile.replacement, 0, bannerFile.replacement.length) : this.banner;
+    const bannerBytes = banner.toBuffer();
+    if (h.unitCode & 2 && h.headerSize > 512) h.banner_size = bannerBytes.length;
+    writer.write(bannerBytes);
+    writer.pad(512);
+    if (layout) {
+      for (const [index, file] of layout.files.entries()) write(file, index < layout.files.length - 1);
+    } else
+      for (const [index, id] of this.fatTable.sortedIDs.entries()) {
+        if (overlayIds.has(id)) continue;
+        const file = FileNameTable.findFile(id, this.root);
+        if (file) write(file, index < this.fatTable.sortedIDs.length - 1);
+        else {
+          const entry = this.fatTable.entries[id];
+          if (entry.size > 0) {
+            write({ ...entry, name: `FAT entry ${id}` }, index < this.fatTable.sortedIDs.length - 1);
+          }
+        }
+      }
+    const logicalEnd = writer.position;
+    const fat = Buffer.alloc(h.FATsize);
+    for (const [id, location] of placements) {
+      fat.writeUInt32LE(location.start, id * 8);
+      fat.writeUInt32LE(location.end, id * 8 + 4);
+    }
+    writer.position = h.FAToffset;
+    writer.write(fat);
+    writer.position = logicalEnd;
+    h.decrypted = writer.length >= 16392 && writer.buffer.readBigUInt64LE(16384) === 0xe7ffdeffe7ffdeffn;
+    if (this.twl) this.twl.writeTo(writer, h);
+    h.ROMsize = writer.position;
+    h.size = 2 ** Math.ceil(Math.log2(Math.max(h.ROMsize + h.dlp_signature.length, 131072)));
+    const secure = writer.toBuffer().subarray(16384, 32768);
+    h.secureCRC16 = crc16(h.decrypted ? encryptSecureArea(h.gameCode, secure) : secure);
+    writer.position = 0;
+    writer.write(h.toBuffer());
+    writer.position = h.ROMsize;
+    writer.write(h.dlp_signature);
+    writer.fillTo(h.size);
+    return writer.toBuffer();
+  }
+  async saveAs(path) {
+    await writeFile(path, this.toBuffer());
+  }
+  serializeDsi(layout) {
+    const twl = this.twl.complete;
+    const h = new Header(this.header.raw);
+    h.nitrocode = this.header.nitrocode;
+    const system = (name) => this.paths.get(name).file;
+    const replacement = system("header.bin").replacement;
+    if (replacement) {
+      const source = new Header(replacement);
+      if (source.unitCode !== 2 || source.tid_high !== h.tid_high || source.tid_low !== h.tid_low || h.dsi9_size && !source.dsi9_size || h.dsi7_size && !source.dsi7_size)
+        throw new Error("Replacement header changes or clears the DSi cartridge identity or programs");
+      source.raw.copy(h.raw);
+      for (const [start, end] of [
+        [32, 64],
+        [64, 96],
+        [104, 110],
+        [128, 136],
+        [144, 148],
+        [448, 452],
+        [460, 468],
+        [476, 532],
+        [544, 560],
+        [768, 888],
+        [928, 948],
+        [3968, 4096]
+      ])
+        this.header.raw.copy(h.raw, start, start, end);
+      h.ARM9entryAddress = source.ARM9entryAddress;
+      h.ARM9ramAddress = source.ARM9ramAddress;
+      h.ARM7entryAddress = source.ARM7entryAddress;
+      h.ARM7ramAddress = source.ARM7ramAddress;
+      h.dsi7_ram_address = source.dsi7_ram_address;
+      h.headerSize = this.header.headerSize;
+    }
+    const sections = [];
+    const add = (label, file, data, place) => {
+      sections.push({ label, start: file.offset, originalSize: file.size, data, place });
+    };
+    const arm9File = system("arm9.bin");
+    let arm9 = this.fileBytes(arm9File);
+    if (arm9File.replacement) h.nitrocode = arm9.length >= 12 && arm9.readUInt32LE(arm9.length - 12) === 3737126433;
+    if (h.gameCode !== twl.header.gameCode && arm9.readBigUInt64LE(0) !== 0xe7ffdeffe7ffdeffn)
+      arm9 = encryptSecureArea(h.gameCode, decryptSecureArea(twl.header.gameCode, arm9));
+    const signedOverlays = this.readOverlayTable(true).entries.filter((entry) => entry.reserved & 33554432);
+    if (signedOverlays.length !== twl.Overlays9Sha1Hmac.length) {
+      if (!arm9File.replacement) throw new Error("Changing signed overlay count requires an ARM9 replacement");
+    } else
+      arm9 = twl.updateOverlays9Sha1Hmac(
+        arm9,
+        h,
+        signedOverlays.map((entry) => this.getFile(`overlay/overlay_${String(entry.overlayId).padStart(4, "0")}.bin`))
+      );
+    h.ARM9size = arm9.length - (h.nitrocode ? 12 : 0);
+    h.decrypted = arm9.length >= 8 && arm9.readBigUInt64LE(0) === 0xe7ffdeffe7ffdeffn;
+    const plainArm9 = h.decrypted ? Buffer.from(arm9) : decryptSecureArea(h.gameCode, arm9);
+    plainArm9.writeUInt16LE(crc16(range(plainArm9, 16, 2032, "ARM9 secure-area CRC")), 14);
+    arm9 = h.decrypted ? plainArm9 : encryptSecureArea(h.gameCode, plainArm9);
+    add("ARM9", arm9File, arm9, (start) => {
+      h.ARM9romOffset = start;
+    });
+    const written = /* @__PURE__ */ new Set();
+    const fileList = layout?.files ?? this.fatTable.entries.map(
+      (entry) => FileNameTable.findFile(entry.id, this.root) ?? { ...entry, name: `FAT entry ${entry.id}` }
+    );
+    const fat = Buffer.alloc(fileList.length * 8);
+    const addPayload = (file) => {
+      const id = layout ? file.id >= 0 ? layout.sourceIds.get(file.id) : layout.ids.get(file) : file.id;
+      if (written.has(id)) return;
+      written.add(id);
+      const overlay = file.id >= 0 ? this.overlay.files.find((overlay2) => overlay2.id === file.id) : void 0;
+      if (overlay) file = overlay;
+      const data = this.fileBytes(file);
+      add(file.name, file, data, (start) => {
+        fat.writeUInt32LE(start, id * 8);
+        fat.writeUInt32LE(start + data.length, id * 8 + 4);
+      });
+    };
+    const overlays = (arm92) => {
+      const name = arm92 ? "overarm9.bin" : "overarm7.bin";
+      if (!this.hasFile(name)) return;
+      const file = system(name);
+      const table = this.readOverlayTable(arm92);
+      for (const entry of table.entries) {
+        const payload = this.paths.get(
+          `overlay/overlay${arm92 ? "" : "7"}_${String(entry.overlayId).padStart(4, "0")}.bin`
+        ).file;
+        const size = this.fileBytes(payload).length;
+        if (entry.reserved >>> 24 & 1 || !arm92 && entry.reserved > 0)
+          entry.reserved = (entry.reserved & 4278190080 | size) >>> 0;
+        entry.fileId = layout ? payload.id >= 0 ? layout.sourceIds.get(payload.id) : layout.ids.get(payload) : payload.id;
+      }
+      add(name, file, table.toBuffer(), (start) => {
+        if (arm92) {
+          h.ARM9overlayOffset = start;
+          h.ARM9overlaySize = table.entries.length * 32;
+        } else {
+          h.ARM7overlayOffset = start;
+          h.ARM7overlaySize = table.entries.length * 32;
+        }
+      });
+      for (const entry of table.entries)
+        addPayload(
+          this.paths.get(`overlay/overlay${arm92 ? "" : "7"}_${String(entry.overlayId).padStart(4, "0")}.bin`).file
+        );
+    };
+    overlays(true);
+    const arm7 = system("arm7.bin");
+    h.ARM7size = this.fileBytes(arm7).length;
+    add("ARM7", arm7, this.fileBytes(arm7), (start) => {
+      h.ARM7romOffset = start;
+    });
+    overlays(false);
+    const fnt = layout?.fnt ?? this.fileBytes(system("fnt.bin"));
+    h.FNTsize = fnt.length;
+    add("FNT", system("fnt.bin"), fnt, (start) => {
+      h.FNToffset = start;
+    });
+    h.FATsize = fat.length;
+    add("FAT", system("fat.bin"), fat, (start) => {
+      h.FAToffset = start;
+    });
+    const bannerFile = system("banner.bin");
+    const banner = bannerFile.replacement ? new Banner(bannerFile.replacement, 0, bannerFile.replacement.length) : this.banner;
+    const bannerBytes = banner.toBuffer();
+    h.banner_size = bannerBytes.length;
+    add("Banner", bannerFile, bannerBytes, (start) => {
+      h.bannerOffset = start;
+    });
+    for (const file of fileList) addPayload(file);
+    return twl.serialize(h, sections, !!layout);
+  }
+};
+
+export {
+  hashDigest,
+  readFile,
+  inflateRawSync,
+  bytes,
+  BinaryWriter,
+  crc16,
+  crc32,
+  Banner,
+  aes128CtrCrypt,
+  modcryptKey,
+  encryptSecureArea,
+  decryptSecureArea,
+  FileAllocationTable,
+  FileNameTable,
+  OverlayTable,
+  UnitCode,
+  Header,
+  decompressBLZ,
+  compressBLZ,
+  decompressArm9,
+  compressArm9,
+  TWL,
+  updateHeaderSignatures,
+  NDSFile
+};
+//# sourceMappingURL=chunk-LK3JXA24.js.map