stormlib-js 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2920 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compression/pkware.ts
+var pkware_exports = {};
+__export(pkware_exports, {
+  decompressPkware: () => decompressPkware
+});
+function decodeLength(reader) {
+  const bits8 = reader.peekBits(8);
+  let lengthCode = -1;
+  for (let i = 0; i < LENGTH_CODES.length; i++) {
+    const codeLen = LENGTH_BITS[i];
+    const mask = (1 << codeLen) - 1;
+    if ((bits8 & mask) === LENGTH_CODES[i]) {
+      lengthCode = i;
+      reader.skipBits(codeLen);
+      break;
+    }
+  }
+  if (lengthCode === -1) {
+    for (let i = 0; i < LENGTH_CODES.length; i++) {
+      const codeLen = LENGTH_BITS[i];
+      const peek = reader.peekBits(codeLen);
+      if (peek === LENGTH_CODES[i]) {
+        lengthCode = i;
+        reader.skipBits(codeLen);
+        break;
+      }
+    }
+  }
+  if (lengthCode === -1) return -1;
+  if (lengthCode === 15) {
+    return 15 + 256 + reader.readBits(8);
+  }
+  return lengthCode + 2;
+}
+function decompressPkware(inBuffer, outSize) {
+  if (inBuffer.length < 4) {
+    return Buffer.from(inBuffer);
+  }
+  const output = Buffer.alloc(outSize);
+  let outPos = 0;
+  const compressionType = inBuffer[0];
+  const dictSizeBits = inBuffer[1];
+  const dictSize = 1 << dictSizeBits;
+  const reader = new PkBitReader(inBuffer.subarray(2));
+  while (outPos < outSize && !reader.isEof) {
+    const flag = reader.readBits(1);
+    if (flag === 0) {
+      if (compressionType === 0) {
+        output[outPos++] = reader.readBits(8);
+      } else {
+        let value = 0;
+        const bits = reader.peekBits(8);
+        let found = false;
+        for (let i = 0; i < 256; i++) {
+          const numBits = CH_BITS_ASC[i];
+          const peek = reader.peekBits(numBits);
+          if (false) {
+            value = i;
+            reader.skipBits(numBits);
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          output[outPos++] = reader.readBits(8);
+        } else {
+          output[outPos++] = value;
+        }
+      }
+    } else {
+      const distBits8 = reader.peekBits(8);
+      let distCode = -1;
+      for (let i = 0; i < DIST_CODES.length; i++) {
+        if (DIST_CODES[i] === (distBits8 & (1 << DIST_BITS[i]) - 1)) {
+          distCode = i;
+          reader.skipBits(DIST_BITS[i]);
+          break;
+        }
+      }
+      if (distCode === -1) {
+        break;
+      }
+      const distance = distCode << dictSizeBits | reader.readBits(dictSizeBits);
+      const length = decodeLength(reader);
+      if (length < 0) break;
+      const srcPos = outPos - distance - 1;
+      if (srcPos < 0) break;
+      for (let i = 0; i < length && outPos < outSize; i++) {
+        output[outPos] = output[srcPos + i];
+        outPos++;
+      }
+    }
+  }
+  return output.subarray(0, outPos);
+}
+var DIST_CODES, DIST_BITS, LENGTH_CODES, LENGTH_BITS, CH_BITS_ASC, PkBitReader;
+var init_pkware = __esm({
+  "src/compression/pkware.ts"() {
+    "use strict";
+    DIST_CODES = [
+      3,
+      13,
+      5,
+      25,
+      9,
+      17,
+      1,
+      62,
+      30,
+      46,
+      14,
+      54,
+      22,
+      38,
+      6,
+      58,
+      26,
+      42,
+      10,
+      50,
+      18,
+      34,
+      66,
+      2,
+      124,
+      60,
+      92,
+      28,
+      108,
+      44,
+      76,
+      12,
+      116,
+      52,
+      84,
+      20,
+      100,
+      36,
+      68,
+      4,
+      120,
+      56,
+      88,
+      24,
+      104,
+      40,
+      72,
+      8,
+      240,
+      112,
+      176,
+      48,
+      208,
+      80,
+      144,
+      16,
+      224,
+      96,
+      160,
+      32,
+      192,
+      64,
+      128,
+      0
+    ];
+    DIST_BITS = [
+      2,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8
+    ];
+    LENGTH_CODES = [
+      5,
+      3,
+      1,
+      6,
+      10,
+      2,
+      12,
+      20,
+      4,
+      24,
+      8,
+      48,
+      16,
+      32,
+      64,
+      0
+    ];
+    LENGTH_BITS = [
+      3,
+      2,
+      3,
+      3,
+      4,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      6,
+      6,
+      6,
+      7,
+      7
+    ];
+    CH_BITS_ASC = [
+      11,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      8,
+      7,
+      12,
+      12,
+      7,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      13,
+      12,
+      12,
+      12,
+      12,
+      12,
+      4,
+      10,
+      8,
+      12,
+      10,
+      12,
+      10,
+      8,
+      7,
+      7,
+      8,
+      9,
+      7,
+      6,
+      7,
+      8,
+      7,
+      6,
+      7,
+      7,
+      7,
+      7,
+      8,
+      7,
+      7,
+      8,
+      8,
+      12,
+      11,
+      7,
+      9,
+      11,
+      12,
+      6,
+      7,
+      6,
+      6,
+      5,
+      7,
+      8,
+      8,
+      6,
+      11,
+      9,
+      6,
+      7,
+      6,
+      6,
+      7,
+      11,
+      6,
+      6,
+      6,
+      7,
+      9,
+      8,
+      9,
+      9,
+      11,
+      8,
+      11,
+      9,
+      12,
+      8,
+      12,
+      5,
+      6,
+      6,
+      6,
+      5,
+      6,
+      6,
+      6,
+      5,
+      11,
+      7,
+      5,
+      6,
+      5,
+      5,
+      6,
+      10,
+      5,
+      5,
+      5,
+      5,
+      8,
+      7,
+      8,
+      8,
+      10,
+      11,
+      11,
+      12,
+      12,
+      12,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      12,
+      13,
+      12,
+      13,
+      13,
+      13,
+      12,
+      13,
+      13,
+      13,
+      12,
+      13,
+      13,
+      13,
+      13,
+      12,
+      13,
+      13,
+      13,
+      12,
+      12,
+      12,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13,
+      13
+    ];
+    PkBitReader = class {
+      constructor(data) {
+        this.bytePos = 0;
+        this.bitBuf = 0;
+        this.bitsAvail = 0;
+        this.data = data;
+      }
+      fillBuffer() {
+        while (this.bitsAvail <= 24 && this.bytePos < this.data.length) {
+          this.bitBuf |= this.data[this.bytePos++] << this.bitsAvail;
+          this.bitsAvail += 8;
+        }
+      }
+      peekBits(n) {
+        this.fillBuffer();
+        return this.bitBuf & (1 << n) - 1;
+      }
+      skipBits(n) {
+        this.fillBuffer();
+        this.bitBuf >>>= n;
+        this.bitsAvail -= n;
+      }
+      readBits(n) {
+        const val = this.peekBits(n);
+        this.skipBits(n);
+        return val;
+      }
+      get isEof() {
+        return this.bytePos >= this.data.length && this.bitsAvail === 0;
+      }
+    };
+  }
+});
+
+// src/constants.ts
+var ID_MPQ = 441536589;
+var ID_MPQ_USERDATA = 458313805;
+var MPQ_FORMAT_VERSION_1 = 0;
+var MPQ_FORMAT_VERSION_2 = 1;
+var MPQ_FORMAT_VERSION_3 = 2;
+var MPQ_FORMAT_VERSION_4 = 3;
+var MPQ_HEADER_SIZE_V1 = 32;
+var MPQ_HEADER_SIZE_V2 = 44;
+var MPQ_HEADER_SIZE_V3 = 68;
+var MPQ_HEADER_SIZE_V4 = 208;
+var HASH_ENTRY_FREE = 4294967295;
+var HET_ENTRY_FREE = 0;
+var MPQ_HASH_TABLE_INDEX = 0;
+var MPQ_HASH_NAME_A = 256;
+var MPQ_HASH_NAME_B = 512;
+var MPQ_HASH_FILE_KEY = 768;
+var MPQ_HASH_KEY2_MIX = 1024;
+var STORM_BUFFER_SIZE = 1280;
+var MPQ_KEY_HASH_TABLE = 3283040112;
+var MPQ_KEY_BLOCK_TABLE = 3968054179;
+var MPQ_FILE_IMPLODE = 256;
+var MPQ_FILE_COMPRESS = 512;
+var MPQ_FILE_ENCRYPTED = 65536;
+var MPQ_FILE_KEY_V2 = 131072;
+var MPQ_FILE_SINGLE_UNIT = 16777216;
+var MPQ_FILE_SECTOR_CRC = 67108864;
+var MPQ_FILE_EXISTS = 2147483648;
+var MPQ_COMPRESSION_HUFFMANN = 1;
+var MPQ_COMPRESSION_ZLIB = 2;
+var MPQ_COMPRESSION_PKWARE = 8;
+var MPQ_COMPRESSION_BZIP2 = 16;
+var MPQ_COMPRESSION_LZMA = 18;
+var MPQ_COMPRESSION_SPARSE = 32;
+var MPQ_COMPRESSION_ADPCM_MONO = 64;
+var MPQ_COMPRESSION_ADPCM_STEREO = 128;
+var HET_TABLE_SIGNATURE = 441730376;
+var BET_TABLE_SIGNATURE = 441730370;
+var BLOCK_INDEX_MASK = 268435455;
+var LISTFILE_NAME = "(listfile)";
+var SIGNATURE_NAME = "(signature)";
+var ATTRIBUTES_NAME = "(attributes)";
+var MPQ_HEADER_SEARCH_ALIGNMENT = 512;
+
+// src/errors.ts
+var MpqError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MpqError";
+  }
+};
+var MpqNotFoundError = class extends MpqError {
+  constructor(message = "File not found in archive") {
+    super(message);
+    this.name = "MpqNotFoundError";
+  }
+};
+var MpqCorruptError = class extends MpqError {
+  constructor(message = "Archive data is corrupt") {
+    super(message);
+    this.name = "MpqCorruptError";
+  }
+};
+var MpqUnsupportedError = class extends MpqError {
+  constructor(message = "Unsupported feature") {
+    super(message);
+    this.name = "MpqUnsupportedError";
+  }
+};
+var MpqEncryptionError = class extends MpqError {
+  constructor(message = "Unable to decrypt data") {
+    super(message);
+    this.name = "MpqEncryptionError";
+  }
+};
+var MpqCompressionError = class extends MpqError {
+  constructor(message = "Decompression failed") {
+    super(message);
+    this.name = "MpqCompressionError";
+  }
+};
+
+// src/stream/file-stream.ts
+import * as fs from "fs";
+var FileStream = class _FileStream {
+  constructor(fd, fileSize, filePath) {
+    this.fd = fd;
+    this.fileSize = fileSize;
+    this.filePath = filePath;
+  }
+  /**
+   * Open a file for reading.
+   */
+  static open(path) {
+    const fd = fs.openSync(path, "r");
+    const stat = fs.fstatSync(fd);
+    return new _FileStream(fd, BigInt(stat.size), path);
+  }
+  /**
+   * Read bytes at a given offset.
+   *
+   * @param offset - Byte offset from the beginning of the file
+   * @param length - Number of bytes to read
+   * @returns Buffer containing the read data
+   */
+  read(offset, length) {
+    const buffer = Buffer.alloc(length);
+    const bytesRead = fs.readSync(this.fd, buffer, 0, length, Number(offset));
+    if (bytesRead < length) {
+      return buffer.subarray(0, bytesRead);
+    }
+    return buffer;
+  }
+  /**
+   * Read bytes into an existing buffer.
+   */
+  readInto(offset, buffer, bufOffset, length) {
+    return fs.readSync(this.fd, buffer, bufOffset, length, Number(offset));
+  }
+  /**
+   * Get the total file size.
+   */
+  getSize() {
+    return this.fileSize;
+  }
+  /**
+   * Get the file path.
+   */
+  getPath() {
+    return this.filePath;
+  }
+  /**
+   * Close the file stream.
+   */
+  close() {
+    if (this.fd >= 0) {
+      fs.closeSync(this.fd);
+      this.fd = -1;
+    }
+  }
+};
+
+// src/archive/header.ts
+function createDefaultHeader() {
+  return {
+    dwID: 0,
+    dwHeaderSize: 0,
+    dwArchiveSize: 0,
+    wFormatVersion: 0,
+    wSectorSize: 0,
+    dwHashTablePos: 0,
+    dwBlockTablePos: 0,
+    dwHashTableSize: 0,
+    dwBlockTableSize: 0,
+    hiBlockTablePos64: 0n,
+    wHashTablePosHi: 0,
+    wBlockTablePosHi: 0,
+    archiveSize64: 0n,
+    betTablePos64: 0n,
+    hetTablePos64: 0n,
+    hashTableSize64: 0n,
+    blockTableSize64: 0n,
+    hiBlockTableSize64: 0n,
+    hetTableSize64: 0n,
+    betTableSize64: 0n,
+    dwRawChunkSize: 0,
+    md5BlockTable: new Uint8Array(16),
+    md5HashTable: new Uint8Array(16),
+    md5HiBlockTable: new Uint8Array(16),
+    md5BetTable: new Uint8Array(16),
+    md5HetTable: new Uint8Array(16),
+    md5MpqHeader: new Uint8Array(16)
+  };
+}
+function parseHeaderV1(data, header) {
+  header.dwID = data.readUInt32LE(0);
+  header.dwHeaderSize = data.readUInt32LE(4);
+  header.dwArchiveSize = data.readUInt32LE(8);
+  header.wFormatVersion = data.readUInt16LE(12);
+  header.wSectorSize = data.readUInt16LE(14);
+  header.dwHashTablePos = data.readUInt32LE(16);
+  header.dwBlockTablePos = data.readUInt32LE(20);
+  header.dwHashTableSize = data.readUInt32LE(24);
+  header.dwBlockTableSize = data.readUInt32LE(28);
+  header.archiveSize64 = BigInt(header.dwArchiveSize);
+  header.hashTableSize64 = BigInt(header.dwHashTableSize * 16);
+  header.blockTableSize64 = BigInt(header.dwBlockTableSize * 16);
+}
+function parseHeaderV2(data, header) {
+  if (data.length < MPQ_HEADER_SIZE_V2) return;
+  header.hiBlockTablePos64 = data.readBigUInt64LE(32);
+  header.wHashTablePosHi = data.readUInt16LE(40);
+  header.wBlockTablePosHi = data.readUInt16LE(42);
+}
+function parseHeaderV3(data, header) {
+  if (data.length < MPQ_HEADER_SIZE_V3) return;
+  header.archiveSize64 = data.readBigUInt64LE(44);
+  header.betTablePos64 = data.readBigUInt64LE(52);
+  header.hetTablePos64 = data.readBigUInt64LE(60);
+}
+function parseHeaderV4(data, header) {
+  if (data.length < MPQ_HEADER_SIZE_V4) return;
+  header.hashTableSize64 = data.readBigUInt64LE(68);
+  header.blockTableSize64 = data.readBigUInt64LE(76);
+  header.hiBlockTableSize64 = data.readBigUInt64LE(84);
+  header.hetTableSize64 = data.readBigUInt64LE(92);
+  header.betTableSize64 = data.readBigUInt64LE(100);
+  header.dwRawChunkSize = data.readUInt32LE(108);
+  header.md5BlockTable = new Uint8Array(data.subarray(112, 128));
+  header.md5HashTable = new Uint8Array(data.subarray(128, 144));
+  header.md5HiBlockTable = new Uint8Array(data.subarray(144, 160));
+  header.md5BetTable = new Uint8Array(data.subarray(160, 176));
+  header.md5HetTable = new Uint8Array(data.subarray(176, 192));
+  header.md5MpqHeader = new Uint8Array(data.subarray(192, 208));
+}
+function parseHeader(data) {
+  if (data.length < MPQ_HEADER_SIZE_V1) {
+    throw new MpqCorruptError("Header data too small");
+  }
+  const header = createDefaultHeader();
+  parseHeaderV1(data, header);
+  if (header.dwID !== ID_MPQ) {
+    throw new MpqCorruptError(`Invalid MPQ signature: 0x${header.dwID.toString(16)}`);
+  }
+  if (header.wFormatVersion >= MPQ_FORMAT_VERSION_2) {
+    parseHeaderV2(data, header);
+  }
+  if (header.wFormatVersion >= MPQ_FORMAT_VERSION_3) {
+    parseHeaderV3(data, header);
+  }
+  if (header.wFormatVersion >= MPQ_FORMAT_VERSION_4) {
+    parseHeaderV4(data, header);
+  }
+  return header;
+}
+function parseUserData(data) {
+  return {
+    dwID: data.readUInt32LE(0),
+    cbUserDataSize: data.readUInt32LE(4),
+    dwHeaderOffs: data.readUInt32LE(8),
+    cbUserDataHeader: data.readUInt32LE(12)
+  };
+}
+function findHeader(stream, noHeaderSearch = false) {
+  const fileSize = stream.getSize();
+  const searchLimit = noHeaderSearch ? 0n : fileSize;
+  let userData;
+  let userDataOffset;
+  for (let offset = 0n; offset <= searchLimit; offset += BigInt(MPQ_HEADER_SEARCH_ALIGNMENT)) {
+    const sigBuf = stream.read(offset, 4);
+    if (sigBuf.length < 4) break;
+    const signature = sigBuf.readUInt32LE(0);
+    if (signature === ID_MPQ_USERDATA && !noHeaderSearch) {
+      const udBuf = stream.read(offset, 16);
+      if (udBuf.length >= 16) {
+        userData = parseUserData(udBuf);
+        userDataOffset = offset;
+        const mpqOffset = offset + BigInt(userData.dwHeaderOffs);
+        const headerBuf = stream.read(mpqOffset, MPQ_HEADER_SIZE_V4);
+        if (headerBuf.length >= MPQ_HEADER_SIZE_V1) {
+          const headerSig = headerBuf.readUInt32LE(0);
+          if (headerSig === ID_MPQ) {
+            const header = parseHeader(headerBuf);
+            return { header, headerOffset: mpqOffset, userData, userDataOffset };
+          }
+        }
+      }
+    } else if (signature === ID_MPQ) {
+      const headerBuf = stream.read(offset, MPQ_HEADER_SIZE_V4);
+      if (headerBuf.length >= MPQ_HEADER_SIZE_V1) {
+        const header = parseHeader(headerBuf);
+        return { header, headerOffset: offset, userData, userDataOffset };
+      }
+    }
+    if (noHeaderSearch) break;
+  }
+  throw new MpqNotFoundError("MPQ header not found in file");
+}
+function getHashTableOffset(header, archiveOffset) {
+  let offset = BigInt(header.dwHashTablePos);
+  if (header.wFormatVersion >= MPQ_FORMAT_VERSION_2) {
+    offset |= BigInt(header.wHashTablePosHi) << 32n;
+  }
+  return archiveOffset + offset;
+}
+function getBlockTableOffset(header, archiveOffset) {
+  let offset = BigInt(header.dwBlockTablePos);
+  if (header.wFormatVersion >= MPQ_FORMAT_VERSION_2) {
+    offset |= BigInt(header.wBlockTablePosHi) << 32n;
+  }
+  return archiveOffset + offset;
+}
+function getHiBlockTableOffset(header, archiveOffset) {
+  if (header.wFormatVersion >= MPQ_FORMAT_VERSION_2 && header.hiBlockTablePos64 !== 0n) {
+    return archiveOffset + header.hiBlockTablePos64;
+  }
+  return 0n;
+}
+function getHetTableOffset(header, archiveOffset) {
+  if (header.wFormatVersion >= MPQ_FORMAT_VERSION_3 && header.hetTablePos64 !== 0n) {
+    return archiveOffset + header.hetTablePos64;
+  }
+  return 0n;
+}
+function getBetTableOffset(header, archiveOffset) {
+  if (header.wFormatVersion >= MPQ_FORMAT_VERSION_3 && header.betTablePos64 !== 0n) {
+    return archiveOffset + header.betTablePos64;
+  }
+  return 0n;
+}
+function getSectorSize(header) {
+  return 512 << header.wSectorSize;
+}
+
+// src/crypto/storm-buffer.ts
+var stormBuffer = new Uint32Array(STORM_BUFFER_SIZE);
+var initialized = false;
+function initializeStormBuffer() {
+  let seed = 1048577;
+  for (let index1 = 0; index1 < 256; index1++) {
+    let index2 = index1;
+    for (let i = 0; i < 5; i++, index2 += 256) {
+      seed = (seed * 125 + 3) % 2796203;
+      const temp1 = (seed & 65535) << 16;
+      seed = (seed * 125 + 3) % 2796203;
+      const temp2 = seed & 65535;
+      stormBuffer[index2] = (temp1 | temp2) >>> 0;
+    }
+  }
+  initialized = true;
+}
+function getStormBuffer() {
+  if (!initialized) {
+    initializeStormBuffer();
+  }
+  return stormBuffer;
+}
+
+// src/crypto/hash.ts
+var AsciiToUpperTable = new Uint8Array([
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  26,
+  27,
+  28,
+  29,
+  30,
+  31,
+  32,
+  33,
+  34,
+  35,
+  36,
+  37,
+  38,
+  39,
+  40,
+  41,
+  42,
+  43,
+  44,
+  45,
+  46,
+  92,
+  // '/' -> '\'
+  48,
+  49,
+  50,
+  51,
+  52,
+  53,
+  54,
+  55,
+  56,
+  57,
+  58,
+  59,
+  60,
+  61,
+  62,
+  63,
+  64,
+  65,
+  66,
+  67,
+  68,
+  69,
+  70,
+  71,
+  72,
+  73,
+  74,
+  75,
+  76,
+  77,
+  78,
+  79,
+  80,
+  81,
+  82,
+  83,
+  84,
+  85,
+  86,
+  87,
+  88,
+  89,
+  90,
+  91,
+  92,
+  93,
+  94,
+  95,
+  96,
+  65,
+  66,
+  67,
+  68,
+  69,
+  70,
+  71,
+  72,
+  73,
+  74,
+  75,
+  76,
+  77,
+  78,
+  79,
+  80,
+  81,
+  82,
+  83,
+  84,
+  85,
+  86,
+  87,
+  88,
+  89,
+  90,
+  123,
+  124,
+  125,
+  126,
+  127,
+  128,
+  129,
+  130,
+  131,
+  132,
+  133,
+  134,
+  135,
+  136,
+  137,
+  138,
+  139,
+  140,
+  141,
+  142,
+  143,
+  144,
+  145,
+  146,
+  147,
+  148,
+  149,
+  150,
+  151,
+  152,
+  153,
+  154,
+  155,
+  156,
+  157,
+  158,
+  159,
+  160,
+  161,
+  162,
+  163,
+  164,
+  165,
+  166,
+  167,
+  168,
+  169,
+  170,
+  171,
+  172,
+  173,
+  174,
+  175,
+  176,
+  177,
+  178,
+  179,
+  180,
+  181,
+  182,
+  183,
+  184,
+  185,
+  186,
+  187,
+  188,
+  189,
+  190,
+  191,
+  192,
+  193,
+  194,
+  195,
+  196,
+  197,
+  198,
+  199,
+  200,
+  201,
+  202,
+  203,
+  204,
+  205,
+  206,
+  207,
+  208,
+  209,
+  210,
+  211,
+  212,
+  213,
+  214,
+  215,
+  216,
+  217,
+  218,
+  219,
+  220,
+  221,
+  222,
+  223,
+  224,
+  225,
+  226,
+  227,
+  228,
+  229,
+  230,
+  231,
+  232,
+  233,
+  234,
+  235,
+  236,
+  237,
+  238,
+  239,
+  240,
+  241,
+  242,
+  243,
+  244,
+  245,
+  246,
+  247,
+  248,
+  249,
+  250,
+  251,
+  252,
+  253,
+  254,
+  255
+]);
+function hashString(str, hashType) {
+  const buffer = getStormBuffer();
+  let seed1 = 2146271213;
+  let seed2 = 4008636142;
+  for (let i = 0; i < str.length; i++) {
+    const ch = AsciiToUpperTable[str.charCodeAt(i) & 255];
+    seed1 = (buffer[hashType + ch] ^ seed1 + seed2 >>> 0) >>> 0;
+    seed2 = (ch + seed1 + seed2 + (seed2 << 5) + 3 & 4294967295) >>> 0;
+  }
+  return seed1 >>> 0;
+}
+function hashTableIndex(fileName) {
+  return hashString(fileName, MPQ_HASH_TABLE_INDEX);
+}
+function hashNameA(fileName) {
+  return hashString(fileName, MPQ_HASH_NAME_A);
+}
+function hashNameB(fileName) {
+  return hashString(fileName, MPQ_HASH_NAME_B);
+}
+function hashFileKey(fileName) {
+  return hashString(fileName, MPQ_HASH_FILE_KEY);
+}
+function jenkinsHash(str) {
+  let a = 3735928559 + str.length;
+  let b = a;
+  let c = a;
+  let i = 0;
+  while (i + 12 <= str.length) {
+    a = a + str.charCodeAt(i) >>> 0;
+    a = a + (str.charCodeAt(i + 1) << 8) >>> 0;
+    a = a + (str.charCodeAt(i + 2) << 16) >>> 0;
+    a = a + (str.charCodeAt(i + 3) << 24 >>> 0) >>> 0;
+    b = b + str.charCodeAt(i + 4) >>> 0;
+    b = b + (str.charCodeAt(i + 5) << 8) >>> 0;
+    b = b + (str.charCodeAt(i + 6) << 16) >>> 0;
+    b = b + (str.charCodeAt(i + 7) << 24 >>> 0) >>> 0;
+    c = c + str.charCodeAt(i + 8) >>> 0;
+    c = c + (str.charCodeAt(i + 9) << 8) >>> 0;
+    c = c + (str.charCodeAt(i + 10) << 16) >>> 0;
+    c = c + (str.charCodeAt(i + 11) << 24 >>> 0) >>> 0;
+    a = a - c >>> 0;
+    a = (a ^ (c << 4 | c >>> 28)) >>> 0;
+    c = c + b >>> 0;
+    b = b - a >>> 0;
+    b = (b ^ (a << 6 | a >>> 26)) >>> 0;
+    a = a + c >>> 0;
+    c = c - b >>> 0;
+    c = (c ^ (b << 8 | b >>> 24)) >>> 0;
+    b = b + a >>> 0;
+    a = a - c >>> 0;
+    a = (a ^ (c << 16 | c >>> 16)) >>> 0;
+    c = c + b >>> 0;
+    b = b - a >>> 0;
+    b = (b ^ (a << 19 | a >>> 13)) >>> 0;
+    a = a + c >>> 0;
+    c = c - b >>> 0;
+    c = (c ^ (b << 4 | b >>> 28)) >>> 0;
+    b = b + a >>> 0;
+    i += 12;
+  }
+  const remaining = str.length - i;
+  switch (remaining) {
+    case 12:
+      c = c + (str.charCodeAt(i + 11) << 24 >>> 0) >>> 0;
+    // fallthrough
+    case 11:
+      c = c + (str.charCodeAt(i + 10) << 16) >>> 0;
+    case 10:
+      c = c + (str.charCodeAt(i + 9) << 8) >>> 0;
+    case 9:
+      c = c + str.charCodeAt(i + 8) >>> 0;
+    case 8:
+      b = b + (str.charCodeAt(i + 7) << 24 >>> 0) >>> 0;
+    case 7:
+      b = b + (str.charCodeAt(i + 6) << 16) >>> 0;
+    case 6:
+      b = b + (str.charCodeAt(i + 5) << 8) >>> 0;
+    case 5:
+      b = b + str.charCodeAt(i + 4) >>> 0;
+    case 4:
+      a = a + (str.charCodeAt(i + 3) << 24 >>> 0) >>> 0;
+    case 3:
+      a = a + (str.charCodeAt(i + 2) << 16) >>> 0;
+    case 2:
+      a = a + (str.charCodeAt(i + 1) << 8) >>> 0;
+    case 1:
+      a = a + str.charCodeAt(i) >>> 0;
+      break;
+    case 0:
+      return BigInt(c >>> 0) << 32n | BigInt(b >>> 0);
+  }
+  c = (c ^ b) >>> 0;
+  c = c - (b << 14 | b >>> 18) >>> 0;
+  a = (a ^ c) >>> 0;
+  a = a - (c << 11 | c >>> 21) >>> 0;
+  b = (b ^ a) >>> 0;
+  b = b - (a << 25 | a >>> 7) >>> 0;
+  c = (c ^ b) >>> 0;
+  c = c - (b << 16 | b >>> 16) >>> 0;
+  a = (a ^ c) >>> 0;
+  a = a - (c << 4 | c >>> 28) >>> 0;
+  b = (b ^ a) >>> 0;
+  b = b - (a << 14 | a >>> 18) >>> 0;
+  c = (c ^ b) >>> 0;
+  c = c - (b << 24 | b >>> 8) >>> 0;
+  return BigInt(c >>> 0) << 32n | BigInt(b >>> 0);
+}
+function getPlainFileName(filePath) {
+  let plainStart = 0;
+  for (let i = 0; i < filePath.length; i++) {
+    const ch = filePath.charCodeAt(i);
+    if (ch === 92 || ch === 47) {
+      plainStart = i + 1;
+    }
+  }
+  return filePath.substring(plainStart);
+}
+
+// src/crypto/cipher.ts
+function decryptBlock(data, key) {
+  const buffer = getStormBuffer();
+  const dwCount = data.length >>> 2;
+  let dwKey1 = key >>> 0;
+  let dwKey2 = 4008636142;
+  for (let i = 0; i < dwCount; i++) {
+    dwKey2 = (dwKey2 + buffer[MPQ_HASH_KEY2_MIX + (dwKey1 & 255)] & 4294967295) >>> 0;
+    const encrypted = data.readUInt32LE(i * 4);
+    const decrypted = (encrypted ^ dwKey1 + dwKey2 >>> 0) >>> 0;
+    data.writeUInt32LE(decrypted, i * 4);
+    dwKey1 = ((~dwKey1 << 21) + 286331153 | dwKey1 >>> 11) >>> 0;
+    dwKey2 = (decrypted + dwKey2 + (dwKey2 << 5) + 3 & 4294967295) >>> 0;
+  }
+}
+function encryptBlock(data, key) {
+  const buffer = getStormBuffer();
+  const dwCount = data.length >>> 2;
+  let dwKey1 = key >>> 0;
+  let dwKey2 = 4008636142;
+  for (let i = 0; i < dwCount; i++) {
+    dwKey2 = (dwKey2 + buffer[MPQ_HASH_KEY2_MIX + (dwKey1 & 255)] & 4294967295) >>> 0;
+    const plaintext = data.readUInt32LE(i * 4);
+    const encrypted = (plaintext ^ dwKey1 + dwKey2 >>> 0) >>> 0;
+    data.writeUInt32LE(encrypted, i * 4);
+    dwKey1 = ((~dwKey1 << 21) + 286331153 | dwKey1 >>> 11) >>> 0;
+    dwKey2 = (plaintext + dwKey2 + (dwKey2 << 5) + 3 & 4294967295) >>> 0;
+  }
+}
+function decryptFileKey(fileName, byteOffset, fileSize, flags) {
+  const plainName = getPlainFileName(fileName);
+  let key = hashString(plainName, MPQ_HASH_FILE_KEY);
+  if (flags & MPQ_FILE_KEY_V2) {
+    key = (key + Number(byteOffset & 0xFFFFFFFFn) ^ fileSize) >>> 0;
+  }
+  return key >>> 0;
+}
+
+// src/tables/hash-table.ts
+function loadHashTable(stream, offset, count) {
+  const dataSize = count * 16;
+  const data = stream.read(offset, dataSize);
+  if (data.length < dataSize) {
+    count = Math.floor(data.length / 16);
+  }
+  decryptBlock(data, MPQ_KEY_HASH_TABLE);
+  const entries = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const off = i * 16;
+    entries[i] = {
+      dwName1: data.readUInt32LE(off + 0),
+      dwName2: data.readUInt32LE(off + 4),
+      lcLocale: data.readUInt16LE(off + 8),
+      platform: data[off + 10],
+      dwBlockIndex: data.readUInt32LE(off + 12)
+    };
+  }
+  return entries;
+}
+function findHashEntry(hashTable, fileName, locale, maxBlockIndex) {
+  if (hashTable.length === 0) return null;
+  const tableSize = hashTable.length;
+  const mask = tableSize - 1;
+  const startIndex = hashString(fileName, MPQ_HASH_TABLE_INDEX) & mask;
+  const hashCheck1 = hashString(fileName, MPQ_HASH_NAME_A);
+  const hashCheck2 = hashString(fileName, MPQ_HASH_NAME_B);
+  let index = startIndex;
+  for (; ; ) {
+    const entry = hashTable[index];
+    if (entry.dwName1 === hashCheck1 && entry.dwName2 === hashCheck2 && (entry.dwBlockIndex & BLOCK_INDEX_MASK) < maxBlockIndex) {
+      if (locale === 0 || entry.lcLocale === locale || entry.lcLocale === 0) {
+        return entry;
+      }
+    }
+    if (entry.dwBlockIndex === HASH_ENTRY_FREE) {
+      return null;
+    }
+    index = index + 1 & mask;
+    if (index === startIndex) {
+      return null;
+    }
+  }
+}
+
+// src/tables/block-table.ts
+function loadBlockTable(stream, offset, count) {
+  const dataSize = count * 16;
+  const data = stream.read(offset, dataSize);
+  if (data.length < dataSize) {
+    count = Math.floor(data.length / 16);
+  }
+  decryptBlock(data, MPQ_KEY_BLOCK_TABLE);
+  const entries = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const off = i * 16;
+    entries[i] = {
+      dwFilePos: data.readUInt32LE(off + 0),
+      dwCSize: data.readUInt32LE(off + 4),
+      dwFSize: data.readUInt32LE(off + 8),
+      dwFlags: data.readUInt32LE(off + 12)
+    };
+  }
+  return entries;
+}
+function loadHiBlockTable(stream, offset, count) {
+  const dataSize = count * 2;
+  const data = stream.read(offset, dataSize);
+  const hiOffsets = new Uint16Array(count);
+  const actualCount = Math.min(count, Math.floor(data.length / 2));
+  for (let i = 0; i < actualCount; i++) {
+    hiOffsets[i] = data.readUInt16LE(i * 2);
+  }
+  return hiOffsets;
+}
+
+// src/tables/het-table.ts
+function readBits(data, bitOffset, numBits) {
+  let result = 0;
+  for (let i = 0; i < numBits; i++) {
+    const byteIdx = bitOffset + i >>> 3;
+    const bitIdx = bitOffset + i & 7;
+    if (byteIdx < data.length && data[byteIdx] & 1 << bitIdx) {
+      result |= 1 << i;
+    }
+  }
+  return result;
+}
+function loadHetTable(stream, offset, compressedSize) {
+  if (offset === 0n) return null;
+  const extHeaderBuf = stream.read(offset, 12);
+  if (extHeaderBuf.length < 12) return null;
+  const signature = extHeaderBuf.readUInt32LE(0);
+  if (signature !== HET_TABLE_SIGNATURE) return null;
+  const version = extHeaderBuf.readUInt32LE(4);
+  const dataSize = extHeaderBuf.readUInt32LE(8);
+  const dataBuf = stream.read(offset + 12n, dataSize);
+  if (dataBuf.length < dataSize) return null;
+  let pos = 0;
+  const hashTableSize = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const maxFileCount = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const hetHashTableSize = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const hashEntrySize = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const totalIndexSize = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const indexSizeExtra = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const indexSize = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const blockTableSize = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const hetHashes = new Uint8Array(dataBuf.subarray(pos, pos + hetHashTableSize));
+  pos += hetHashTableSize;
+  const betIndexBits = new Uint8Array(dataBuf.subarray(pos));
+  const betIndices = new Array(hetHashTableSize);
+  for (let i = 0; i < hetHashTableSize; i++) {
+    betIndices[i] = readBits(betIndexBits, i * totalIndexSize, totalIndexSize);
+  }
+  return {
+    hashTableSize: hetHashTableSize,
+    maxFileCount,
+    hashEntrySize,
+    totalIndexSize,
+    indexSizeExtra,
+    indexSize,
+    hetHashes,
+    betIndices
+  };
+}
+function findInHetTable(het, fileName) {
+  if (!het || het.hashTableSize === 0) return -1;
+  const fullHash = jenkinsHash(fileName);
+  const hashByte = Number(fullHash >> 56n & 0xFFn) | 128;
+  const startIndex = Number(fullHash % BigInt(het.hashTableSize));
+  let index = startIndex;
+  for (; ; ) {
+    const hetHash = het.hetHashes[index];
+    if (hetHash === HET_ENTRY_FREE) {
+      return -1;
+    }
+    if (hetHash === hashByte) {
+      return het.betIndices[index];
+    }
+    index = (index + 1) % het.hashTableSize;
+    if (index === startIndex) return -1;
+  }
+}
+
+// src/tables/bet-table.ts
+function readBits2(data, bitOffset, numBits) {
+  let result = 0;
+  for (let i = 0; i < numBits; i++) {
+    const byteIdx = bitOffset + i >>> 3;
+    const bitIdx = bitOffset + i & 7;
+    if (byteIdx < data.length && data[byteIdx] & 1 << bitIdx) {
+      result |= 1 << i;
+    }
+  }
+  return result;
+}
+function readBits64(data, bitOffset, numBits) {
+  let result = 0n;
+  for (let i = 0; i < numBits; i++) {
+    const byteIdx = bitOffset + i >>> 3;
+    const bitIdx = bitOffset + i & 7;
+    if (byteIdx < data.length && data[byteIdx] & 1 << bitIdx) {
+      result |= 1n << BigInt(i);
+    }
+  }
+  return result;
+}
+function loadBetTable(stream, offset, compressedSize) {
+  if (offset === 0n) return null;
+  const extHeaderBuf = stream.read(offset, 12);
+  if (extHeaderBuf.length < 12) return null;
+  const signature = extHeaderBuf.readUInt32LE(0);
+  if (signature !== BET_TABLE_SIGNATURE) return null;
+  const version = extHeaderBuf.readUInt32LE(4);
+  const dataSize = extHeaderBuf.readUInt32LE(8);
+  const dataBuf = stream.read(offset + 12n, dataSize);
+  if (dataBuf.length < dataSize) return null;
+  let pos = 0;
+  const tableSize = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const maxFileCount = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const flagCount = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const filePosBits = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const fileSizeBits = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const cmpSizeBits = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const flagIndexBits = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const unknownBits = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const hashSizeBits = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const hashSizeTotal = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const hashSizeExtra = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const hashArraySize = dataBuf.readUInt32LE(pos);
+  pos += 4;
+  const flags = [];
+  for (let i = 0; i < flagCount; i++) {
+    flags.push(dataBuf.readUInt32LE(pos));
+    pos += 4;
+  }
+  const bitsPerEntry = filePosBits + fileSizeBits + cmpSizeBits + flagIndexBits + unknownBits;
+  const entryData = new Uint8Array(dataBuf.subarray(pos));
+  const entries = [];
+  for (let i = 0; i < maxFileCount; i++) {
+    let bitOff = i * bitsPerEntry;
+    const byteOffset = readBits64(entryData, bitOff, filePosBits);
+    bitOff += filePosBits;
+    const fileSize = readBits2(entryData, bitOff, fileSizeBits);
+    bitOff += fileSizeBits;
+    const cmpSize = readBits2(entryData, bitOff, cmpSizeBits);
+    bitOff += cmpSizeBits;
+    const flagIndex = readBits2(entryData, bitOff, flagIndexBits);
+    bitOff += flagIndexBits;
+    const hashBitOffset = maxFileCount * bitsPerEntry + i * hashSizeTotal;
+    const fileNameHash = readBits64(entryData, hashBitOffset, hashSizeTotal);
+    entries.push({
+      fileNameHash,
+      byteOffset,
+      fileSize,
+      cmpSize,
+      flagIndex
+    });
+  }
+  return { maxFileCount, flagCount, flags, entries };
+}
+function getBetEntry(bet, index) {
+  if (index < 0 || index >= bet.entries.length) return null;
+  const entry = bet.entries[index];
+  const flags = entry.flagIndex < bet.flags.length ? bet.flags[entry.flagIndex] : 0;
+  return {
+    fileNameHash: entry.fileNameHash,
+    byteOffset: entry.byteOffset,
+    fileTime: 0n,
+    fileSize: entry.fileSize,
+    cmpSize: entry.cmpSize,
+    flags,
+    crc32: 0,
+    md5: new Uint8Array(16),
+    fileName: ""
+  };
+}
+
+// src/tables/file-table.ts
+function buildFileTable(hashTable, blockTable, hiBlockTable) {
+  const fileCount = blockTable.length;
+  const entries = new Array(fileCount);
+  for (let i = 0; i < fileCount; i++) {
+    const block = blockTable[i];
+    let byteOffset = BigInt(block.dwFilePos);
+    if (hiBlockTable && i < hiBlockTable.length) {
+      byteOffset |= BigInt(hiBlockTable[i]) << 32n;
+    }
+    entries[i] = {
+      fileNameHash: 0n,
+      byteOffset,
+      fileTime: 0n,
+      fileSize: block.dwFSize,
+      cmpSize: block.dwCSize,
+      flags: block.dwFlags,
+      crc32: 0,
+      md5: new Uint8Array(16),
+      fileName: ""
+    };
+  }
+  return entries;
+}
+function buildFileTableFromHetBet(het, bet) {
+  const entries = [];
+  for (let i = 0; i < bet.entries.length; i++) {
+    const entry = getBetEntry(bet, i);
+    if (entry) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function applyFileNames(fileEntries, hashTable, names) {
+  const tableSize = hashTable.length;
+  if (tableSize === 0) return;
+  const mask = tableSize - 1;
+  for (const name of names) {
+    if (!name) continue;
+    const startIndex = hashString(name, MPQ_HASH_TABLE_INDEX) & mask;
+    const check1 = hashString(name, MPQ_HASH_NAME_A);
+    const check2 = hashString(name, MPQ_HASH_NAME_B);
+    let index = startIndex;
+    for (; ; ) {
+      const entry = hashTable[index];
+      if (entry.dwName1 === check1 && entry.dwName2 === check2 && (entry.dwBlockIndex & BLOCK_INDEX_MASK) < fileEntries.length) {
+        const blockIndex = entry.dwBlockIndex & BLOCK_INDEX_MASK;
+        if (!fileEntries[blockIndex].fileName) {
+          fileEntries[blockIndex].fileName = name;
+        }
+        break;
+      }
+      if (entry.dwBlockIndex === HASH_ENTRY_FREE) break;
+      index = index + 1 & mask;
+      if (index === startIndex) break;
+    }
+  }
+}
+
+// src/archive/listfile.ts
+function parseListfile(data) {
+  const text = data.toString("utf8");
+  const names = [];
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.length > 0) {
+      names.push(trimmed);
+    }
+  }
+  return names;
+}
+function parseAttributes(data, fileCount) {
+  if (data.length < 8) return null;
+  const version = data.readUInt32LE(0);
+  const flags = data.readUInt32LE(4);
+  if (version !== 100) return null;
+  const result = {
+    crc32s: [],
+    fileTimes: [],
+    md5s: []
+  };
+  let offset = 8;
+  if (flags & 1) {
+    for (let i = 0; i < fileCount && offset + 4 <= data.length; i++) {
+      result.crc32s.push(data.readUInt32LE(offset));
+      offset += 4;
+    }
+  }
+  if (flags & 2) {
+    for (let i = 0; i < fileCount && offset + 8 <= data.length; i++) {
+      result.fileTimes.push(data.readBigUInt64LE(offset));
+      offset += 8;
+    }
+  }
+  if (flags & 4) {
+    for (let i = 0; i < fileCount && offset + 16 <= data.length; i++) {
+      result.md5s.push(new Uint8Array(data.subarray(offset, offset + 16)));
+      offset += 16;
+    }
+  }
+  return result;
+}
+
+// src/compression/huffman.ts
+var WEIGHT_TABLES = {
+  // Generic text compression (type 0)
+  0: [
+    2571,
+    2568,
+    2567,
+    2566,
+    2570,
+    2569,
+    2565,
+    2564,
+    2563,
+    2562,
+    2561,
+    2560,
+    2319,
+    2318,
+    2317,
+    2316,
+    2315,
+    2314,
+    2313,
+    2312,
+    2311,
+    2310,
+    2309,
+    2308,
+    2307,
+    2306,
+    2305,
+    2304,
+    2063,
+    2062,
+    2061,
+    2060,
+    2059,
+    2058,
+    2057,
+    2056,
+    2055,
+    2054,
+    2053,
+    2052,
+    2051,
+    2050,
+    2049,
+    2048,
+    1807,
+    1806,
+    1805,
+    1804,
+    1803,
+    1802,
+    1801,
+    1800,
+    1799,
+    1798,
+    1797,
+    1796,
+    1795,
+    1794,
+    1793,
+    1792,
+    1551,
+    1550,
+    1549,
+    1548,
+    1547,
+    1546,
+    1545,
+    1544,
+    1543,
+    1542,
+    1541,
+    1540,
+    1539,
+    1538,
+    1537,
+    1536,
+    1295,
+    1294,
+    1293,
+    1292,
+    1291,
+    1290,
+    1289,
+    1288,
+    1287,
+    1286,
+    1285,
+    1284,
+    1283,
+    1282,
+    1281,
+    1280,
+    1039,
+    1038,
+    1037,
+    1036,
+    1035,
+    1034,
+    1033,
+    1032,
+    1031,
+    1030,
+    1029,
+    1028,
+    1027,
+    1026,
+    1025,
+    1024,
+    783,
+    782,
+    781,
+    780,
+    779,
+    778,
+    777,
+    776,
+    775,
+    774,
+    773,
+    772,
+    771,
+    770,
+    769,
+    768,
+    527,
+    526,
+    525,
+    524,
+    523,
+    522,
+    521,
+    520,
+    519,
+    518,
+    517,
+    516,
+    515,
+    514,
+    513,
+    512,
+    271,
+    270,
+    269,
+    268,
+    267,
+    266,
+    265,
+    264,
+    263,
+    262,
+    261,
+    260,
+    259,
+    258,
+    257,
+    256,
+    15,
+    14,
+    13,
+    12,
+    11,
+    10,
+    9,
+    8,
+    7,
+    6,
+    5,
+    4,
+    3,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    2
+  ]
+};
+var BitReader = class {
+  constructor(data) {
+    this.bitPos = 0;
+    this.data = data;
+  }
+  readBits(numBits) {
+    let result = 0;
+    for (let i = 0; i < numBits; i++) {
+      const byteIndex = this.bitPos >>> 3;
+      const bitIndex = this.bitPos & 7;
+      if (byteIndex >= this.data.length) return result;
+      if (this.data[byteIndex] & 1 << bitIndex) {
+        result |= 1 << i;
+      }
+      this.bitPos++;
+    }
+    return result;
+  }
+  readBit() {
+    const byteIndex = this.bitPos >>> 3;
+    const bitIndex = this.bitPos & 7;
+    if (byteIndex >= this.data.length) return 0;
+    const bit = this.data[byteIndex] >>> bitIndex & 1;
+    this.bitPos++;
+    return bit;
+  }
+  get isEof() {
+    return this.bitPos >>> 3 >= this.data.length;
+  }
+};
+var HuffmanTree = class {
+  constructor(compressionType) {
+    this.nodes = [];
+    this.root = -1;
+    this.items256 = new Array(256).fill(-1);
+    this.buildTree(compressionType);
+  }
+  buildTree(compressionType) {
+    const weights = WEIGHT_TABLES[compressionType] || WEIGHT_TABLES[0];
+    for (let i = 0; i < 257; i++) {
+      this.nodes.push({
+        weight: i < 256 ? weights ? weights[i] || 0 : 0 : 0,
+        child0: -1,
+        child1: -1,
+        parent: -1,
+        value: i
+      });
+    }
+    const leafIndices = Array.from({ length: 257 }, (_, i) => i).filter((i) => this.nodes[i].weight > 0 || i === 256);
+    leafIndices.sort((a, b) => this.nodes[a].weight - this.nodes[b].weight);
+    const active = [...leafIndices];
+    while (active.length > 1) {
+      const idx0 = active.shift();
+      const idx1 = active.shift();
+      const parentIdx = this.nodes.length;
+      this.nodes.push({
+        weight: this.nodes[idx0].weight + this.nodes[idx1].weight,
+        child0: idx0,
+        child1: idx1,
+        parent: -1,
+        value: -1
+      });
+      this.nodes[idx0].parent = parentIdx;
+      this.nodes[idx1].parent = parentIdx;
+      let insertAt = active.length;
+      for (let j = 0; j < active.length; j++) {
+        if (this.nodes[parentIdx].weight <= this.nodes[active[j]].weight) {
+          insertAt = j;
+          break;
+        }
+      }
+      active.splice(insertAt, 0, parentIdx);
+    }
+    if (active.length > 0) {
+      this.root = active[0];
+    }
+    for (let i = 0; i < 256; i++) {
+      if (this.nodes[i].weight > 0) {
+        this.items256[i] = i;
+      }
+    }
+  }
+  decodeOne(reader) {
+    if (this.root === -1) return -1;
+    let current = this.root;
+    while (this.nodes[current].value === -1) {
+      const bit = reader.readBit();
+      if (bit === 0) {
+        current = this.nodes[current].child0;
+      } else {
+        current = this.nodes[current].child1;
+      }
+      if (current === -1) return -1;
+    }
+    return this.nodes[current].value;
+  }
+};
+function decompressHuffman(inBuffer, outSize) {
+  if (inBuffer.length === 0) {
+    return Buffer.alloc(outSize);
+  }
+  const compressionType = inBuffer[0];
+  const reader = new BitReader(inBuffer.subarray(1));
+  const tree = new HuffmanTree(compressionType);
+  const output = Buffer.alloc(outSize);
+  let outPos = 0;
+  while (outPos < outSize && !reader.isEof) {
+    const value = tree.decodeOne(reader);
+    if (value < 0 || value === 256) break;
+    output[outPos++] = value & 255;
+  }
+  return output;
+}
+
+// src/compression/index.ts
+init_pkware();
+
+// src/compression/adpcm.ts
+var STEP_TABLE = [
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  16,
+  17,
+  19,
+  21,
+  23,
+  25,
+  28,
+  31,
+  34,
+  37,
+  41,
+  45,
+  50,
+  55,
+  60,
+  66,
+  73,
+  80,
+  88,
+  97,
+  107,
+  118,
+  130,
+  143,
+  157,
+  173,
+  190,
+  209,
+  230,
+  253,
+  279,
+  307,
+  337,
+  371,
+  408,
+  449,
+  494,
+  544,
+  598,
+  658,
+  724,
+  796,
+  876,
+  963,
+  1060,
+  1166,
+  1282,
+  1411,
+  1552,
+  1707,
+  1878,
+  2066,
+  2272,
+  2499,
+  2749,
+  3024,
+  3327,
+  3660,
+  4026,
+  4428,
+  4871,
+  5358,
+  5894,
+  6484,
+  7132,
+  7845,
+  8630,
+  9493,
+  10442,
+  11487,
+  12635,
+  13899,
+  15289,
+  16818,
+  18500,
+  20350,
+  22385,
+  24623,
+  27086,
+  29794,
+  32767
+];
+var INDEX_TABLE = [
+  -1,
+  0,
+  -1,
+  4,
+  -1,
+  2,
+  -1,
+  6,
+  -1,
+  1,
+  -1,
+  5,
+  -1,
+  3,
+  -1,
+  7,
+  -1,
+  1,
+  -1,
+  5,
+  -1,
+  3,
+  -1,
+  7,
+  -1,
+  2,
+  -1,
+  4,
+  -1,
+  6,
+  -1,
+  8
+];
+function clampStepIndex(index) {
+  if (index < 0) return 0;
+  if (index > 88) return 88;
+  return index;
+}
+function clampSample(sample) {
+  if (sample > 32767) return 32767;
+  if (sample < -32768) return -32768;
+  return sample;
+}
+function decodeSample(state, code) {
+  const step = STEP_TABLE[state.stepIndex];
+  let diff = step >>> 3;
+  if (code & 4) diff += step;
+  if (code & 2) diff += step >>> 1;
+  if (code & 1) diff += step >>> 2;
+  if (code & 8) {
+    state.predSample = clampSample(state.predSample - diff);
+  } else {
+    state.predSample = clampSample(state.predSample + diff);
+  }
+  state.stepIndex = clampStepIndex(state.stepIndex + INDEX_TABLE[code & 31]);
+  return state.predSample;
+}
+function decompressAdpcmMono(inBuffer, outSize) {
+  if (inBuffer.length < 4) {
+    return Buffer.alloc(outSize);
+  }
+  const output = Buffer.alloc(outSize);
+  let inPos = 0;
+  let outPos = 0;
+  const shift = inBuffer[inPos++];
+  const initialSample = inBuffer.readInt16LE(inPos);
+  inPos += 2;
+  const state = {
+    predSample: initialSample,
+    stepIndex: STEP_TABLE.indexOf(Math.abs(initialSample)) || 0
+  };
+  if (outPos + 2 <= outSize) {
+    output.writeInt16LE(state.predSample, outPos);
+    outPos += 2;
+  }
+  while (inPos < inBuffer.length && outPos + 2 <= outSize) {
+    const byte = inBuffer[inPos++];
+    const sample1 = decodeSample(state, byte & 15);
+    if (outPos + 2 <= outSize) {
+      output.writeInt16LE(sample1, outPos);
+      outPos += 2;
+    }
+    if (outPos + 2 <= outSize) {
+      const sample2 = decodeSample(state, byte >>> 4 & 15);
+      output.writeInt16LE(sample2, outPos);
+      outPos += 2;
+    }
+  }
+  return output;
+}
+function decompressAdpcmStereo(inBuffer, outSize) {
+  if (inBuffer.length < 8) {
+    return Buffer.alloc(outSize);
+  }
+  const output = Buffer.alloc(outSize);
+  let inPos = 0;
+  let outPos = 0;
+  const shift = inBuffer[inPos++];
+  const initialLeft = inBuffer.readInt16LE(inPos);
+  inPos += 2;
+  const initialRight = inBuffer.readInt16LE(inPos);
+  inPos += 2;
+  const stateL = {
+    predSample: initialLeft,
+    stepIndex: 0
+  };
+  const stateR = {
+    predSample: initialRight,
+    stepIndex: 0
+  };
+  if (outPos + 4 <= outSize) {
+    output.writeInt16LE(stateL.predSample, outPos);
+    outPos += 2;
+    output.writeInt16LE(stateR.predSample, outPos);
+    outPos += 2;
+  }
+  let channel = 0;
+  while (inPos < inBuffer.length && outPos + 2 <= outSize) {
+    const byte = inBuffer[inPos++];
+    const state = channel === 0 ? stateL : stateR;
+    const sample1 = decodeSample(state, byte & 15);
+    if (outPos + 2 <= outSize) {
+      output.writeInt16LE(sample1, outPos);
+      outPos += 2;
+    }
+    channel ^= 1;
+    if (outPos + 2 <= outSize) {
+      const state2 = channel === 0 ? stateL : stateR;
+      const sample2 = decodeSample(state2, byte >>> 4 & 15);
+      output.writeInt16LE(sample2, outPos);
+      outPos += 2;
+    }
+    channel ^= 1;
+  }
+  return output;
+}
+
+// src/compression/sparse.ts
+function decompressSparse(inBuffer, outSize) {
+  const output = Buffer.alloc(outSize);
+  let inPos = 0;
+  let outPos = 0;
+  while (inPos < inBuffer.length && outPos < outSize) {
+    const byte = inBuffer[inPos++];
+    if (byte !== 0) {
+      output[outPos++] = byte;
+    } else {
+      if (inPos >= inBuffer.length) break;
+      const count = inBuffer[inPos++];
+      if (count === 0) {
+        output[outPos++] = 0;
+      } else {
+        const end = Math.min(outPos + count, outSize);
+        outPos = end;
+      }
+    }
+  }
+  return output;
+}
+
+// src/compression/index.ts
+import pako from "pako";
+function decompressZlib(inBuffer, outSize) {
+  const result = pako.inflate(inBuffer);
+  return Buffer.from(result.buffer, result.byteOffset, result.byteLength);
+}
+function decompressBzip2(_inBuffer, _outSize) {
+  throw new MpqUnsupportedError("BZIP2 decompression is not supported. Install a bzip2 package if needed.");
+}
+function decompressLzma(_inBuffer, _outSize) {
+  throw new MpqUnsupportedError("LZMA decompression is not supported. Install an LZMA package if needed.");
+}
+var DECOMPRESS_TABLE = [
+  { mask: MPQ_COMPRESSION_BZIP2, decompress: decompressBzip2 },
+  { mask: MPQ_COMPRESSION_PKWARE, decompress: decompressPkware },
+  { mask: MPQ_COMPRESSION_ZLIB, decompress: decompressZlib },
+  { mask: MPQ_COMPRESSION_HUFFMANN, decompress: decompressHuffman },
+  { mask: MPQ_COMPRESSION_ADPCM_STEREO, decompress: decompressAdpcmStereo },
+  { mask: MPQ_COMPRESSION_ADPCM_MONO, decompress: decompressAdpcmMono },
+  { mask: MPQ_COMPRESSION_SPARSE, decompress: decompressSparse }
+];
+function decompress(inBuffer, outSize) {
+  if (inBuffer.length === outSize) {
+    return Buffer.from(inBuffer);
+  }
+  if (inBuffer.length === 0) {
+    throw new MpqCompressionError("Empty input buffer");
+  }
+  const compressionMask = inBuffer[0];
+  let data = inBuffer.subarray(1);
+  if (compressionMask === MPQ_COMPRESSION_LZMA) {
+    return decompressLzma(data, outSize);
+  }
+  const stages = [];
+  let remainingMask = compressionMask;
+  for (const entry of DECOMPRESS_TABLE) {
+    if (remainingMask & entry.mask) {
+      stages.push(entry);
+      remainingMask &= ~entry.mask;
+    }
+  }
+  if (stages.length === 0 || remainingMask !== 0) {
+    throw new MpqCompressionError(
+      `Unsupported compression mask: 0x${compressionMask.toString(16).padStart(2, "0")}`
+    );
+  }
+  let currentData = data;
+  let currentSize = outSize;
+  for (let i = 0; i < stages.length; i++) {
+    const isLast = i === stages.length - 1;
+    const targetSize = isLast ? outSize : currentData.length * 4;
+    try {
+      currentData = stages[i].decompress(
+        Buffer.isBuffer(currentData) ? currentData : Buffer.from(currentData),
+        isLast ? outSize : targetSize
+      );
+    } catch (err) {
+      if (err instanceof MpqUnsupportedError) throw err;
+      throw new MpqCompressionError(
+        `Decompression stage 0x${stages[i].mask.toString(16)} failed: ${err}`
+      );
+    }
+  }
+  return Buffer.isBuffer(currentData) ? currentData : Buffer.from(currentData);
+}
+
+// src/file/sector-reader.ts
+init_pkware();
+function readSectorOffsets(stream, fileOffset, fileEntry, sectorSize, fileKey) {
+  const sectorCount = Math.ceil(fileEntry.fileSize / sectorSize);
+  let offsetCount = sectorCount + 1;
+  if (fileEntry.flags & MPQ_FILE_SECTOR_CRC) {
+    offsetCount++;
+  }
+  const tableSize = offsetCount * 4;
+  const tableData = stream.read(fileOffset, tableSize);
+  if (tableData.length < tableSize) {
+    throw new MpqCorruptError("Sector offset table is truncated");
+  }
+  if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {
+    decryptBlock(tableData, fileKey - 1 >>> 0);
+  }
+  const offsets = new Uint32Array(offsetCount);
+  for (let i = 0; i < offsetCount; i++) {
+    offsets[i] = tableData.readUInt32LE(i * 4);
+  }
+  return offsets;
+}
+function readSector(stream, fileOffset, sectorOffsets, sectorIndex, fileEntry, sectorSize, fileKey) {
+  const rawOffset = sectorOffsets[sectorIndex];
+  const rawEnd = sectorOffsets[sectorIndex + 1];
+  const rawSize = rawEnd - rawOffset;
+  const sectorStart = sectorIndex * sectorSize;
+  const expectedSize = Math.min(sectorSize, fileEntry.fileSize - sectorStart);
+  let sectorData = stream.read(fileOffset + BigInt(rawOffset), rawSize);
+  if (sectorData.length < rawSize) {
+    throw new MpqCorruptError(`Sector ${sectorIndex} data is truncated`);
+  }
+  if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {
+    sectorData = Buffer.from(sectorData);
+    decryptBlock(sectorData, fileKey + sectorIndex >>> 0);
+  }
+  if (rawSize < expectedSize) {
+    if (fileEntry.flags & MPQ_FILE_COMPRESS) {
+      sectorData = decompress(sectorData, expectedSize);
+    } else if (fileEntry.flags & MPQ_FILE_IMPLODE) {
+      sectorData = decompressPkware(sectorData, expectedSize);
+    }
+  }
+  return sectorData;
+}
+function readSectorFile(stream, archiveOffset, fileEntry, sectorSize, fileKey) {
+  const fileOffset = archiveOffset + fileEntry.byteOffset;
+  const sectorOffsets = readSectorOffsets(stream, fileOffset, fileEntry, sectorSize, fileKey);
+  const sectorCount = Math.ceil(fileEntry.fileSize / sectorSize);
+  const output = Buffer.alloc(fileEntry.fileSize);
+  let outPos = 0;
+  for (let i = 0; i < sectorCount; i++) {
+    const sectorData = readSector(
+      stream,
+      fileOffset,
+      sectorOffsets,
+      i,
+      fileEntry,
+      sectorSize,
+      fileKey
+    );
+    const copyLen = Math.min(sectorData.length, fileEntry.fileSize - outPos);
+    sectorData.copy(output, outPos, 0, copyLen);
+    outPos += copyLen;
+  }
+  return output;
+}
+function readSingleUnitFile(stream, archiveOffset, fileEntry, fileKey) {
+  const fileOffset = archiveOffset + fileEntry.byteOffset;
+  let data = stream.read(fileOffset, fileEntry.cmpSize);
+  if (data.length < fileEntry.cmpSize) {
+    throw new MpqCorruptError("Single-unit file data is truncated");
+  }
+  if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {
+    data = Buffer.from(data);
+    decryptBlock(data, fileKey);
+  }
+  if (fileEntry.cmpSize < fileEntry.fileSize) {
+    if (fileEntry.flags & MPQ_FILE_COMPRESS) {
+      data = decompress(data, fileEntry.fileSize);
+    } else if (fileEntry.flags & MPQ_FILE_IMPLODE) {
+      const { decompressPkware: decompressPkware2 } = (init_pkware(), __toCommonJS(pkware_exports));
+      data = decompressPkware2(data, fileEntry.fileSize);
+    }
+  }
+  return data;
+}
+
+// src/file/mpq-file.ts
+var MpqFile = class {
+  constructor(stream, archiveOffset, entry, sectorSize) {
+    this.closed = false;
+    this.stream = stream;
+    this.archiveOffset = archiveOffset;
+    this.entry = entry;
+    this.sectorSize = sectorSize;
+    if (entry.flags & MPQ_FILE_ENCRYPTED) {
+      this.fileKey = decryptFileKey(
+        entry.fileName,
+        entry.byteOffset,
+        entry.fileSize,
+        entry.flags
+      );
+    } else {
+      this.fileKey = 0;
+    }
+  }
+  /** Uncompressed file size */
+  get size() {
+    return this.entry.fileSize;
+  }
+  /** Compressed file size */
+  get compressedSize() {
+    return this.entry.cmpSize;
+  }
+  /** File flags */
+  get flags() {
+    return this.entry.flags;
+  }
+  /** File name */
+  get name() {
+    return this.entry.fileName;
+  }
+  /** The underlying file entry */
+  get fileEntry() {
+    return this.entry;
+  }
+  /**
+   * Read the entire file contents.
+   *
+   * @returns Buffer containing the decompressed file data
+   */
+  read() {
+    if (this.closed) {
+      throw new Error("File handle is closed");
+    }
+    if (this.entry.fileSize === 0) {
+      return Buffer.alloc(0);
+    }
+    if (this.entry.flags & MPQ_FILE_SINGLE_UNIT) {
+      return readSingleUnitFile(
+        this.stream,
+        this.archiveOffset,
+        this.entry,
+        this.fileKey
+      );
+    }
+    return readSectorFile(
+      this.stream,
+      this.archiveOffset,
+      this.entry,
+      this.sectorSize,
+      this.fileKey
+    );
+  }
+  /**
+   * Close the file handle.
+   */
+  close() {
+    this.closed = true;
+  }
+};
+
+// src/archive/mpq-archive.ts
+var MpqArchive = class _MpqArchive {
+  constructor(stream, header, archiveOffset) {
+    this.hashTable = [];
+    this.blockTable = [];
+    this.hiBlockTable = null;
+    this.hetTable = null;
+    this.betTable = null;
+    this.fileEntries = [];
+    this.attributes = null;
+    this.closed = false;
+    this.stream = stream;
+    this.header = header;
+    this.archiveOffset = archiveOffset;
+    this.sectorSize = getSectorSize(header);
+  }
+  /**
+   * Open an MPQ archive from a file path.
+   *
+   * @param path - Path to the MPQ file
+   * @param options - Open options
+   * @returns MpqArchive instance
+   */
+  static open(path, options) {
+    const stream = FileStream.open(path);
+    try {
+      const noHeaderSearch = options?.noHeaderSearch ?? false;
+      const { header, headerOffset } = findHeader(stream, noHeaderSearch);
+      if (options?.forceMpqV1) {
+        header.wFormatVersion = MPQ_FORMAT_VERSION_1;
+      }
+      const archive = new _MpqArchive(stream, header, headerOffset);
+      archive.loadTables();
+      if (!options?.noListfile) {
+        archive.loadListfile();
+      }
+      if (!options?.noAttributes) {
+        archive.loadAttributes();
+      }
+      return archive;
+    } catch (err) {
+      stream.close();
+      throw err;
+    }
+  }
+  /**
+   * Load all archive tables (hash, block, HET, BET).
+   */
+  loadTables() {
+    const h = this.header;
+    if (h.dwHashTableSize > 0) {
+      const hashOffset = getHashTableOffset(h, this.archiveOffset);
+      this.hashTable = loadHashTable(this.stream, hashOffset, h.dwHashTableSize);
+    }
+    if (h.dwBlockTableSize > 0) {
+      const blockOffset = getBlockTableOffset(h, this.archiveOffset);
+      this.blockTable = loadBlockTable(this.stream, blockOffset, h.dwBlockTableSize);
+    }
+    const hiBlockOffset = getHiBlockTableOffset(h, this.archiveOffset);
+    if (hiBlockOffset !== 0n && this.blockTable.length > 0) {
+      this.hiBlockTable = loadHiBlockTable(this.stream, hiBlockOffset, this.blockTable.length);
+    }
+    if (h.wFormatVersion >= MPQ_FORMAT_VERSION_3) {
+      const hetOffset = getHetTableOffset(h, this.archiveOffset);
+      if (hetOffset !== 0n) {
+        this.hetTable = loadHetTable(this.stream, hetOffset, h.hetTableSize64);
+      }
+      const betOffset = getBetTableOffset(h, this.archiveOffset);
+      if (betOffset !== 0n) {
+        this.betTable = loadBetTable(this.stream, betOffset, h.betTableSize64);
+      }
+    }
+    if (this.hetTable && this.betTable) {
+      this.fileEntries = buildFileTableFromHetBet(this.hetTable, this.betTable);
+    } else {
+      this.fileEntries = buildFileTable(this.hashTable, this.blockTable, this.hiBlockTable);
+    }
+  }
+  /**
+   * Load and parse the (listfile) to populate file names.
+   */
+  loadListfile() {
+    try {
+      const data = this.extractFileByName(LISTFILE_NAME);
+      if (data) {
+        const names = parseListfile(data);
+        applyFileNames(this.fileEntries, this.hashTable, names);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Load and parse the (attributes) file.
+   */
+  loadAttributes() {
+    try {
+      const data = this.extractFileByName(ATTRIBUTES_NAME);
+      if (data) {
+        this.attributes = parseAttributes(data, this.fileEntries.length);
+        if (this.attributes) {
+          for (let i = 0; i < this.fileEntries.length; i++) {
+            if (i < this.attributes.crc32s.length) {
+              this.fileEntries[i].crc32 = this.attributes.crc32s[i];
+            }
+            if (i < this.attributes.fileTimes.length) {
+              this.fileEntries[i].fileTime = this.attributes.fileTimes[i];
+            }
+            if (i < this.attributes.md5s.length) {
+              this.fileEntries[i].md5 = this.attributes.md5s[i];
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Internal: extract a file by name without relying on the listfile.
+   * Used for bootstrapping (listfile) and (attributes) loading.
+   */
+  extractFileByName(fileName) {
+    const hashEntry = findHashEntry(
+      this.hashTable,
+      fileName,
+      0,
+      this.fileEntries.length
+    );
+    if (!hashEntry) return null;
+    const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;
+    if (blockIndex >= this.fileEntries.length) return null;
+    const entry = this.fileEntries[blockIndex];
+    if (!(entry.flags & MPQ_FILE_EXISTS)) return null;
+    const savedName = entry.fileName;
+    entry.fileName = fileName;
+    try {
+      const file = new MpqFile(this.stream, this.archiveOffset, entry, this.sectorSize);
+      const data = file.read();
+      file.close();
+      return data;
+    } finally {
+      entry.fileName = savedName;
+    }
+  }
+  /**
+   * Check if a file exists in the archive.
+   */
+  hasFile(name) {
+    this.ensureOpen();
+    if (this.hetTable && this.betTable) {
+      const betIndex = findInHetTable(this.hetTable, name);
+      if (betIndex >= 0 && betIndex < this.fileEntries.length) {
+        return !!(this.fileEntries[betIndex].flags & MPQ_FILE_EXISTS);
+      }
+    }
+    const hashEntry = findHashEntry(this.hashTable, name, 0, this.fileEntries.length);
+    if (!hashEntry) return false;
+    const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;
+    return blockIndex < this.fileEntries.length && !!(this.fileEntries[blockIndex].flags & MPQ_FILE_EXISTS);
+  }
+  /**
+   * Open a file within the archive for reading.
+   *
+   * @param name - File path within the archive
+   * @returns MpqFile handle
+   */
+  openFile(name) {
+    this.ensureOpen();
+    const entry = this.resolveFile(name);
+    if (!entry) {
+      throw new MpqNotFoundError(`File not found: ${name}`);
+    }
+    return new MpqFile(this.stream, this.archiveOffset, entry, this.sectorSize);
+  }
+  /**
+   * Extract a file's contents directly.
+   *
+   * @param name - File path within the archive
+   * @returns Buffer with the file contents
+   */
+  extractFile(name) {
+    const file = this.openFile(name);
+    try {
+      return file.read();
+    } finally {
+      file.close();
+    }
+  }
+  /**
+   * Get the list of all known file names (from listfile).
+   */
+  getFileList() {
+    this.ensureOpen();
+    return this.fileEntries.filter((e) => e.fileName && e.flags & MPQ_FILE_EXISTS).map((e) => e.fileName);
+  }
+  /**
+   * Find files matching a wildcard pattern.
+   *
+   * @param mask - Wildcard pattern (supports '*' and '?')
+   * @returns Array of matching file entries
+   */
+  findFiles(mask = "*") {
+    this.ensureOpen();
+    const regex = wildcardToRegex(mask);
+    const results = [];
+    for (let i = 0; i < this.fileEntries.length; i++) {
+      const entry = this.fileEntries[i];
+      if (!(entry.flags & MPQ_FILE_EXISTS)) continue;
+      if (!entry.fileName) continue;
+      if (regex.test(entry.fileName)) {
+        const plainName = entry.fileName.replace(/^.*[\\/]/, "");
+        results.push({
+          fileName: entry.fileName,
+          plainName,
+          hashIndex: 0,
+          blockIndex: i,
+          fileSize: entry.fileSize,
+          compSize: entry.cmpSize,
+          fileFlags: entry.flags,
+          locale: 0
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Apply an external list of file names to resolve unnamed entries.
+   * Equivalent to providing an external listfile to SFileFindFirstFile.
+   *
+   * @param names - Array of file names to try
+   * @returns Number of newly resolved names
+   */
+  addListfile(names) {
+    this.ensureOpen();
+    const before = this.fileEntries.filter((e) => e.fileName).length;
+    applyFileNames(this.fileEntries, this.hashTable, names);
+    return this.fileEntries.filter((e) => e.fileName).length - before;
+  }
+  /**
+   * Enumerate all existing file entries, including those without names.
+   * Unnamed entries get a synthetic name like "File00001234.xxx".
+   */
+  enumerateFiles() {
+    this.ensureOpen();
+    const results = [];
+    for (let i = 0; i < this.fileEntries.length; i++) {
+      const entry = this.fileEntries[i];
+      if (!(entry.flags & MPQ_FILE_EXISTS)) continue;
+      const fileName = entry.fileName || `File${String(i).padStart(8, "0")}.xxx`;
+      const plainName = fileName.replace(/^.*[\\/]/, "");
+      results.push({
+        fileName,
+        plainName,
+        hashIndex: 0,
+        blockIndex: i,
+        fileSize: entry.fileSize,
+        compSize: entry.cmpSize,
+        fileFlags: entry.flags,
+        locale: 0
+      });
+    }
+    return results;
+  }
+  /** Get the archive header */
+  getHeader() {
+    return this.header;
+  }
+  /** Get the number of file entries */
+  get fileCount() {
+    return this.fileEntries.length;
+  }
+  /** Get the sector size */
+  getSectorSize() {
+    return this.sectorSize;
+  }
+  /**
+   * Close the archive and release resources.
+   */
+  close() {
+    if (!this.closed) {
+      this.stream.close();
+      this.closed = true;
+    }
+  }
+  /**
+   * Resolve a file name to its FileEntry.
+   */
+  resolveFile(name) {
+    if (this.hetTable && this.betTable) {
+      const betIndex = findInHetTable(this.hetTable, name);
+      if (betIndex >= 0 && betIndex < this.fileEntries.length) {
+        const entry2 = this.fileEntries[betIndex];
+        if (entry2.flags & MPQ_FILE_EXISTS) {
+          if (!entry2.fileName) entry2.fileName = name;
+          return entry2;
+        }
+      }
+    }
+    const hashEntry = findHashEntry(this.hashTable, name, 0, this.fileEntries.length);
+    if (!hashEntry) return null;
+    const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;
+    if (blockIndex >= this.fileEntries.length) return null;
+    const entry = this.fileEntries[blockIndex];
+    if (!(entry.flags & MPQ_FILE_EXISTS)) return null;
+    if (!entry.fileName) {
+      entry.fileName = name;
+    }
+    return entry;
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new MpqError("Archive is closed");
+    }
+  }
+};
+function wildcardToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+export {
+  ATTRIBUTES_NAME,
+  ID_MPQ,
+  ID_MPQ_USERDATA,
+  LISTFILE_NAME,
+  MPQ_COMPRESSION_ADPCM_MONO,
+  MPQ_COMPRESSION_ADPCM_STEREO,
+  MPQ_COMPRESSION_BZIP2,
+  MPQ_COMPRESSION_HUFFMANN,
+  MPQ_COMPRESSION_LZMA,
+  MPQ_COMPRESSION_PKWARE,
+  MPQ_COMPRESSION_SPARSE,
+  MPQ_COMPRESSION_ZLIB,
+  MPQ_FILE_COMPRESS,
+  MPQ_FILE_ENCRYPTED,
+  MPQ_FILE_EXISTS,
+  MPQ_FILE_IMPLODE,
+  MPQ_FILE_KEY_V2,
+  MPQ_FILE_SINGLE_UNIT,
+  MPQ_FORMAT_VERSION_1,
+  MPQ_FORMAT_VERSION_2,
+  MPQ_FORMAT_VERSION_3,
+  MPQ_FORMAT_VERSION_4,
+  MpqArchive,
+  MpqCompressionError,
+  MpqCorruptError,
+  MpqEncryptionError,
+  MpqError,
+  MpqFile,
+  MpqNotFoundError,
+  MpqUnsupportedError,
+  SIGNATURE_NAME,
+  decryptBlock,
+  decryptFileKey,
+  encryptBlock,
+  getStormBuffer,
+  hashFileKey,
+  hashNameA,
+  hashNameB,
+  hashString,
+  hashTableIndex,
+  jenkinsHash
+};
+//# sourceMappingURL=index.mjs.map