stormlib-js 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -1,681 +1,133 @@
-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";
-  }
-};
+import {
+  ATTRIBUTES_NAME,
+  BLOCK_INDEX_MASK,
+  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_SECTOR_CRC,
+  MPQ_FILE_SINGLE_UNIT,
+  MPQ_FORMAT_VERSION_1,
+  MPQ_FORMAT_VERSION_2,
+  MPQ_FORMAT_VERSION_3,
+  MPQ_FORMAT_VERSION_4,
+  MpqCompressionError,
+  MpqCorruptError,
+  MpqEncryptionError,
+  MpqError,
+  MpqNotFoundError,
+  MpqUnsupportedError,
+  SIGNATURE_NAME,
+  __require,
+  __toCommonJS,
+  applyFileNames,
+  buildFileTable,
+  buildFileTableFromHetBet,
+  decompress,
+  decompressPkware,
+  decryptBlock,
+  decryptFileKey,
+  encryptBlock,
+  findHashEntry,
+  findHeader,
+  findInHetTable,
+  getBetTableOffset,
+  getBlockTableOffset,
+  getHashTableOffset,
+  getHetTableOffset,
+  getHiBlockTableOffset,
+  getSectorSize,
+  getStormBuffer,
+  hashFileKey,
+  hashNameA,
+  hashNameB,
+  hashString,
+  hashTableIndex,
+  init_pkware,
+  jenkinsHash,
+  loadBetTable,
+  loadBlockTable,
+  loadHashTable,
+  loadHetTable,
+  loadHiBlockTable,
+  parseAttributes,
+  parseListfile,
+  pkware_exports
+} from "./chunk-RRBXXQVG.mjs";
 
 // src/stream/file-stream.ts
-import * as fs from "fs";
-var FileStream = class _FileStream {
-  constructor(fd, fileSize, filePath) {
+var _FileStream = class _FileStream {
+  constructor(fd, fileSize, filePath, memoryData = null) {
     this.fd = fd;
     this.fileSize = fileSize;
     this.filePath = filePath;
+    this.memoryData = memoryData;
   }
   /**
    * Open a file for reading.
    */
   static open(path) {
+    const fs = _FileStream.getFs();
     const fd = fs.openSync(path, "r");
     const stat = fs.fstatSync(fd);
     return new _FileStream(fd, BigInt(stat.size), path);
   }
+  /**
+   * Create an in-memory stream from binary data.
+   */
+  static fromBuffer(data, filePath = "[buffer]") {
+    const buffer = _FileStream.normalizeBuffer(data);
+    return new _FileStream(-1, BigInt(buffer.length), filePath, buffer);
+  }
+  static normalizeBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+  }
+  static getRequire() {
+    try {
+      if (typeof __require === "function") {
+        return __require;
+      }
+    } catch {
+    }
+    try {
+      return Function('return typeof require === "function" ? require : null;')();
+    } catch {
+      return null;
+    }
+  }
+  static getFs() {
+    if (_FileStream.fsModule) {
+      return _FileStream.fsModule;
+    }
+    const req = _FileStream.getRequire();
+    if (!req) {
+      throw new Error("Node.js fs module is not available in this runtime. Use MpqArchive.openFromBuffer().");
+    }
+    const fs = req("fs");
+    if (!fs) {
+      throw new Error("Failed to load Node.js fs module.");
+    }
+    _FileStream.fsModule = fs;
+    return _FileStream.fsModule;
+  }
   /**
    * Read bytes at a given offset.
    *
@@ -684,6 +136,15 @@ var FileStream = class _FileStream {
    * @returns Buffer containing the read data
    */
   read(offset, length) {
+    if (this.memoryData) {
+      const start = Number(offset);
+      if (start >= this.memoryData.length || length <= 0) {
+        return Buffer.alloc(0);
+      }
+      const end = Math.min(start + length, this.memoryData.length);
+      return this.memoryData.subarray(start, end);
+    }
+    const fs = _FileStream.getFs();
     const buffer = Buffer.alloc(length);
     const bytesRead = fs.readSync(this.fd, buffer, 0, length, Number(offset));
     if (bytesRead < length) {
@@ -695,6 +156,15 @@ var FileStream = class _FileStream {
    * Read bytes into an existing buffer.
    */
   readInto(offset, buffer, bufOffset, length) {
+    if (this.memoryData) {
+      const start = Number(offset);
+      if (start >= this.memoryData.length || length <= 0) {
+        return 0;
+      }
+      const end = Math.min(start + length, this.memoryData.length);
+      return this.memoryData.copy(buffer, bufOffset, start, end);
+    }
+    const fs = _FileStream.getFs();
     return fs.readSync(this.fd, buffer, bufOffset, length, Number(offset));
   }
   /**
@@ -713,1685 +183,16 @@ var FileStream = class _FileStream {
    * Close the file stream.
    */
   close() {
-    if (this.fd >= 0) {
+    if (this.fd >= 0 && !this.memoryData) {
+      const fs = _FileStream.getFs();
       fs.closeSync(this.fd);
       this.fd = -1;
     }
+    this.memoryData = null;
   }
 };
-
-// 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);
-}
+_FileStream.fsModule = null;
+var FileStream = _FileStream;
 
 // src/file/sector-reader.ts
 init_pkware();
@@ -2581,6 +382,22 @@ var MpqArchive = class _MpqArchive {
    */
   static open(path, options) {
     const stream = FileStream.open(path);
+    return _MpqArchive.openFromStream(stream, options);
+  }
+  /**
+   * Open an MPQ archive from in-memory binary data.
+   *
+   * This API works in both Node.js and browser runtimes.
+   *
+   * @param data - MPQ binary contents
+   * @param options - Open options
+   * @returns MpqArchive instance
+   */
+  static openFromBuffer(data, options) {
+    const stream = FileStream.fromBuffer(data);
+    return _MpqArchive.openFromStream(stream, options);
+  }
+  static openFromStream(stream, options) {
     try {
       const noHeaderSearch = options?.noHeaderSearch ?? false;
       const { header, headerOffset } = findHeader(stream, noHeaderSearch);