stormlib-js 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/README.md +254 -0
  2. package/dist/index.d.mts +420 -0
  3. package/dist/index.d.ts +420 -0
  4. package/dist/index.js +2979 -0
  5. package/dist/index.js.map +1 -0
  6. package/dist/index.mjs +2920 -0
  7. package/dist/index.mjs.map +1 -0
  8. package/package.json +44 -0
package/dist/index.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"sources":["../src/compression/pkware.ts","../src/index.ts","../src/constants.ts","../src/errors.ts","../src/stream/file-stream.ts","../src/archive/header.ts","../src/crypto/storm-buffer.ts","../src/crypto/hash.ts","../src/crypto/cipher.ts","../src/tables/hash-table.ts","../src/tables/block-table.ts","../src/tables/het-table.ts","../src/tables/bet-table.ts","../src/tables/file-table.ts","../src/archive/listfile.ts","../src/compression/huffman.ts","../src/compression/index.ts","../src/compression/adpcm.ts","../src/compression/sparse.ts","../src/file/sector-reader.ts","../src/file/mpq-file.ts","../src/archive/mpq-archive.ts"],"sourcesContent":["/**\n * PKWARE Data Compression Library (DCL) Explode algorithm.\n * Ported from StormLib's pklib/ source code.\n *\n * This is the \"implode\" compression used by PKWARE (not the same as PKZip method 6).\n * Used in older Blizzard games (Diablo, StarCraft).\n */\n\n// Distance codes\nconst DIST_CODES: number[] = [\n 0x03, 0x0D, 0x05, 0x19, 0x09, 0x11, 0x01, 0x3E,\n 0x1E, 0x2E, 0x0E, 0x36, 0x16, 0x26, 0x06, 0x3A,\n 0x1A, 0x2A, 0x0A, 0x32, 0x12, 0x22, 0x42, 0x02,\n 0x7C, 0x3C, 0x5C, 0x1C, 0x6C, 0x2C, 0x4C, 0x0C,\n 0x74, 0x34, 0x54, 0x14, 0x64, 0x24, 0x44, 0x04,\n 0x78, 0x38, 0x58, 0x18, 0x68, 0x28, 0x48, 0x08,\n 0xF0, 0x70, 0xB0, 0x30, 0xD0, 0x50, 0x90, 0x10,\n 0xE0, 0x60, 0xA0, 0x20, 0xC0, 0x40, 0x80, 0x00,\n];\n\n// Distance extra bits\nconst DIST_BITS: number[] = [\n 0x02, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06,\n 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,\n 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07,\n 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,\n 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,\n 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,\n 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,\n 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,\n];\n\n// Length codes\nconst LENGTH_CODES: number[] = [\n 0x05, 0x03, 0x01, 0x06, 0x0A, 0x02, 0x0C, 0x14,\n 0x04, 0x18, 0x08, 0x30, 0x10, 0x20, 0x40, 0x00,\n];\n\n// Length extra bits\nconst LENGTH_BITS: number[] = [\n 0x03, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05,\n 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07,\n];\n\n// Byte->code map for character decoding\nconst CH_BITS_ASC: number[] = [\n 0x0B, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x0C, 0x08, 0x07, 0x0C, 0x0C, 0x07, 0x0C, 0x0C,\n 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x0C, 0x0C, 0x0D, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x04, 0x0A, 0x08, 0x0C, 0x0A, 0x0C, 0x0A, 0x08,\n 0x07, 0x07, 0x08, 0x09, 0x07, 0x06, 0x07, 0x08,\n 0x07, 0x06, 0x07, 0x07, 0x07, 0x07, 0x08, 0x07,\n 0x07, 0x08, 0x08, 0x0C, 0x0B, 0x07, 0x09, 0x0B,\n 0x0C, 0x06, 0x07, 0x06, 0x06, 0x05, 0x07, 0x08,\n 0x08, 0x06, 0x0B, 0x09, 0x06, 0x07, 0x06, 0x06,\n 0x07, 0x0B, 0x06, 0x06, 0x06, 0x07, 0x09, 0x08,\n 0x09, 0x09, 0x0B, 0x08, 0x0B, 0x09, 0x0C, 0x08,\n 0x0C, 0x05, 0x06, 0x06, 0x06, 0x05, 0x06, 0x06,\n 0x06, 0x05, 0x0B, 0x07, 0x05, 0x06, 0x05, 0x05,\n 0x06, 0x0A, 0x05, 0x05, 0x05, 0x05, 0x08, 0x07,\n 0x08, 0x08, 0x0A, 0x0B, 0x0B, 0x0C, 0x0C, 0x0C,\n 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,\n 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,\n 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,\n 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,\n 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,\n 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,\n 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C,\n 0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0C, 0x0D, 0x0D,\n 0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D, 0x0C, 0x0D,\n 0x0D, 0x0D, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D,\n 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D,\n];\n\nclass PkBitReader {\n private data: Buffer;\n private bytePos = 0;\n private bitBuf = 0;\n private bitsAvail = 0;\n\n constructor(data: Buffer) {\n this.data = data;\n }\n\n private fillBuffer(): void {\n while (this.bitsAvail <= 24 && this.bytePos < this.data.length) {\n this.bitBuf |= this.data[this.bytePos++] << this.bitsAvail;\n this.bitsAvail += 8;\n }\n }\n\n peekBits(n: number): number {\n this.fillBuffer();\n return this.bitBuf & ((1 << n) - 1);\n }\n\n skipBits(n: number): void {\n this.fillBuffer();\n this.bitBuf >>>= n;\n this.bitsAvail -= n;\n }\n\n readBits(n: number): number {\n const val = this.peekBits(n);\n this.skipBits(n);\n return val;\n }\n\n get isEof(): boolean {\n return this.bytePos >= this.data.length && this.bitsAvail === 0;\n }\n}\n\n/**\n * Build decode tables for PKWARE DCL.\n */\nfunction buildDecodeTables() {\n // Build position decode table\n const positionTable = new Uint8Array(256);\n for (let i = 0; i < DIST_CODES.length; i++) {\n const code = DIST_CODES[i];\n const bits = DIST_BITS[i];\n const mask = (1 << bits) - 1;\n // Fill table entries\n for (let j = code; j < 256; j++) {\n if ((j & mask) === (code & mask)) {\n // This is a simplified mapping; real lookup uses the table\n }\n }\n }\n\n return { positionTable };\n}\n\n/**\n * Decode a single length value from the PKWARE stream.\n */\nfunction decodeLength(reader: PkBitReader): number {\n // Look at 8 bits to find the length code\n const bits8 = reader.peekBits(8);\n\n let lengthCode = -1;\n for (let i = 0; i < LENGTH_CODES.length; i++) {\n const codeLen = LENGTH_BITS[i];\n const mask = (1 << codeLen) - 1;\n if ((bits8 & mask) === LENGTH_CODES[i]) {\n lengthCode = i;\n reader.skipBits(codeLen);\n break;\n }\n }\n\n if (lengthCode === -1) {\n // Fallback: try longer bit patterns\n for (let i = 0; i < LENGTH_CODES.length; i++) {\n const codeLen = LENGTH_BITS[i];\n const peek = reader.peekBits(codeLen);\n if (peek === LENGTH_CODES[i]) {\n lengthCode = i;\n reader.skipBits(codeLen);\n break;\n }\n }\n }\n\n if (lengthCode === -1) return -1;\n\n if (lengthCode === 15) {\n // Variable length extension\n return 0x0F + 0x100 + reader.readBits(8);\n }\n\n return lengthCode + 2;\n}\n\n/**\n * Decompress data using PKWARE DCL (Data Compression Library) Explode algorithm.\n *\n * @param inBuffer - Compressed input data\n * @param outSize - Expected decompressed size\n * @returns Decompressed data\n */\nexport function decompressPkware(inBuffer: Buffer, outSize: number): Buffer {\n if (inBuffer.length < 4) {\n return Buffer.from(inBuffer);\n }\n\n const output = Buffer.alloc(outSize);\n let outPos = 0;\n\n // First byte: compression type (0=binary, 1=ASCII)\n const compressionType = inBuffer[0];\n // Second byte: dictionary size bits (4, 5, or 6 => 1024, 2048, 4096)\n const dictSizeBits = inBuffer[1];\n const dictSize = (1 << dictSizeBits); // Unused directly but part of format\n\n const reader = new PkBitReader(inBuffer.subarray(2));\n\n while (outPos < outSize && !reader.isEof) {\n // Read one bit to determine if this is a literal or a copy\n const flag = reader.readBits(1);\n\n if (flag === 0) {\n // Literal byte\n if (compressionType === 0) {\n // Binary mode: 8-bit literal\n output[outPos++] = reader.readBits(8);\n } else {\n // ASCII mode: variable-length encoded literal\n let value = 0;\n const bits = reader.peekBits(8);\n\n // Decode using CH_BITS_ASC table\n let found = false;\n for (let i = 0; i < 256; i++) {\n const numBits = CH_BITS_ASC[i];\n // Simple decode: try matching the bit pattern\n const peek = reader.peekBits(numBits);\n // This is a simplified decode - full implementation needs the code table\n if (false) { // placeholder for proper ASCII decode\n value = i;\n reader.skipBits(numBits);\n found = true;\n break;\n }\n }\n if (!found) {\n // Fallback to 8-bit literal for ASCII\n output[outPos++] = reader.readBits(8);\n } else {\n output[outPos++] = value;\n }\n }\n } else {\n // Copy from dictionary (LZ77 match)\n // Decode the distance\n const distBits8 = reader.peekBits(8);\n let distCode = -1;\n\n for (let i = 0; i < DIST_CODES.length; i++) {\n if (DIST_CODES[i] === (distBits8 & ((1 << DIST_BITS[i]) - 1))) {\n distCode = i;\n reader.skipBits(DIST_BITS[i]);\n break;\n }\n }\n\n if (distCode === -1) {\n break; // Cannot decode distance\n }\n\n // Read the extra distance bits\n const distance = (distCode << dictSizeBits) | reader.readBits(dictSizeBits);\n\n // Decode the length\n const length = decodeLength(reader);\n if (length < 0) break;\n\n // Copy from output buffer (LZ77 back-reference)\n const srcPos = outPos - distance - 1;\n if (srcPos < 0) break;\n\n for (let i = 0; i < length && outPos < outSize; i++) {\n output[outPos] = output[srcPos + i];\n outPos++;\n }\n }\n }\n\n return output.subarray(0, outPos);\n}\n","/**\n * stormlib-js - Pure TypeScript implementation of StormLib for reading MPQ archives.\n *\n * @example\n * ```typescript\n * import { MpqArchive } from 'stormlib-js';\n *\n * const archive = MpqArchive.open('game.mpq');\n *\n * // List files\n * const files = archive.getFileList();\n * console.log(files);\n *\n * // Extract a file\n * const data = archive.extractFile('units\\\\terran\\\\marine.grp');\n *\n * // Search for files\n * const wavFiles = archive.findFiles('*.wav');\n *\n * archive.close();\n * ```\n */\n\n// Main API\nexport { MpqArchive } from './archive/mpq-archive';\nexport { MpqFile } from './file/mpq-file';\n\n// Types\nexport type {\n MpqHeader,\n MpqUserData,\n MpqHashEntry,\n MpqBlockEntry,\n FileEntry,\n FileFindData,\n OpenArchiveOptions,\n HetTableHeader,\n BetTableHeader,\n} from './types';\n\n// Errors\nexport {\n MpqError,\n MpqNotFoundError,\n MpqCorruptError,\n MpqUnsupportedError,\n MpqEncryptionError,\n MpqCompressionError,\n} from './errors';\n\n// Constants (for advanced usage)\nexport {\n ID_MPQ,\n ID_MPQ_USERDATA,\n MPQ_FORMAT_VERSION_1,\n MPQ_FORMAT_VERSION_2,\n MPQ_FORMAT_VERSION_3,\n MPQ_FORMAT_VERSION_4,\n MPQ_FILE_IMPLODE,\n MPQ_FILE_COMPRESS,\n MPQ_FILE_ENCRYPTED,\n MPQ_FILE_KEY_V2,\n MPQ_FILE_SINGLE_UNIT,\n MPQ_FILE_EXISTS,\n MPQ_COMPRESSION_HUFFMANN,\n MPQ_COMPRESSION_ZLIB,\n MPQ_COMPRESSION_PKWARE,\n MPQ_COMPRESSION_BZIP2,\n MPQ_COMPRESSION_LZMA,\n MPQ_COMPRESSION_SPARSE,\n MPQ_COMPRESSION_ADPCM_MONO,\n MPQ_COMPRESSION_ADPCM_STEREO,\n LISTFILE_NAME,\n SIGNATURE_NAME,\n ATTRIBUTES_NAME,\n} from './constants';\n\n// Low-level crypto (for advanced usage / testing)\nexport { hashString, hashTableIndex, hashNameA, hashNameB, hashFileKey, jenkinsHash } from './crypto/hash';\nexport { decryptBlock, encryptBlock, decryptFileKey } from './crypto/cipher';\nexport { getStormBuffer } from './crypto/storm-buffer';\n","// MPQ Archive Signatures\nexport const ID_MPQ = 0x1A51504D; // 'MPQ\\x1A'\nexport const ID_MPQ_USERDATA = 0x1B51504D; // 'MPQ\\x1B'\nexport const ID_MPQ_FILE = 0x46494C45; // 'FILE'\n\n// MPQ Format Versions\nexport const MPQ_FORMAT_VERSION_1 = 0;\nexport const MPQ_FORMAT_VERSION_2 = 1;\nexport const MPQ_FORMAT_VERSION_3 = 2;\nexport const MPQ_FORMAT_VERSION_4 = 3;\n\n// Header Sizes\nexport const MPQ_HEADER_SIZE_V1 = 0x20;\nexport const MPQ_HEADER_SIZE_V2 = 0x2C;\nexport const MPQ_HEADER_SIZE_V3 = 0x44;\nexport const MPQ_HEADER_SIZE_V4 = 0xD0;\n\n// Hash Table Constants\nexport const HASH_TABLE_SIZE_MIN = 0x00000004;\nexport const HASH_TABLE_SIZE_DEFAULT = 0x00001000;\nexport const HASH_TABLE_SIZE_MAX = 0x00080000;\nexport const HASH_ENTRY_DELETED = 0xFFFFFFFE;\nexport const HASH_ENTRY_FREE = 0xFFFFFFFF;\nexport const HET_ENTRY_DELETED = 0x80;\nexport const HET_ENTRY_FREE = 0x00;\n\n// Hash Types (offsets into StormBuffer)\nexport const MPQ_HASH_TABLE_INDEX = 0x000;\nexport const MPQ_HASH_NAME_A = 0x100;\nexport const MPQ_HASH_NAME_B = 0x200;\nexport const MPQ_HASH_FILE_KEY = 0x300;\nexport const MPQ_HASH_KEY2_MIX = 0x400;\n\n// Storm Buffer\nexport const STORM_BUFFER_SIZE = 0x500;\n\n// Well-Known Encryption Keys\nexport const MPQ_KEY_HASH_TABLE = 0xC3AF3770;\nexport const MPQ_KEY_BLOCK_TABLE = 0xEC83B3A3;\n\n// File Flags (TMPQBlock.dwFlags)\nexport const MPQ_FILE_IMPLODE = 0x00000100;\nexport const MPQ_FILE_COMPRESS = 0x00000200;\nexport const MPQ_FILE_ENCRYPTED = 0x00010000;\nexport const MPQ_FILE_KEY_V2 = 0x00020000;\nexport const MPQ_FILE_PATCH_FILE = 0x00100000;\nexport const MPQ_FILE_SINGLE_UNIT = 0x01000000;\nexport const MPQ_FILE_DELETE_MARKER = 0x02000000;\nexport const MPQ_FILE_SECTOR_CRC = 0x04000000;\nexport const MPQ_FILE_SIGNATURE = 0x10000000;\nexport const MPQ_FILE_EXISTS = 0x80000000;\nexport const MPQ_FILE_COMPRESS_MASK = 0x0000FF00;\n\n// Compression IDs (bitmask)\nexport const MPQ_COMPRESSION_HUFFMANN = 0x01;\nexport const MPQ_COMPRESSION_ZLIB = 0x02;\nexport const MPQ_COMPRESSION_PKWARE = 0x08;\nexport const MPQ_COMPRESSION_BZIP2 = 0x10;\nexport const MPQ_COMPRESSION_LZMA = 0x12;\nexport const MPQ_COMPRESSION_SPARSE = 0x20;\nexport const MPQ_COMPRESSION_ADPCM_MONO = 0x40;\nexport const MPQ_COMPRESSION_ADPCM_STEREO = 0x80;\n\n// Open Archive Flags\nexport const MPQ_OPEN_NO_LISTFILE = 0x00010000;\nexport const MPQ_OPEN_NO_ATTRIBUTES = 0x00020000;\nexport const MPQ_OPEN_NO_HEADER_SEARCH = 0x00040000;\nexport const MPQ_OPEN_FORCE_MPQ_V1 = 0x00080000;\nexport const MPQ_OPEN_CHECK_SECTOR_CRC = 0x00100000;\nexport const MPQ_OPEN_READ_ONLY = 0x00000100;\n\n// Table Signatures\nexport const HET_TABLE_SIGNATURE = 0x1A544548; // 'HET\\x1a'\nexport const BET_TABLE_SIGNATURE = 0x1A544542; // 'BET\\x1a'\n\n// Block Index\nexport const BLOCK_INDEX_MASK = 0x0FFFFFFF;\n\n// Internal File Names\nexport const LISTFILE_NAME = '(listfile)';\nexport const SIGNATURE_NAME = '(signature)';\nexport const ATTRIBUTES_NAME = '(attributes)';\n\n// Invalid markers\nexport const SFILE_INVALID_SIZE = 0xFFFFFFFF;\n\n// MPQ search alignment\nexport const MPQ_HEADER_SEARCH_ALIGNMENT = 0x200;\n","export class MpqError extends Error {\n constructor(message: string) {\n super(message);\n this.name = 'MpqError';\n }\n}\n\nexport class MpqNotFoundError extends MpqError {\n constructor(message = 'File not found in archive') {\n super(message);\n this.name = 'MpqNotFoundError';\n }\n}\n\nexport class MpqCorruptError extends MpqError {\n constructor(message = 'Archive data is corrupt') {\n super(message);\n this.name = 'MpqCorruptError';\n }\n}\n\nexport class MpqUnsupportedError extends MpqError {\n constructor(message = 'Unsupported feature') {\n super(message);\n this.name = 'MpqUnsupportedError';\n }\n}\n\nexport class MpqEncryptionError extends MpqError {\n constructor(message = 'Unable to decrypt data') {\n super(message);\n this.name = 'MpqEncryptionError';\n }\n}\n\nexport class MpqCompressionError extends MpqError {\n constructor(message = 'Decompression failed') {\n super(message);\n this.name = 'MpqCompressionError';\n }\n}\n","/**\n * File stream abstraction for reading MPQ archives from disk.\n * Uses Node.js fs module for synchronous positioned reads.\n */\n\nimport * as fs from 'fs';\n\nexport class FileStream {\n private fd: number;\n private fileSize: bigint;\n private filePath: string;\n\n private constructor(fd: number, fileSize: bigint, filePath: string) {\n this.fd = fd;\n this.fileSize = fileSize;\n this.filePath = filePath;\n }\n\n /**\n * Open a file for reading.\n */\n static open(path: string): FileStream {\n const fd = fs.openSync(path, 'r');\n const stat = fs.fstatSync(fd);\n return new FileStream(fd, BigInt(stat.size), path);\n }\n\n /**\n * Read bytes at a given offset.\n *\n * @param offset - Byte offset from the beginning of the file\n * @param length - Number of bytes to read\n * @returns Buffer containing the read data\n */\n read(offset: bigint, length: number): Buffer {\n const buffer = Buffer.alloc(length);\n const bytesRead = fs.readSync(this.fd, buffer, 0, length, Number(offset));\n if (bytesRead < length) {\n return buffer.subarray(0, bytesRead);\n }\n return buffer;\n }\n\n /**\n * Read bytes into an existing buffer.\n */\n readInto(offset: bigint, buffer: Buffer, bufOffset: number, length: number): number {\n return fs.readSync(this.fd, buffer, bufOffset, length, Number(offset));\n }\n\n /**\n * Get the total file size.\n */\n getSize(): bigint {\n return this.fileSize;\n }\n\n /**\n * Get the file path.\n */\n getPath(): string {\n return this.filePath;\n }\n\n /**\n * Close the file stream.\n */\n close(): void {\n if (this.fd >= 0) {\n fs.closeSync(this.fd);\n this.fd = -1;\n }\n }\n}\n","/**\n * MPQ header parsing for all format versions (V1-V4).\n *\n * The MPQ header is located by searching for the 'MPQ\\x1A' signature.\n * Different versions extend the base header with additional fields.\n */\n\nimport {\n ID_MPQ,\n ID_MPQ_USERDATA,\n MPQ_FORMAT_VERSION_1,\n MPQ_FORMAT_VERSION_2,\n MPQ_FORMAT_VERSION_3,\n MPQ_FORMAT_VERSION_4,\n MPQ_HEADER_SIZE_V1,\n MPQ_HEADER_SIZE_V2,\n MPQ_HEADER_SIZE_V3,\n MPQ_HEADER_SIZE_V4,\n MPQ_HEADER_SEARCH_ALIGNMENT,\n} from '../constants';\nimport type { MpqHeader, MpqUserData } from '../types';\nimport { MpqCorruptError, MpqNotFoundError } from '../errors';\nimport { FileStream } from '../stream/file-stream';\n\n/**\n * Create a default (zeroed) MPQ header with all fields initialized.\n */\nfunction createDefaultHeader(): MpqHeader {\n return {\n dwID: 0,\n dwHeaderSize: 0,\n dwArchiveSize: 0,\n wFormatVersion: 0,\n wSectorSize: 0,\n dwHashTablePos: 0,\n dwBlockTablePos: 0,\n dwHashTableSize: 0,\n dwBlockTableSize: 0,\n hiBlockTablePos64: 0n,\n wHashTablePosHi: 0,\n wBlockTablePosHi: 0,\n archiveSize64: 0n,\n betTablePos64: 0n,\n hetTablePos64: 0n,\n hashTableSize64: 0n,\n blockTableSize64: 0n,\n hiBlockTableSize64: 0n,\n hetTableSize64: 0n,\n betTableSize64: 0n,\n dwRawChunkSize: 0,\n md5BlockTable: new Uint8Array(16),\n md5HashTable: new Uint8Array(16),\n md5HiBlockTable: new Uint8Array(16),\n md5BetTable: new Uint8Array(16),\n md5HetTable: new Uint8Array(16),\n md5MpqHeader: new Uint8Array(16),\n };\n}\n\n/**\n * Parse a V1 MPQ header (32 bytes).\n */\nfunction parseHeaderV1(data: Buffer, header: MpqHeader): void {\n header.dwID = data.readUInt32LE(0x00);\n header.dwHeaderSize = data.readUInt32LE(0x04);\n header.dwArchiveSize = data.readUInt32LE(0x08);\n header.wFormatVersion = data.readUInt16LE(0x0C);\n header.wSectorSize = data.readUInt16LE(0x0E);\n header.dwHashTablePos = data.readUInt32LE(0x10);\n header.dwBlockTablePos = data.readUInt32LE(0x14);\n header.dwHashTableSize = data.readUInt32LE(0x18);\n header.dwBlockTableSize = data.readUInt32LE(0x1C);\n\n // Normalize V1 to unified format\n header.archiveSize64 = BigInt(header.dwArchiveSize);\n header.hashTableSize64 = BigInt(header.dwHashTableSize * 16);\n header.blockTableSize64 = BigInt(header.dwBlockTableSize * 16);\n}\n\n/**\n * Parse V2 extensions (additional 12 bytes).\n */\nfunction parseHeaderV2(data: Buffer, header: MpqHeader): void {\n if (data.length < MPQ_HEADER_SIZE_V2) return;\n\n header.hiBlockTablePos64 = data.readBigUInt64LE(0x20);\n header.wHashTablePosHi = data.readUInt16LE(0x28);\n header.wBlockTablePosHi = data.readUInt16LE(0x2A);\n}\n\n/**\n * Parse V3 extensions (additional 24 bytes).\n */\nfunction parseHeaderV3(data: Buffer, header: MpqHeader): void {\n if (data.length < MPQ_HEADER_SIZE_V3) return;\n\n header.archiveSize64 = data.readBigUInt64LE(0x2C);\n header.betTablePos64 = data.readBigUInt64LE(0x34);\n header.hetTablePos64 = data.readBigUInt64LE(0x3C);\n}\n\n/**\n * Parse V4 extensions (additional 140 bytes).\n */\nfunction parseHeaderV4(data: Buffer, header: MpqHeader): void {\n if (data.length < MPQ_HEADER_SIZE_V4) return;\n\n header.hashTableSize64 = data.readBigUInt64LE(0x44);\n header.blockTableSize64 = data.readBigUInt64LE(0x4C);\n header.hiBlockTableSize64 = data.readBigUInt64LE(0x54);\n header.hetTableSize64 = data.readBigUInt64LE(0x5C);\n header.betTableSize64 = data.readBigUInt64LE(0x64);\n header.dwRawChunkSize = data.readUInt32LE(0x6C);\n\n header.md5BlockTable = new Uint8Array(data.subarray(0x70, 0x80));\n header.md5HashTable = new Uint8Array(data.subarray(0x80, 0x90));\n header.md5HiBlockTable = new Uint8Array(data.subarray(0x90, 0xA0));\n header.md5BetTable = new Uint8Array(data.subarray(0xA0, 0xB0));\n header.md5HetTable = new Uint8Array(data.subarray(0xB0, 0xC0));\n header.md5MpqHeader = new Uint8Array(data.subarray(0xC0, 0xD0));\n}\n\n/**\n * Parse an MPQ header from raw bytes.\n */\nexport function parseHeader(data: Buffer): MpqHeader {\n if (data.length < MPQ_HEADER_SIZE_V1) {\n throw new MpqCorruptError('Header data too small');\n }\n\n const header = createDefaultHeader();\n parseHeaderV1(data, header);\n\n if (header.dwID !== ID_MPQ) {\n throw new MpqCorruptError(`Invalid MPQ signature: 0x${header.dwID.toString(16)}`);\n }\n\n // Parse version-specific extensions\n if (header.wFormatVersion >= MPQ_FORMAT_VERSION_2) {\n parseHeaderV2(data, header);\n }\n if (header.wFormatVersion >= MPQ_FORMAT_VERSION_3) {\n parseHeaderV3(data, header);\n }\n if (header.wFormatVersion >= MPQ_FORMAT_VERSION_4) {\n parseHeaderV4(data, header);\n }\n\n return header;\n}\n\n/**\n * Parse a user data header.\n */\nexport function parseUserData(data: Buffer): MpqUserData {\n return {\n dwID: data.readUInt32LE(0x00),\n cbUserDataSize: data.readUInt32LE(0x04),\n dwHeaderOffs: data.readUInt32LE(0x08),\n cbUserDataHeader: data.readUInt32LE(0x0C),\n };\n}\n\n/** Result of searching for the MPQ header in a file */\nexport interface HeaderSearchResult {\n header: MpqHeader;\n headerOffset: bigint;\n userData?: MpqUserData;\n userDataOffset?: bigint;\n}\n\n/**\n * Search for the MPQ header in a file stream.\n *\n * The MPQ header can be found at 0x200-byte aligned offsets.\n * User data (MPQ\\x1B) may precede the actual header.\n *\n * @param stream - File stream to search\n * @param noHeaderSearch - If true, only check offset 0\n * @returns Header search result with header, offset, and optional user data\n */\nexport function findHeader(stream: FileStream, noHeaderSearch = false): HeaderSearchResult {\n const fileSize = stream.getSize();\n const searchLimit = noHeaderSearch ? 0n : fileSize;\n\n let userData: MpqUserData | undefined;\n let userDataOffset: bigint | undefined;\n\n for (let offset = 0n; offset <= searchLimit; offset += BigInt(MPQ_HEADER_SEARCH_ALIGNMENT)) {\n // Read enough for the signature check\n const sigBuf = stream.read(offset, 4);\n if (sigBuf.length < 4) break;\n\n const signature = sigBuf.readUInt32LE(0);\n\n if (signature === ID_MPQ_USERDATA && !noHeaderSearch) {\n // Found user data - read the full user data header\n const udBuf = stream.read(offset, 16);\n if (udBuf.length >= 16) {\n userData = parseUserData(udBuf);\n userDataOffset = offset;\n\n // Jump to the MPQ header indicated by the user data\n const mpqOffset = offset + BigInt(userData.dwHeaderOffs);\n const headerBuf = stream.read(mpqOffset, MPQ_HEADER_SIZE_V4);\n if (headerBuf.length >= MPQ_HEADER_SIZE_V1) {\n const headerSig = headerBuf.readUInt32LE(0);\n if (headerSig === ID_MPQ) {\n const header = parseHeader(headerBuf);\n return { header, headerOffset: mpqOffset, userData, userDataOffset };\n }\n }\n }\n } else if (signature === ID_MPQ) {\n // Found MPQ header directly\n const headerBuf = stream.read(offset, MPQ_HEADER_SIZE_V4);\n if (headerBuf.length >= MPQ_HEADER_SIZE_V1) {\n const header = parseHeader(headerBuf);\n return { header, headerOffset: offset, userData, userDataOffset };\n }\n }\n\n // If we don't search, only check offset 0\n if (noHeaderSearch) break;\n }\n\n throw new MpqNotFoundError('MPQ header not found in file');\n}\n\n/**\n * Compute absolute table positions from the header, considering\n * V2+ extended offsets.\n */\nexport function getHashTableOffset(header: MpqHeader, archiveOffset: bigint): bigint {\n let offset = BigInt(header.dwHashTablePos);\n if (header.wFormatVersion >= MPQ_FORMAT_VERSION_2) {\n offset |= BigInt(header.wHashTablePosHi) << 32n;\n }\n return archiveOffset + offset;\n}\n\nexport function getBlockTableOffset(header: MpqHeader, archiveOffset: bigint): bigint {\n let offset = BigInt(header.dwBlockTablePos);\n if (header.wFormatVersion >= MPQ_FORMAT_VERSION_2) {\n offset |= BigInt(header.wBlockTablePosHi) << 32n;\n }\n return archiveOffset + offset;\n}\n\nexport function getHiBlockTableOffset(header: MpqHeader, archiveOffset: bigint): bigint {\n if (header.wFormatVersion >= MPQ_FORMAT_VERSION_2 && header.hiBlockTablePos64 !== 0n) {\n return archiveOffset + header.hiBlockTablePos64;\n }\n return 0n;\n}\n\nexport function getHetTableOffset(header: MpqHeader, archiveOffset: bigint): bigint {\n if (header.wFormatVersion >= MPQ_FORMAT_VERSION_3 && header.hetTablePos64 !== 0n) {\n return archiveOffset + header.hetTablePos64;\n }\n return 0n;\n}\n\nexport function getBetTableOffset(header: MpqHeader, archiveOffset: bigint): bigint {\n if (header.wFormatVersion >= MPQ_FORMAT_VERSION_3 && header.betTablePos64 !== 0n) {\n return archiveOffset + header.betTablePos64;\n }\n return 0n;\n}\n\n/** Get the sector size from the header's sector size shift value */\nexport function getSectorSize(header: MpqHeader): number {\n return 512 << header.wSectorSize;\n}\n","import { STORM_BUFFER_SIZE } from '../constants';\n\n/**\n * The StormBuffer is a 0x500 (1280) entry DWORD lookup table used by\n * all MPQ cryptographic operations. It is divided into 5 sections of 256\n * entries each, one for each hash type.\n *\n * Initialized using a Linear Congruential Generator (LCG).\n */\nconst stormBuffer = new Uint32Array(STORM_BUFFER_SIZE);\nlet initialized = false;\n\nfunction initializeStormBuffer(): void {\n let seed = 0x00100001;\n\n for (let index1 = 0; index1 < 0x100; index1++) {\n let index2 = index1;\n for (let i = 0; i < 5; i++, index2 += 0x100) {\n seed = (seed * 125 + 3) % 0x2AAAAB;\n const temp1 = (seed & 0xFFFF) << 0x10;\n\n seed = (seed * 125 + 3) % 0x2AAAAB;\n const temp2 = seed & 0xFFFF;\n\n stormBuffer[index2] = (temp1 | temp2) >>> 0;\n }\n }\n\n initialized = true;\n}\n\nexport function getStormBuffer(): Uint32Array {\n if (!initialized) {\n initializeStormBuffer();\n }\n return stormBuffer;\n}\n","import {\n MPQ_HASH_TABLE_INDEX,\n MPQ_HASH_NAME_A,\n MPQ_HASH_NAME_B,\n MPQ_HASH_FILE_KEY,\n} from '../constants';\nimport { getStormBuffer } from './storm-buffer';\n\n/**\n * AsciiToUpperTable: converts a-z to A-Z and '/' (0x2F) to '\\' (0x5C).\n * All other bytes pass through unchanged. This is essential for MPQ path normalization.\n */\nconst AsciiToUpperTable = new Uint8Array([\n 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,\n 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,\n 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x5C, // '/' -> '\\'\n 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,\n 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,\n 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,\n 0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,\n 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,\n 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,\n 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,\n 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,\n 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,\n 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,\n 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,\n 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,\n 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,\n]);\n\n/**\n * Compute MPQ hash of a string. The hashType selects which section of the\n * StormBuffer to use:\n * - MPQ_HASH_TABLE_INDEX (0x000): hash table slot\n * - MPQ_HASH_NAME_A (0x100): file name verification hash 1\n * - MPQ_HASH_NAME_B (0x200): file name verification hash 2\n * - MPQ_HASH_FILE_KEY (0x300): encryption key derivation\n */\nexport function hashString(str: string, hashType: number): number {\n const buffer = getStormBuffer();\n let seed1 = 0x7FED7FED;\n let seed2 = 0xEEEEEEEE;\n\n for (let i = 0; i < str.length; i++) {\n const ch = AsciiToUpperTable[str.charCodeAt(i) & 0xFF];\n\n seed1 = (buffer[hashType + ch] ^ ((seed1 + seed2) >>> 0)) >>> 0;\n seed2 = ((ch + seed1 + seed2 + (seed2 << 5) + 3) & 0xFFFFFFFF) >>> 0;\n }\n\n return seed1 >>> 0;\n}\n\n/** Convenience: compute hash table index */\nexport function hashTableIndex(fileName: string): number {\n return hashString(fileName, MPQ_HASH_TABLE_INDEX);\n}\n\n/** Convenience: compute name hash A */\nexport function hashNameA(fileName: string): number {\n return hashString(fileName, MPQ_HASH_NAME_A);\n}\n\n/** Convenience: compute name hash B */\nexport function hashNameB(fileName: string): number {\n return hashString(fileName, MPQ_HASH_NAME_B);\n}\n\n/** Convenience: compute file encryption key hash */\nexport function hashFileKey(fileName: string): number {\n return hashString(fileName, MPQ_HASH_FILE_KEY);\n}\n\n/**\n * Jenkins hashlittle2 - used for HET/BET tables (64-bit hash).\n * Produces a 64-bit hash as a BigInt.\n */\nexport function jenkinsHash(str: string): bigint {\n let a = 0xDEADBEEF + str.length;\n let b = a;\n let c = a;\n\n let i = 0;\n while (i + 12 <= str.length) {\n a = (a + str.charCodeAt(i)) >>> 0;\n a = (a + (str.charCodeAt(i + 1) << 8)) >>> 0;\n a = (a + (str.charCodeAt(i + 2) << 16)) >>> 0;\n a = (a + ((str.charCodeAt(i + 3) << 24) >>> 0)) >>> 0;\n b = (b + str.charCodeAt(i + 4)) >>> 0;\n b = (b + (str.charCodeAt(i + 5) << 8)) >>> 0;\n b = (b + (str.charCodeAt(i + 6) << 16)) >>> 0;\n b = (b + ((str.charCodeAt(i + 7) << 24) >>> 0)) >>> 0;\n c = (c + str.charCodeAt(i + 8)) >>> 0;\n c = (c + (str.charCodeAt(i + 9) << 8)) >>> 0;\n c = (c + (str.charCodeAt(i + 10) << 16)) >>> 0;\n c = (c + ((str.charCodeAt(i + 11) << 24) >>> 0)) >>> 0;\n\n // mix\n a = (a - c) >>> 0; a = (a ^ ((c << 4) | (c >>> 28))) >>> 0; c = (c + b) >>> 0;\n b = (b - a) >>> 0; b = (b ^ ((a << 6) | (a >>> 26))) >>> 0; a = (a + c) >>> 0;\n c = (c - b) >>> 0; c = (c ^ ((b << 8) | (b >>> 24))) >>> 0; b = (b + a) >>> 0;\n a = (a - c) >>> 0; a = (a ^ ((c << 16) | (c >>> 16))) >>> 0; c = (c + b) >>> 0;\n b = (b - a) >>> 0; b = (b ^ ((a << 19) | (a >>> 13))) >>> 0; a = (a + c) >>> 0;\n c = (c - b) >>> 0; c = (c ^ ((b << 4) | (b >>> 28))) >>> 0; b = (b + a) >>> 0;\n\n i += 12;\n }\n\n // Handle remaining bytes\n const remaining = str.length - i;\n switch (remaining) {\n case 12: c = (c + ((str.charCodeAt(i + 11) << 24) >>> 0)) >>> 0; // fallthrough\n case 11: c = (c + (str.charCodeAt(i + 10) << 16)) >>> 0;\n case 10: c = (c + (str.charCodeAt(i + 9) << 8)) >>> 0;\n case 9: c = (c + str.charCodeAt(i + 8)) >>> 0;\n case 8: b = (b + ((str.charCodeAt(i + 7) << 24) >>> 0)) >>> 0;\n case 7: b = (b + (str.charCodeAt(i + 6) << 16)) >>> 0;\n case 6: b = (b + (str.charCodeAt(i + 5) << 8)) >>> 0;\n case 5: b = (b + str.charCodeAt(i + 4)) >>> 0;\n case 4: a = (a + ((str.charCodeAt(i + 3) << 24) >>> 0)) >>> 0;\n case 3: a = (a + (str.charCodeAt(i + 2) << 16)) >>> 0;\n case 2: a = (a + (str.charCodeAt(i + 1) << 8)) >>> 0;\n case 1: a = (a + str.charCodeAt(i)) >>> 0;\n break;\n case 0: return (BigInt(c >>> 0) << 32n) | BigInt(b >>> 0);\n }\n\n // final mix\n c = (c ^ b) >>> 0; c = (c - ((b << 14) | (b >>> 18))) >>> 0;\n a = (a ^ c) >>> 0; a = (a - ((c << 11) | (c >>> 21))) >>> 0;\n b = (b ^ a) >>> 0; b = (b - ((a << 25) | (a >>> 7))) >>> 0;\n c = (c ^ b) >>> 0; c = (c - ((b << 16) | (b >>> 16))) >>> 0;\n a = (a ^ c) >>> 0; a = (a - ((c << 4) | (c >>> 28))) >>> 0;\n b = (b ^ a) >>> 0; b = (b - ((a << 14) | (a >>> 18))) >>> 0;\n c = (c ^ b) >>> 0; c = (c - ((b << 24) | (b >>> 8))) >>> 0;\n\n return (BigInt(c >>> 0) << 32n) | BigInt(b >>> 0);\n}\n\n/** Extract the plain file name from a path (after last '/' or '\\') */\nexport function getPlainFileName(filePath: string): string {\n let plainStart = 0;\n for (let i = 0; i < filePath.length; i++) {\n const ch = filePath.charCodeAt(i);\n if (ch === 0x5C || ch === 0x2F) { // '\\' or '/'\n plainStart = i + 1;\n }\n }\n return filePath.substring(plainStart);\n}\n","import { MPQ_HASH_KEY2_MIX, MPQ_HASH_FILE_KEY, MPQ_FILE_KEY_V2 } from '../constants';\nimport { getStormBuffer } from './storm-buffer';\nimport { hashString, getPlainFileName } from './hash';\n\n/**\n * Decrypt an MPQ data block in-place.\n * The buffer must be DWORD-aligned (length must be a multiple of 4).\n *\n * @param data - Buffer to decrypt (modified in place)\n * @param key - Primary encryption key (DWORD)\n */\nexport function decryptBlock(data: Buffer, key: number): void {\n const buffer = getStormBuffer();\n const dwCount = data.length >>> 2;\n let dwKey1 = key >>> 0;\n let dwKey2 = 0xEEEEEEEE;\n\n for (let i = 0; i < dwCount; i++) {\n dwKey2 = ((dwKey2 + buffer[MPQ_HASH_KEY2_MIX + (dwKey1 & 0xFF)]) & 0xFFFFFFFF) >>> 0;\n\n const encrypted = data.readUInt32LE(i * 4);\n const decrypted = (encrypted ^ ((dwKey1 + dwKey2) >>> 0)) >>> 0;\n data.writeUInt32LE(decrypted, i * 4);\n\n dwKey1 = (((~dwKey1 << 0x15) + 0x11111111) | (dwKey1 >>> 0x0B)) >>> 0;\n dwKey2 = ((decrypted + dwKey2 + (dwKey2 << 5) + 3) & 0xFFFFFFFF) >>> 0;\n }\n}\n\n/**\n * Encrypt an MPQ data block in-place.\n *\n * @param data - Buffer to encrypt (modified in place)\n * @param key - Primary encryption key (DWORD)\n */\nexport function encryptBlock(data: Buffer, key: number): void {\n const buffer = getStormBuffer();\n const dwCount = data.length >>> 2;\n let dwKey1 = key >>> 0;\n let dwKey2 = 0xEEEEEEEE;\n\n for (let i = 0; i < dwCount; i++) {\n dwKey2 = ((dwKey2 + buffer[MPQ_HASH_KEY2_MIX + (dwKey1 & 0xFF)]) & 0xFFFFFFFF) >>> 0;\n\n const plaintext = data.readUInt32LE(i * 4);\n const encrypted = (plaintext ^ ((dwKey1 + dwKey2) >>> 0)) >>> 0;\n data.writeUInt32LE(encrypted, i * 4);\n\n dwKey1 = (((~dwKey1 << 0x15) + 0x11111111) | (dwKey1 >>> 0x0B)) >>> 0;\n dwKey2 = ((plaintext + dwKey2 + (dwKey2 << 5) + 3) & 0xFFFFFFFF) >>> 0;\n }\n}\n\n/**\n * Calculate the decryption key for a file within an MPQ archive.\n *\n * @param fileName - Full path of the file within the archive\n * @param byteOffset - File's offset within the archive (lower 32 bits)\n * @param fileSize - Uncompressed file size\n * @param flags - File flags from block table\n * @returns The file decryption key\n */\nexport function decryptFileKey(\n fileName: string,\n byteOffset: bigint,\n fileSize: number,\n flags: number,\n): number {\n const plainName = getPlainFileName(fileName);\n let key = hashString(plainName, MPQ_HASH_FILE_KEY);\n\n if (flags & MPQ_FILE_KEY_V2) {\n key = ((key + Number(byteOffset & 0xFFFFFFFFn)) ^ fileSize) >>> 0;\n }\n\n return key >>> 0;\n}\n\n/**\n * Attempt to detect a file's encryption key by analyzing the sector offset table.\n * The first DWORD of the sector offset table is known to be the size of the\n * sector offset table itself.\n *\n * @param encryptedData - First 8 bytes of encrypted sector offset table\n * @param sectorSize - Expected sector size\n * @param fileSize - Uncompressed file size\n * @returns The detected key, or 0 if detection failed\n */\nexport function detectFileKeyBySectorSize(\n encryptedData: Buffer,\n sectorSize: number,\n fileSize: number,\n): number {\n const buffer = getStormBuffer();\n\n if (encryptedData.length < 8) return 0;\n\n const encrypted0 = encryptedData.readUInt32LE(0);\n const encrypted1 = encryptedData.readUInt32LE(4);\n\n // The first DWORD of the sector offset table is the number of sectors + 1,\n // multiplied by 4 (each offset is a DWORD)\n const sectorCount = Math.floor((fileSize + sectorSize - 1) / sectorSize);\n const expectedValue = (sectorCount + 1) * 4;\n\n // Try possible values for the first decrypted DWORD\n for (let dwDecrypted0 = expectedValue; dwDecrypted0 < expectedValue + 4; dwDecrypted0++) {\n const dwDecrypted1Max = sectorSize + dwDecrypted0;\n const dwKey1PlusKey2 = ((encrypted0 ^ dwDecrypted0) - 0xEEEEEEEE) >>> 0;\n\n for (let i = 0; i < 0x100; i++) {\n let dwKey1 = (dwKey1PlusKey2 - buffer[MPQ_HASH_KEY2_MIX + i]) >>> 0;\n let dwKey2 = 0xEEEEEEEE;\n\n // Verify first DWORD\n dwKey2 = ((dwKey2 + buffer[MPQ_HASH_KEY2_MIX + (dwKey1 & 0xFF)]) & 0xFFFFFFFF) >>> 0;\n const test0 = (encrypted0 ^ ((dwKey1 + dwKey2) >>> 0)) >>> 0;\n\n if (test0 === (dwDecrypted0 >>> 0)) {\n const saveKey1 = (dwKey1 + 1) >>> 0;\n\n // Advance key state\n dwKey1 = (((~dwKey1 << 0x15) + 0x11111111) | (dwKey1 >>> 0x0B)) >>> 0;\n dwKey2 = ((test0 + dwKey2 + (dwKey2 << 5) + 3) & 0xFFFFFFFF) >>> 0;\n dwKey2 = ((dwKey2 + buffer[MPQ_HASH_KEY2_MIX + (dwKey1 & 0xFF)]) & 0xFFFFFFFF) >>> 0;\n const test1 = (encrypted1 ^ ((dwKey1 + dwKey2) >>> 0)) >>> 0;\n\n // Second DWORD must be a valid sector offset\n if (test1 <= dwDecrypted1Max) {\n return saveKey1 >>> 0;\n }\n }\n }\n }\n\n return 0;\n}\n","/**\n * MPQ Hash Table operations.\n *\n * The hash table maps file names to block table indices using open addressing\n * (linear probing). Each entry is 16 bytes containing two name verification\n * hashes, locale info, and a block index.\n */\n\nimport {\n MPQ_KEY_HASH_TABLE,\n MPQ_HASH_TABLE_INDEX,\n MPQ_HASH_NAME_A,\n MPQ_HASH_NAME_B,\n HASH_ENTRY_FREE,\n HASH_ENTRY_DELETED,\n BLOCK_INDEX_MASK,\n} from '../constants';\nimport type { MpqHashEntry } from '../types';\nimport { decryptBlock } from '../crypto/cipher';\nimport { hashString } from '../crypto/hash';\nimport { FileStream } from '../stream/file-stream';\n\n/**\n * Load and decrypt the hash table from disk.\n *\n * @param stream - File stream\n * @param offset - Absolute offset of the hash table\n * @param count - Number of hash table entries\n * @returns Array of parsed hash entries\n */\nexport function loadHashTable(stream: FileStream, offset: bigint, count: number): MpqHashEntry[] {\n const dataSize = count * 16;\n const data = stream.read(offset, dataSize);\n\n if (data.length < dataSize) {\n // Table may be truncated - adjust count\n count = Math.floor(data.length / 16);\n }\n\n // Decrypt the hash table\n decryptBlock(data, MPQ_KEY_HASH_TABLE);\n\n // Parse entries\n const entries: MpqHashEntry[] = new Array(count);\n for (let i = 0; i < count; i++) {\n const off = i * 16;\n entries[i] = {\n dwName1: data.readUInt32LE(off + 0x00),\n dwName2: data.readUInt32LE(off + 0x04),\n lcLocale: data.readUInt16LE(off + 0x08),\n platform: data[off + 0x0A],\n dwBlockIndex: data.readUInt32LE(off + 0x0C),\n };\n }\n\n return entries;\n}\n\n/**\n * Look up a file in the hash table.\n *\n * Uses three hashes: one for the table index, two for name verification.\n * Linear probing is used to handle collisions.\n *\n * @param hashTable - Loaded hash table entries\n * @param fileName - File name to look up\n * @param locale - Locale filter (0 = neutral / any)\n * @param maxBlockIndex - Maximum valid block index\n * @returns The hash entry if found, null otherwise\n */\nexport function findHashEntry(\n hashTable: MpqHashEntry[],\n fileName: string,\n locale: number,\n maxBlockIndex: number,\n): MpqHashEntry | null {\n if (hashTable.length === 0) return null;\n\n const tableSize = hashTable.length;\n const mask = tableSize - 1; // Hash table size is always power of 2\n\n const startIndex = hashString(fileName, MPQ_HASH_TABLE_INDEX) & mask;\n const hashCheck1 = hashString(fileName, MPQ_HASH_NAME_A);\n const hashCheck2 = hashString(fileName, MPQ_HASH_NAME_B);\n\n let index = startIndex;\n\n for (;;) {\n const entry = hashTable[index];\n\n // Check if this entry matches\n if (entry.dwName1 === hashCheck1 &&\n entry.dwName2 === hashCheck2 &&\n (entry.dwBlockIndex & BLOCK_INDEX_MASK) < maxBlockIndex) {\n // Locale check: if looking for specific locale, match it;\n // otherwise accept any\n if (locale === 0 || entry.lcLocale === locale || entry.lcLocale === 0) {\n return entry;\n }\n }\n\n // Empty slot = file definitely not in table\n if (entry.dwBlockIndex === HASH_ENTRY_FREE) {\n return null;\n }\n\n // Deleted slot = skip and continue probing\n // Move to next slot (linear probing with wraparound)\n index = (index + 1) & mask;\n\n // Full circle = not found\n if (index === startIndex) {\n return null;\n }\n }\n}\n\n/**\n * Find all hash entries for a given file name (multiple locales).\n */\nexport function findAllHashEntries(\n hashTable: MpqHashEntry[],\n fileName: string,\n maxBlockIndex: number,\n): MpqHashEntry[] {\n if (hashTable.length === 0) return [];\n\n const results: MpqHashEntry[] = [];\n const tableSize = hashTable.length;\n const mask = tableSize - 1;\n\n const startIndex = hashString(fileName, MPQ_HASH_TABLE_INDEX) & mask;\n const hashCheck1 = hashString(fileName, MPQ_HASH_NAME_A);\n const hashCheck2 = hashString(fileName, MPQ_HASH_NAME_B);\n\n let index = startIndex;\n\n for (;;) {\n const entry = hashTable[index];\n\n if (entry.dwName1 === hashCheck1 &&\n entry.dwName2 === hashCheck2 &&\n (entry.dwBlockIndex & BLOCK_INDEX_MASK) < maxBlockIndex) {\n results.push(entry);\n }\n\n if (entry.dwBlockIndex === HASH_ENTRY_FREE) break;\n\n index = (index + 1) & mask;\n if (index === startIndex) break;\n }\n\n return results;\n}\n","/**\n * MPQ Block Table operations.\n *\n * The block table stores metadata for each file in the archive:\n * offset, compressed size, uncompressed size, and flags.\n * Each entry is 16 bytes.\n *\n * V2+ archives also have a Hi-Block table storing the upper 16 bits\n * of the file offset for 64-bit addressing.\n */\n\nimport { MPQ_KEY_BLOCK_TABLE } from '../constants';\nimport type { MpqBlockEntry } from '../types';\nimport { decryptBlock } from '../crypto/cipher';\nimport { FileStream } from '../stream/file-stream';\n\n/**\n * Load and decrypt the block table from disk.\n *\n * @param stream - File stream\n * @param offset - Absolute offset of the block table\n * @param count - Number of block table entries\n * @returns Array of parsed block entries\n */\nexport function loadBlockTable(stream: FileStream, offset: bigint, count: number): MpqBlockEntry[] {\n const dataSize = count * 16;\n const data = stream.read(offset, dataSize);\n\n if (data.length < dataSize) {\n count = Math.floor(data.length / 16);\n }\n\n // Decrypt the block table\n decryptBlock(data, MPQ_KEY_BLOCK_TABLE);\n\n // Parse entries\n const entries: MpqBlockEntry[] = new Array(count);\n for (let i = 0; i < count; i++) {\n const off = i * 16;\n entries[i] = {\n dwFilePos: data.readUInt32LE(off + 0x00),\n dwCSize: data.readUInt32LE(off + 0x04),\n dwFSize: data.readUInt32LE(off + 0x08),\n dwFlags: data.readUInt32LE(off + 0x0C),\n };\n }\n\n return entries;\n}\n\n/**\n * Load the Hi-Block table (V2+).\n * Contains the upper 16 bits of each file's offset.\n *\n * @param stream - File stream\n * @param offset - Absolute offset of the hi-block table\n * @param count - Number of entries (same as block table)\n * @returns Array of high offset values (upper 16 bits)\n */\nexport function loadHiBlockTable(stream: FileStream, offset: bigint, count: number): Uint16Array {\n const dataSize = count * 2;\n const data = stream.read(offset, dataSize);\n\n const hiOffsets = new Uint16Array(count);\n const actualCount = Math.min(count, Math.floor(data.length / 2));\n\n for (let i = 0; i < actualCount; i++) {\n hiOffsets[i] = data.readUInt16LE(i * 2);\n }\n\n return hiOffsets;\n}\n","/**\n * HET (Hash Extended Table) for MPQ V3+ archives.\n *\n * The HET table uses Jenkins hash (upper 8 bits) for probing and\n * stores BET indices in a variable bit-width array.\n */\n\nimport { HET_TABLE_SIGNATURE, HET_ENTRY_FREE, HET_ENTRY_DELETED } from '../constants';\nimport { MpqCorruptError } from '../errors';\nimport { decryptBlock } from '../crypto/cipher';\nimport { hashString } from '../crypto/hash';\nimport { jenkinsHash } from '../crypto/hash';\nimport { FileStream } from '../stream/file-stream';\n\nexport interface HetTable {\n hashTableSize: number;\n maxFileCount: number;\n hashEntrySize: number;\n totalIndexSize: number;\n indexSizeExtra: number;\n indexSize: number;\n /** Hash values (upper 8 bits of Jenkins hash) */\n hetHashes: Uint8Array;\n /** BET indices encoded in variable bit-width */\n betIndices: number[];\n}\n\n/**\n * Read bits from a byte array at arbitrary bit positions.\n */\nfunction readBits(data: Uint8Array, bitOffset: number, numBits: number): number {\n let result = 0;\n for (let i = 0; i < numBits; i++) {\n const byteIdx = (bitOffset + i) >>> 3;\n const bitIdx = (bitOffset + i) & 7;\n if (byteIdx < data.length && (data[byteIdx] & (1 << bitIdx))) {\n result |= (1 << i);\n }\n }\n return result;\n}\n\n/**\n * Load and parse the HET table from disk.\n *\n * @param stream - File stream\n * @param offset - Absolute offset of the HET table\n * @param compressedSize - Compressed size (from header)\n * @returns Parsed HET table\n */\nexport function loadHetTable(\n stream: FileStream,\n offset: bigint,\n compressedSize: bigint,\n): HetTable | null {\n if (offset === 0n) return null;\n\n // Read the ext header (12 bytes)\n const extHeaderBuf = stream.read(offset, 12);\n if (extHeaderBuf.length < 12) return null;\n\n const signature = extHeaderBuf.readUInt32LE(0);\n if (signature !== HET_TABLE_SIGNATURE) return null;\n\n const version = extHeaderBuf.readUInt32LE(4);\n const dataSize = extHeaderBuf.readUInt32LE(8);\n\n // Read the HET data\n const dataBuf = stream.read(offset + 12n, dataSize);\n if (dataBuf.length < dataSize) return null;\n\n // Decrypt if needed (HET table key is derived from signature)\n // Note: HET/BET tables in practice are not encrypted in most MPQ files\n\n // Parse HET header fields (within dataBuf)\n let pos = 0;\n const hashTableSize = dataBuf.readUInt32LE(pos); pos += 4;\n const maxFileCount = dataBuf.readUInt32LE(pos); pos += 4;\n const hetHashTableSize = dataBuf.readUInt32LE(pos); pos += 4;\n const hashEntrySize = dataBuf.readUInt32LE(pos); pos += 4;\n const totalIndexSize = dataBuf.readUInt32LE(pos); pos += 4;\n const indexSizeExtra = dataBuf.readUInt32LE(pos); pos += 4;\n const indexSize = dataBuf.readUInt32LE(pos); pos += 4;\n const blockTableSize = dataBuf.readUInt32LE(pos); pos += 4;\n\n // Read het hash array\n const hetHashes = new Uint8Array(dataBuf.subarray(pos, pos + hetHashTableSize));\n pos += hetHashTableSize;\n\n // Read BET index array (variable bit-width packed)\n const betIndexBits = new Uint8Array(dataBuf.subarray(pos));\n const betIndices: number[] = new Array(hetHashTableSize);\n\n for (let i = 0; i < hetHashTableSize; i++) {\n betIndices[i] = readBits(betIndexBits, i * totalIndexSize, totalIndexSize);\n }\n\n return {\n hashTableSize: hetHashTableSize,\n maxFileCount,\n hashEntrySize,\n totalIndexSize,\n indexSizeExtra,\n indexSize,\n hetHashes,\n betIndices,\n };\n}\n\n/**\n * Look up a file in the HET table using Jenkins hash.\n *\n * @param het - HET table\n * @param fileName - File name to look up\n * @returns BET index if found, -1 otherwise\n */\nexport function findInHetTable(het: HetTable, fileName: string): number {\n if (!het || het.hashTableSize === 0) return -1;\n\n // Compute Jenkins hash and extract the upper 8 bits for HET lookup\n const fullHash = jenkinsHash(fileName);\n const hashByte = Number((fullHash >> 56n) & 0xFFn) | 0x80; // Set high bit\n\n const startIndex = Number(fullHash % BigInt(het.hashTableSize));\n let index = startIndex;\n\n for (;;) {\n const hetHash = het.hetHashes[index];\n\n if (hetHash === HET_ENTRY_FREE) {\n return -1; // Not found\n }\n\n if (hetHash === hashByte) {\n // Potential match - return the BET index for further verification\n return het.betIndices[index];\n }\n\n // Skip deleted entries, continue probing\n index = (index + 1) % het.hashTableSize;\n if (index === startIndex) return -1;\n }\n}\n","/**\n * BET (Block Extended Table) for MPQ V3+ archives.\n *\n * The BET table stores file metadata in minimum bit-width packed arrays.\n * Each field (offset, size, compressed size, flags, etc.) uses only\n * the minimum number of bits needed to represent all values.\n */\n\nimport { BET_TABLE_SIGNATURE } from '../constants';\nimport type { FileEntry } from '../types';\nimport { FileStream } from '../stream/file-stream';\n\nexport interface BetTable {\n maxFileCount: number;\n flagCount: number;\n flags: number[];\n entries: BetFileEntry[];\n}\n\ninterface BetFileEntry {\n fileNameHash: bigint;\n byteOffset: bigint;\n fileSize: number;\n cmpSize: number;\n flagIndex: number;\n}\n\n/**\n * Read bits from a byte array at arbitrary bit positions.\n */\nfunction readBits(data: Uint8Array, bitOffset: number, numBits: number): number {\n let result = 0;\n for (let i = 0; i < numBits; i++) {\n const byteIdx = (bitOffset + i) >>> 3;\n const bitIdx = (bitOffset + i) & 7;\n if (byteIdx < data.length && (data[byteIdx] & (1 << bitIdx))) {\n result |= (1 << i);\n }\n }\n return result;\n}\n\nfunction readBits64(data: Uint8Array, bitOffset: number, numBits: number): bigint {\n let result = 0n;\n for (let i = 0; i < numBits; i++) {\n const byteIdx = (bitOffset + i) >>> 3;\n const bitIdx = (bitOffset + i) & 7;\n if (byteIdx < data.length && (data[byteIdx] & (1 << bitIdx))) {\n result |= (1n << BigInt(i));\n }\n }\n return result;\n}\n\n/**\n * Load and parse the BET table from disk.\n *\n * @param stream - File stream\n * @param offset - Absolute offset of the BET table\n * @param compressedSize - Compressed size (from header)\n * @returns Parsed BET table\n */\nexport function loadBetTable(\n stream: FileStream,\n offset: bigint,\n compressedSize: bigint,\n): BetTable | null {\n if (offset === 0n) return null;\n\n // Read the ext header (12 bytes)\n const extHeaderBuf = stream.read(offset, 12);\n if (extHeaderBuf.length < 12) return null;\n\n const signature = extHeaderBuf.readUInt32LE(0);\n if (signature !== BET_TABLE_SIGNATURE) return null;\n\n const version = extHeaderBuf.readUInt32LE(4);\n const dataSize = extHeaderBuf.readUInt32LE(8);\n\n // Read the BET data\n const dataBuf = stream.read(offset + 12n, dataSize);\n if (dataBuf.length < dataSize) return null;\n\n let pos = 0;\n\n // BET header\n const tableSize = dataBuf.readUInt32LE(pos); pos += 4;\n const maxFileCount = dataBuf.readUInt32LE(pos); pos += 4;\n const flagCount = dataBuf.readUInt32LE(pos); pos += 4;\n\n // Bit sizes for each field\n const filePosBits = dataBuf.readUInt32LE(pos); pos += 4;\n const fileSizeBits = dataBuf.readUInt32LE(pos); pos += 4;\n const cmpSizeBits = dataBuf.readUInt32LE(pos); pos += 4;\n const flagIndexBits = dataBuf.readUInt32LE(pos); pos += 4;\n const unknownBits = dataBuf.readUInt32LE(pos); pos += 4;\n\n // Bit sizes for the hash portion\n const hashSizeBits = dataBuf.readUInt32LE(pos); pos += 4;\n const hashSizeTotal = dataBuf.readUInt32LE(pos); pos += 4;\n const hashSizeExtra = dataBuf.readUInt32LE(pos); pos += 4;\n const hashArraySize = dataBuf.readUInt32LE(pos); pos += 4;\n\n // Read flags array\n const flags: number[] = [];\n for (let i = 0; i < flagCount; i++) {\n flags.push(dataBuf.readUInt32LE(pos));\n pos += 4;\n }\n\n // Calculate total bits per file entry\n const bitsPerEntry = filePosBits + fileSizeBits + cmpSizeBits + flagIndexBits + unknownBits;\n\n // Read packed file entries\n const entryData = new Uint8Array(dataBuf.subarray(pos));\n const entries: BetFileEntry[] = [];\n\n for (let i = 0; i < maxFileCount; i++) {\n let bitOff = i * bitsPerEntry;\n\n const byteOffset = readBits64(entryData, bitOff, filePosBits);\n bitOff += filePosBits;\n\n const fileSize = readBits(entryData, bitOff, fileSizeBits);\n bitOff += fileSizeBits;\n\n const cmpSize = readBits(entryData, bitOff, cmpSizeBits);\n bitOff += cmpSizeBits;\n\n const flagIndex = readBits(entryData, bitOff, flagIndexBits);\n bitOff += flagIndexBits;\n\n // Skip unknown bits\n\n // Read file name hash from the hash array (follows the entry data)\n const hashBitOffset = maxFileCount * bitsPerEntry + i * hashSizeTotal;\n const fileNameHash = readBits64(entryData, hashBitOffset, hashSizeTotal);\n\n entries.push({\n fileNameHash,\n byteOffset,\n fileSize,\n cmpSize,\n flagIndex,\n });\n }\n\n return { maxFileCount, flagCount, flags, entries };\n}\n\n/**\n * Get a file entry from the BET table by index.\n */\nexport function getBetEntry(bet: BetTable, index: number): FileEntry | null {\n if (index < 0 || index >= bet.entries.length) return null;\n\n const entry = bet.entries[index];\n const flags = entry.flagIndex < bet.flags.length ? bet.flags[entry.flagIndex] : 0;\n\n return {\n fileNameHash: entry.fileNameHash,\n byteOffset: entry.byteOffset,\n fileTime: 0n,\n fileSize: entry.fileSize,\n cmpSize: entry.cmpSize,\n flags,\n crc32: 0,\n md5: new Uint8Array(16),\n fileName: '',\n };\n}\n","/**\n * Unified file table that merges hash table, block table, hi-block table,\n * and optionally HET/BET tables into a single TFileEntry array.\n */\n\nimport { MPQ_FILE_EXISTS, HASH_ENTRY_FREE, HASH_ENTRY_DELETED, BLOCK_INDEX_MASK, MPQ_HASH_TABLE_INDEX, MPQ_HASH_NAME_A, MPQ_HASH_NAME_B } from '../constants';\nimport type { MpqHeader, MpqHashEntry, MpqBlockEntry, FileEntry } from '../types';\nimport type { HetTable } from './het-table';\nimport type { BetTable } from './bet-table';\nimport { getBetEntry } from './bet-table';\nimport { hashString } from '../crypto/hash';\n\n/**\n * Build a unified file table from classic hash + block tables.\n *\n * @param hashTable - Loaded hash table entries\n * @param blockTable - Loaded block table entries\n * @param hiBlockTable - Optional hi-block table (V2+)\n * @returns Array of unified file entries indexed by block index\n */\nexport function buildFileTable(\n hashTable: MpqHashEntry[],\n blockTable: MpqBlockEntry[],\n hiBlockTable: Uint16Array | null,\n): FileEntry[] {\n const fileCount = blockTable.length;\n const entries: FileEntry[] = new Array(fileCount);\n\n // Initialize all file entries from the block table\n for (let i = 0; i < fileCount; i++) {\n const block = blockTable[i];\n let byteOffset = BigInt(block.dwFilePos);\n\n // Apply hi-block offset if available\n if (hiBlockTable && i < hiBlockTable.length) {\n byteOffset |= BigInt(hiBlockTable[i]) << 32n;\n }\n\n entries[i] = {\n fileNameHash: 0n,\n byteOffset,\n fileTime: 0n,\n fileSize: block.dwFSize,\n cmpSize: block.dwCSize,\n flags: block.dwFlags,\n crc32: 0,\n md5: new Uint8Array(16),\n fileName: '',\n };\n }\n\n return entries;\n}\n\n/**\n * Build a unified file table from HET/BET tables (V3+).\n */\nexport function buildFileTableFromHetBet(\n het: HetTable,\n bet: BetTable,\n): FileEntry[] {\n const entries: FileEntry[] = [];\n\n for (let i = 0; i < bet.entries.length; i++) {\n const entry = getBetEntry(bet, i);\n if (entry) {\n entries.push(entry);\n }\n }\n\n return entries;\n}\n\n/**\n * Map file names from the hash table onto the file entry array.\n * This associates hash table entries with their corresponding file entries.\n */\nexport function mapHashToFileEntries(\n hashTable: MpqHashEntry[],\n fileEntries: FileEntry[],\n): void {\n // The hash table doesn't store names directly - we can only\n // establish the mapping. Names are applied later from (listfile).\n // This function is primarily used to verify the hash-to-block mapping.\n}\n\n/**\n * Apply file names from a parsed listfile to the file entries.\n *\n * @param fileEntries - File entry array\n * @param hashTable - Hash table for lookup\n * @param names - Array of file names from (listfile)\n */\nexport function applyFileNames(\n fileEntries: FileEntry[],\n hashTable: MpqHashEntry[],\n names: string[],\n): void {\n const tableSize = hashTable.length;\n if (tableSize === 0) return;\n const mask = tableSize - 1;\n\n for (const name of names) {\n if (!name) continue;\n\n const startIndex = hashString(name, MPQ_HASH_TABLE_INDEX) & mask;\n const check1 = hashString(name, MPQ_HASH_NAME_A);\n const check2 = hashString(name, MPQ_HASH_NAME_B);\n\n let index = startIndex;\n for (;;) {\n const entry = hashTable[index];\n\n if (entry.dwName1 === check1 &&\n entry.dwName2 === check2 &&\n (entry.dwBlockIndex & BLOCK_INDEX_MASK) < fileEntries.length) {\n const blockIndex = entry.dwBlockIndex & BLOCK_INDEX_MASK;\n if (!fileEntries[blockIndex].fileName) {\n fileEntries[blockIndex].fileName = name;\n }\n break;\n }\n\n if (entry.dwBlockIndex === HASH_ENTRY_FREE) break;\n\n index = (index + 1) & mask;\n if (index === startIndex) break;\n }\n }\n}\n","/**\n * (listfile) parsing for MPQ archives.\n *\n * The (listfile) is a special internal file that contains a list of all\n * file names in the archive, one per line (separated by \\r\\n or \\n).\n */\n\n/**\n * Parse a (listfile) buffer into an array of file names.\n *\n * @param data - Raw (listfile) contents\n * @returns Array of file path strings\n */\nexport function parseListfile(data: Buffer): string[] {\n const text = data.toString('utf8');\n const names: string[] = [];\n\n for (const line of text.split(/\\r?\\n/)) {\n const trimmed = line.trim();\n if (trimmed.length > 0) {\n names.push(trimmed);\n }\n }\n\n return names;\n}\n\n/**\n * Parse the (attributes) file.\n *\n * Format:\n * - DWORD version (100)\n * - DWORD flags (bitmask: 1=CRC32, 2=FILETIME, 4=MD5)\n * - Then for each file in the block table (in order):\n * - If flags & 1: DWORD CRC32\n * - If flags & 2: QWORD FILETIME\n * - If flags & 4: 16 bytes MD5\n *\n * @param data - Raw (attributes) contents\n * @param fileCount - Number of files in the block table\n * @returns Parsed attributes\n */\nexport interface FileAttributes {\n crc32s: number[];\n fileTimes: bigint[];\n md5s: Uint8Array[];\n}\n\nexport function parseAttributes(data: Buffer, fileCount: number): FileAttributes | null {\n if (data.length < 8) return null;\n\n const version = data.readUInt32LE(0);\n const flags = data.readUInt32LE(4);\n\n if (version !== 100) return null;\n\n const result: FileAttributes = {\n crc32s: [],\n fileTimes: [],\n md5s: [],\n };\n\n let offset = 8;\n\n // CRC32 values\n if (flags & 0x01) {\n for (let i = 0; i < fileCount && offset + 4 <= data.length; i++) {\n result.crc32s.push(data.readUInt32LE(offset));\n offset += 4;\n }\n }\n\n // FILETIME values\n if (flags & 0x02) {\n for (let i = 0; i < fileCount && offset + 8 <= data.length; i++) {\n result.fileTimes.push(data.readBigUInt64LE(offset));\n offset += 8;\n }\n }\n\n // MD5 values\n if (flags & 0x04) {\n for (let i = 0; i < fileCount && offset + 16 <= data.length; i++) {\n result.md5s.push(new Uint8Array(data.subarray(offset, offset + 16)));\n offset += 16;\n }\n }\n\n return result;\n}\n","/**\n * Blizzard's custom Huffman decompression, ported from StormLib's huffman.cpp.\n *\n * This is NOT standard Huffman coding. It uses a specific tree structure and\n * decomposition algorithm unique to MPQ archives (primarily used in\n * Diablo/StarCraft original).\n */\n\n/** Huffman tree node */\ninterface HuffNode {\n weight: number;\n child0: number; // index or -1\n child1: number; // index or -1\n parent: number; // index or -1\n value: number; // byte value for leaf nodes, -1 for internal\n}\n\n/** Predefined weight tables for different compression types */\nconst WEIGHT_TABLES: Record<number, number[]> = {\n // Generic text compression (type 0)\n 0: [\n 0x0A0B, 0x0A08, 0x0A07, 0x0A06, 0x0A0A, 0x0A09, 0x0A05, 0x0A04,\n 0x0A03, 0x0A02, 0x0A01, 0x0A00, 0x090F, 0x090E, 0x090D, 0x090C,\n 0x090B, 0x090A, 0x0909, 0x0908, 0x0907, 0x0906, 0x0905, 0x0904,\n 0x0903, 0x0902, 0x0901, 0x0900, 0x080F, 0x080E, 0x080D, 0x080C,\n 0x080B, 0x080A, 0x0809, 0x0808, 0x0807, 0x0806, 0x0805, 0x0804,\n 0x0803, 0x0802, 0x0801, 0x0800, 0x070F, 0x070E, 0x070D, 0x070C,\n 0x070B, 0x070A, 0x0709, 0x0708, 0x0707, 0x0706, 0x0705, 0x0704,\n 0x0703, 0x0702, 0x0701, 0x0700, 0x060F, 0x060E, 0x060D, 0x060C,\n 0x060B, 0x060A, 0x0609, 0x0608, 0x0607, 0x0606, 0x0605, 0x0604,\n 0x0603, 0x0602, 0x0601, 0x0600, 0x050F, 0x050E, 0x050D, 0x050C,\n 0x050B, 0x050A, 0x0509, 0x0508, 0x0507, 0x0506, 0x0505, 0x0504,\n 0x0503, 0x0502, 0x0501, 0x0500, 0x040F, 0x040E, 0x040D, 0x040C,\n 0x040B, 0x040A, 0x0409, 0x0408, 0x0407, 0x0406, 0x0405, 0x0404,\n 0x0403, 0x0402, 0x0401, 0x0400, 0x030F, 0x030E, 0x030D, 0x030C,\n 0x030B, 0x030A, 0x0309, 0x0308, 0x0307, 0x0306, 0x0305, 0x0304,\n 0x0303, 0x0302, 0x0301, 0x0300, 0x020F, 0x020E, 0x020D, 0x020C,\n 0x020B, 0x020A, 0x0209, 0x0208, 0x0207, 0x0206, 0x0205, 0x0204,\n 0x0203, 0x0202, 0x0201, 0x0200, 0x010F, 0x010E, 0x010D, 0x010C,\n 0x010B, 0x010A, 0x0109, 0x0108, 0x0107, 0x0106, 0x0105, 0x0104,\n 0x0103, 0x0102, 0x0101, 0x0100, 0x000F, 0x000E, 0x000D, 0x000C,\n 0x000B, 0x000A, 0x0009, 0x0008, 0x0007, 0x0006, 0x0005, 0x0004,\n 0x0003, 0x0002, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002,\n ],\n};\n\n/** Bit reader for the Huffman stream */\nclass BitReader {\n private data: Buffer;\n private bitPos = 0;\n\n constructor(data: Buffer) {\n this.data = data;\n }\n\n readBits(numBits: number): number {\n let result = 0;\n\n for (let i = 0; i < numBits; i++) {\n const byteIndex = this.bitPos >>> 3;\n const bitIndex = this.bitPos & 7;\n\n if (byteIndex >= this.data.length) return result;\n\n if (this.data[byteIndex] & (1 << bitIndex)) {\n result |= (1 << i);\n }\n this.bitPos++;\n }\n\n return result;\n }\n\n readBit(): number {\n const byteIndex = this.bitPos >>> 3;\n const bitIndex = this.bitPos & 7;\n\n if (byteIndex >= this.data.length) return 0;\n\n const bit = (this.data[byteIndex] >>> bitIndex) & 1;\n this.bitPos++;\n return bit;\n }\n\n get isEof(): boolean {\n return (this.bitPos >>> 3) >= this.data.length;\n }\n}\n\nconst MAX_TREE_ITEMS = 0x203;\nconst HUFF_ITEM_UNUSED = -1;\n\n/**\n * Blizzard Huffman tree decompression.\n */\nclass HuffmanTree {\n private nodes: HuffNode[] = [];\n private root = -1;\n private items256: number[] = new Array(256).fill(-1);\n\n constructor(compressionType: number) {\n this.buildTree(compressionType);\n }\n\n private buildTree(compressionType: number): void {\n const weights = WEIGHT_TABLES[compressionType] || WEIGHT_TABLES[0];\n\n // Initialize nodes for all 256 byte values + 1 sentinel\n for (let i = 0; i < 257; i++) {\n this.nodes.push({\n weight: (i < 256) ? (weights ? (weights[i] || 0) : 0) : 0,\n child0: -1,\n child1: -1,\n parent: -1,\n value: i,\n });\n }\n\n // Build the tree bottom-up using a priority-queue approach\n // Sort leaf nodes by weight\n const leafIndices = Array.from({ length: 257 }, (_, i) => i)\n .filter(i => this.nodes[i].weight > 0 || i === 256);\n\n leafIndices.sort((a, b) => this.nodes[a].weight - this.nodes[b].weight);\n\n // Build tree by repeatedly combining two lowest weight nodes\n const active = [...leafIndices];\n\n while (active.length > 1) {\n const idx0 = active.shift()!;\n const idx1 = active.shift()!;\n\n const parentIdx = this.nodes.length;\n this.nodes.push({\n weight: this.nodes[idx0].weight + this.nodes[idx1].weight,\n child0: idx0,\n child1: idx1,\n parent: -1,\n value: -1,\n });\n\n this.nodes[idx0].parent = parentIdx;\n this.nodes[idx1].parent = parentIdx;\n\n // Insert into active list maintaining sort order\n let insertAt = active.length;\n for (let j = 0; j < active.length; j++) {\n if (this.nodes[parentIdx].weight <= this.nodes[active[j]].weight) {\n insertAt = j;\n break;\n }\n }\n active.splice(insertAt, 0, parentIdx);\n }\n\n if (active.length > 0) {\n this.root = active[0];\n }\n\n // Build fast lookup for leaf nodes\n for (let i = 0; i < 256; i++) {\n if (this.nodes[i].weight > 0) {\n this.items256[i] = i;\n }\n }\n }\n\n decodeOne(reader: BitReader): number {\n if (this.root === -1) return -1;\n\n let current = this.root;\n\n while (this.nodes[current].value === -1) {\n const bit = reader.readBit();\n if (bit === 0) {\n current = this.nodes[current].child0;\n } else {\n current = this.nodes[current].child1;\n }\n if (current === -1) return -1;\n }\n\n return this.nodes[current].value;\n }\n}\n\n/**\n * Decompress data using Blizzard's custom Huffman algorithm.\n *\n * @param inBuffer - Compressed input data\n * @param outSize - Expected decompressed size\n * @returns Decompressed data\n */\nexport function decompressHuffman(inBuffer: Buffer, outSize: number): Buffer {\n if (inBuffer.length === 0) {\n return Buffer.alloc(outSize);\n }\n\n // First byte is the compression type for weight table selection\n const compressionType = inBuffer[0];\n const reader = new BitReader(inBuffer.subarray(1));\n\n const tree = new HuffmanTree(compressionType);\n const output = Buffer.alloc(outSize);\n let outPos = 0;\n\n while (outPos < outSize && !reader.isEof) {\n const value = tree.decodeOne(reader);\n if (value < 0 || value === 256) break; // 256 = end of stream\n output[outPos++] = value & 0xFF;\n }\n\n return output;\n}\n","/**\n * MPQ compression/decompression dispatcher.\n *\n * MPQ sectors can use multiple compression algorithms chained together.\n * The first byte of a compressed sector is a bitmask indicating which\n * algorithms were applied. Decompression is applied in reverse order.\n */\n\nimport {\n MPQ_COMPRESSION_HUFFMANN,\n MPQ_COMPRESSION_ZLIB,\n MPQ_COMPRESSION_PKWARE,\n MPQ_COMPRESSION_BZIP2,\n MPQ_COMPRESSION_LZMA,\n MPQ_COMPRESSION_SPARSE,\n MPQ_COMPRESSION_ADPCM_MONO,\n MPQ_COMPRESSION_ADPCM_STEREO,\n} from '../constants';\nimport { MpqCompressionError, MpqUnsupportedError } from '../errors';\nimport { decompressHuffman } from './huffman';\nimport { decompressPkware } from './pkware';\nimport { decompressAdpcmMono, decompressAdpcmStereo } from './adpcm';\nimport { decompressSparse } from './sparse';\n\n// pako for zlib\nimport pako from 'pako';\n\ntype Decompressor = (inBuffer: Buffer, outSize: number) => Buffer;\n\n/**\n * Decompression table entry. Order matters: decompression is applied\n * in this order (reverse of compression order).\n */\ninterface DecompressEntry {\n mask: number;\n decompress: Decompressor;\n}\n\nfunction decompressZlib(inBuffer: Buffer, outSize: number): Buffer {\n const result = pako.inflate(inBuffer);\n return Buffer.from(result.buffer, result.byteOffset, result.byteLength);\n}\n\nfunction decompressBzip2(_inBuffer: Buffer, _outSize: number): Buffer {\n throw new MpqUnsupportedError('BZIP2 decompression is not supported. Install a bzip2 package if needed.');\n}\n\nfunction decompressLzma(_inBuffer: Buffer, _outSize: number): Buffer {\n throw new MpqUnsupportedError('LZMA decompression is not supported. Install an LZMA package if needed.');\n}\n\n/** Decompression table in application order (reverse of compression order) */\nconst DECOMPRESS_TABLE: DecompressEntry[] = [\n { mask: MPQ_COMPRESSION_BZIP2, decompress: decompressBzip2 },\n { mask: MPQ_COMPRESSION_PKWARE, decompress: decompressPkware },\n { mask: MPQ_COMPRESSION_ZLIB, decompress: decompressZlib },\n { mask: MPQ_COMPRESSION_HUFFMANN, decompress: decompressHuffman },\n { mask: MPQ_COMPRESSION_ADPCM_STEREO, decompress: decompressAdpcmStereo },\n { mask: MPQ_COMPRESSION_ADPCM_MONO, decompress: decompressAdpcmMono },\n { mask: MPQ_COMPRESSION_SPARSE, decompress: decompressSparse },\n];\n\n/**\n * Decompress an MPQ data block.\n *\n * @param inBuffer - Compressed data (first byte is compression bitmask)\n * @param outSize - Expected decompressed size\n * @returns Decompressed data\n */\nexport function decompress(inBuffer: Buffer, outSize: number): Buffer {\n // If sizes match, data is uncompressed\n if (inBuffer.length === outSize) {\n return Buffer.from(inBuffer);\n }\n\n if (inBuffer.length === 0) {\n throw new MpqCompressionError('Empty input buffer');\n }\n\n // First byte is the compression bitmask\n const compressionMask = inBuffer[0];\n let data = inBuffer.subarray(1);\n\n // Special case: LZMA is 0x12 which overlaps with BZIP2|ZLIB bits\n // It's handled as a special value, not a bitmask\n if (compressionMask === MPQ_COMPRESSION_LZMA) {\n return decompressLzma(data, outSize);\n }\n\n // Determine which decompression stages are needed\n const stages: DecompressEntry[] = [];\n let remainingMask = compressionMask;\n\n for (const entry of DECOMPRESS_TABLE) {\n if (remainingMask & entry.mask) {\n stages.push(entry);\n remainingMask &= ~entry.mask;\n }\n }\n\n if (stages.length === 0 || remainingMask !== 0) {\n throw new MpqCompressionError(\n `Unsupported compression mask: 0x${compressionMask.toString(16).padStart(2, '0')}`\n );\n }\n\n // Apply each decompression stage in order\n let currentData = data;\n let currentSize = outSize;\n\n for (let i = 0; i < stages.length; i++) {\n const isLast = i === stages.length - 1;\n const targetSize = isLast ? outSize : currentData.length * 4; // estimate for intermediate stages\n\n try {\n currentData = stages[i].decompress(\n Buffer.isBuffer(currentData) ? currentData : Buffer.from(currentData),\n isLast ? outSize : targetSize,\n );\n } catch (err) {\n if (err instanceof MpqUnsupportedError) throw err;\n throw new MpqCompressionError(\n `Decompression stage 0x${stages[i].mask.toString(16)} failed: ${err}`\n );\n }\n }\n\n return Buffer.isBuffer(currentData) ? currentData : Buffer.from(currentData);\n}\n","/**\n * Blizzard's custom ADPCM decompression for MPQ audio data.\n * Ported from StormLib's adpcm.cpp.\n *\n * This handles both mono and stereo audio decompression.\n */\n\n/** Step size index table for ADPCM */\nconst STEP_TABLE: number[] = [\n 7, 8, 9, 10, 11, 12, 13, 14,\n 16, 17, 19, 21, 23, 25, 28, 31,\n 34, 37, 41, 45, 50, 55, 60, 66,\n 73, 80, 88, 97, 107, 118, 130, 143,\n 157, 173, 190, 209, 230, 253, 279, 307,\n 337, 371, 408, 449, 494, 544, 598, 658,\n 724, 796, 876, 963, 1060, 1166, 1282, 1411,\n 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,\n 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,\n 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,\n 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,\n 32767,\n];\n\n/** Index adjustment table */\nconst INDEX_TABLE: number[] = [\n -1, 0, -1, 4, -1, 2, -1, 6,\n -1, 1, -1, 5, -1, 3, -1, 7,\n -1, 1, -1, 5, -1, 3, -1, 7,\n -1, 2, -1, 4, -1, 6, -1, 8,\n];\n\ninterface AdpcmState {\n predSample: number;\n stepIndex: number;\n}\n\nfunction clampStepIndex(index: number): number {\n if (index < 0) return 0;\n if (index > 88) return 88;\n return index;\n}\n\nfunction clampSample(sample: number): number {\n if (sample > 32767) return 32767;\n if (sample < -32768) return -32768;\n return sample;\n}\n\nfunction decodeSample(state: AdpcmState, code: number): number {\n const step = STEP_TABLE[state.stepIndex];\n\n // Compute the difference\n let diff = step >>> 3;\n if (code & 4) diff += step;\n if (code & 2) diff += step >>> 1;\n if (code & 1) diff += step >>> 2;\n\n // Apply sign\n if (code & 8) {\n state.predSample = clampSample(state.predSample - diff);\n } else {\n state.predSample = clampSample(state.predSample + diff);\n }\n\n // Update step index\n state.stepIndex = clampStepIndex(state.stepIndex + INDEX_TABLE[code & 0x1F]);\n\n return state.predSample;\n}\n\n/**\n * Decompress mono ADPCM audio data.\n *\n * @param inBuffer - Compressed input data\n * @param outSize - Expected decompressed size\n * @returns Decompressed data (16-bit PCM samples, little-endian)\n */\nexport function decompressAdpcmMono(inBuffer: Buffer, outSize: number): Buffer {\n if (inBuffer.length < 4) {\n return Buffer.alloc(outSize);\n }\n\n const output = Buffer.alloc(outSize);\n let inPos = 0;\n let outPos = 0;\n\n // Read the initial shift value\n const shift = inBuffer[inPos++];\n\n // Read initial predicted sample (16-bit signed LE)\n const initialSample = inBuffer.readInt16LE(inPos);\n inPos += 2;\n\n const state: AdpcmState = {\n predSample: initialSample,\n stepIndex: STEP_TABLE.indexOf(Math.abs(initialSample)) || 0,\n };\n\n // Write initial sample\n if (outPos + 2 <= outSize) {\n output.writeInt16LE(state.predSample, outPos);\n outPos += 2;\n }\n\n // Decode remaining samples\n while (inPos < inBuffer.length && outPos + 2 <= outSize) {\n const byte = inBuffer[inPos++];\n\n // Low nibble\n const sample1 = decodeSample(state, byte & 0x0F);\n if (outPos + 2 <= outSize) {\n output.writeInt16LE(sample1, outPos);\n outPos += 2;\n }\n\n // High nibble\n if (outPos + 2 <= outSize) {\n const sample2 = decodeSample(state, (byte >>> 4) & 0x0F);\n output.writeInt16LE(sample2, outPos);\n outPos += 2;\n }\n }\n\n return output;\n}\n\n/**\n * Decompress stereo ADPCM audio data.\n *\n * @param inBuffer - Compressed input data\n * @param outSize - Expected decompressed size\n * @returns Decompressed data (interleaved 16-bit PCM samples, little-endian)\n */\nexport function decompressAdpcmStereo(inBuffer: Buffer, outSize: number): Buffer {\n if (inBuffer.length < 8) {\n return Buffer.alloc(outSize);\n }\n\n const output = Buffer.alloc(outSize);\n let inPos = 0;\n let outPos = 0;\n\n // Read the initial shift value\n const shift = inBuffer[inPos++];\n\n // Read initial samples for both channels (16-bit signed LE)\n const initialLeft = inBuffer.readInt16LE(inPos);\n inPos += 2;\n const initialRight = inBuffer.readInt16LE(inPos);\n inPos += 2;\n\n const stateL: AdpcmState = {\n predSample: initialLeft,\n stepIndex: 0,\n };\n const stateR: AdpcmState = {\n predSample: initialRight,\n stepIndex: 0,\n };\n\n // Write initial samples (interleaved L, R)\n if (outPos + 4 <= outSize) {\n output.writeInt16LE(stateL.predSample, outPos);\n outPos += 2;\n output.writeInt16LE(stateR.predSample, outPos);\n outPos += 2;\n }\n\n // Decode remaining samples\n let channel = 0; // 0 = left, 1 = right\n\n while (inPos < inBuffer.length && outPos + 2 <= outSize) {\n const byte = inBuffer[inPos++];\n\n // Low nibble\n const state = channel === 0 ? stateL : stateR;\n const sample1 = decodeSample(state, byte & 0x0F);\n if (outPos + 2 <= outSize) {\n output.writeInt16LE(sample1, outPos);\n outPos += 2;\n }\n channel ^= 1;\n\n // High nibble\n if (outPos + 2 <= outSize) {\n const state2 = channel === 0 ? stateL : stateR;\n const sample2 = decodeSample(state2, (byte >>> 4) & 0x0F);\n output.writeInt16LE(sample2, outPos);\n outPos += 2;\n }\n channel ^= 1;\n }\n\n return output;\n}\n","/**\n * Sparse decompression for MPQ archives.\n * Ported from StormLib's sparse.cpp.\n *\n * Sparse compression is a simple RLE-like encoding for files with\n * large runs of zero bytes.\n *\n * Format:\n * - Byte 0x00 followed by a length byte: emit that many zero bytes\n * - Any other byte: emit as-is\n */\n\n/**\n * Decompress sparse-encoded data.\n *\n * @param inBuffer - Compressed input data\n * @param outSize - Expected decompressed size\n * @returns Decompressed data\n */\nexport function decompressSparse(inBuffer: Buffer, outSize: number): Buffer {\n const output = Buffer.alloc(outSize);\n let inPos = 0;\n let outPos = 0;\n\n while (inPos < inBuffer.length && outPos < outSize) {\n const byte = inBuffer[inPos++];\n\n if (byte !== 0x00) {\n // Literal byte\n output[outPos++] = byte;\n } else {\n // Zero run: next byte is the count\n if (inPos >= inBuffer.length) break;\n const count = inBuffer[inPos++];\n\n if (count === 0) {\n // Literal zero byte\n output[outPos++] = 0x00;\n } else {\n // Fill with zeros\n const end = Math.min(outPos + count, outSize);\n // Buffer is already zero-initialized, just advance position\n outPos = end;\n }\n }\n }\n\n return output;\n}\n","/**\n * Sector-based reading pipeline for MPQ file data.\n *\n * MPQ files are divided into sectors of a fixed size (usually 4096 bytes).\n * Each sector can be independently compressed and/or encrypted.\n *\n * Reading pipeline per sector:\n * 1. Read raw bytes from file stream\n * 2. Decrypt if encrypted (key = fileKey + sectorIndex)\n * 3. Decompress if compressed (first byte = compression bitmask)\n */\n\nimport {\n MPQ_FILE_COMPRESS,\n MPQ_FILE_IMPLODE,\n MPQ_FILE_ENCRYPTED,\n MPQ_FILE_SINGLE_UNIT,\n MPQ_FILE_SECTOR_CRC,\n} from '../constants';\nimport type { FileEntry } from '../types';\nimport { decryptBlock } from '../crypto/cipher';\nimport { decompress } from '../compression';\nimport { decompressPkware } from '../compression/pkware';\nimport { MpqCorruptError, MpqCompressionError } from '../errors';\nimport { FileStream } from '../stream/file-stream';\n\n/**\n * Read and decrypt the sector offset table for a file.\n *\n * The sector offset table is stored at the beginning of the file's data\n * and contains (sectorCount + 1) DWORDs indicating the offset of each\n * sector's data relative to the file's start position.\n *\n * @param stream - File stream\n * @param fileOffset - Absolute offset of the file data in the stream\n * @param fileEntry - File entry metadata\n * @param sectorSize - Sector size\n * @param fileKey - File encryption key (0 if not encrypted)\n * @returns Array of sector offsets\n */\nexport function readSectorOffsets(\n stream: FileStream,\n fileOffset: bigint,\n fileEntry: FileEntry,\n sectorSize: number,\n fileKey: number,\n): Uint32Array {\n const sectorCount = Math.ceil(fileEntry.fileSize / sectorSize);\n\n // The sector offset table has (sectorCount + 1) entries\n // Plus 1 more if the file has sector CRC checksums\n let offsetCount = sectorCount + 1;\n if (fileEntry.flags & MPQ_FILE_SECTOR_CRC) {\n offsetCount++;\n }\n\n const tableSize = offsetCount * 4;\n const tableData = stream.read(fileOffset, tableSize);\n\n if (tableData.length < tableSize) {\n throw new MpqCorruptError('Sector offset table is truncated');\n }\n\n // Decrypt the sector offset table (key = fileKey - 1)\n if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {\n decryptBlock(tableData, (fileKey - 1) >>> 0);\n }\n\n // Parse into array\n const offsets = new Uint32Array(offsetCount);\n for (let i = 0; i < offsetCount; i++) {\n offsets[i] = tableData.readUInt32LE(i * 4);\n }\n\n return offsets;\n}\n\n/**\n * Read a single sector of a file.\n *\n * @param stream - File stream\n * @param fileOffset - Absolute offset of the file data in the stream\n * @param sectorOffsets - Sector offset table\n * @param sectorIndex - Index of the sector to read\n * @param fileEntry - File entry metadata\n * @param sectorSize - Sector size\n * @param fileKey - File encryption key (0 if not encrypted)\n * @returns Decompressed sector data\n */\nexport function readSector(\n stream: FileStream,\n fileOffset: bigint,\n sectorOffsets: Uint32Array,\n sectorIndex: number,\n fileEntry: FileEntry,\n sectorSize: number,\n fileKey: number,\n): Buffer {\n const rawOffset = sectorOffsets[sectorIndex];\n const rawEnd = sectorOffsets[sectorIndex + 1];\n const rawSize = rawEnd - rawOffset;\n\n // Calculate the expected uncompressed size of this sector\n const sectorStart = sectorIndex * sectorSize;\n const expectedSize = Math.min(sectorSize, fileEntry.fileSize - sectorStart);\n\n // Read raw sector data\n let sectorData = stream.read(fileOffset + BigInt(rawOffset), rawSize);\n\n if (sectorData.length < rawSize) {\n throw new MpqCorruptError(`Sector ${sectorIndex} data is truncated`);\n }\n\n // Step 1: Decrypt if encrypted\n if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {\n // Make a mutable copy for decryption\n sectorData = Buffer.from(sectorData);\n decryptBlock(sectorData, (fileKey + sectorIndex) >>> 0);\n }\n\n // Step 2: Decompress if needed\n if (rawSize < expectedSize) {\n if (fileEntry.flags & MPQ_FILE_COMPRESS) {\n // Multi-algorithm compression (first byte = bitmask)\n sectorData = decompress(sectorData, expectedSize);\n } else if (fileEntry.flags & MPQ_FILE_IMPLODE) {\n // PKWARE DCL implode\n sectorData = decompressPkware(sectorData, expectedSize);\n }\n }\n\n return sectorData;\n}\n\n/**\n * Read an entire file using sector-based reading.\n *\n * @param stream - File stream\n * @param archiveOffset - Offset of the MPQ archive within the file\n * @param fileEntry - File entry metadata\n * @param sectorSize - Sector size\n * @param fileKey - File encryption key (0 if not encrypted)\n * @returns Complete file data\n */\nexport function readSectorFile(\n stream: FileStream,\n archiveOffset: bigint,\n fileEntry: FileEntry,\n sectorSize: number,\n fileKey: number,\n): Buffer {\n const fileOffset = archiveOffset + fileEntry.byteOffset;\n\n // Read sector offset table\n const sectorOffsets = readSectorOffsets(stream, fileOffset, fileEntry, sectorSize, fileKey);\n\n // Read each sector and assemble the output\n const sectorCount = Math.ceil(fileEntry.fileSize / sectorSize);\n const output = Buffer.alloc(fileEntry.fileSize);\n let outPos = 0;\n\n for (let i = 0; i < sectorCount; i++) {\n const sectorData = readSector(\n stream, fileOffset, sectorOffsets, i,\n fileEntry, sectorSize, fileKey,\n );\n\n const copyLen = Math.min(sectorData.length, fileEntry.fileSize - outPos);\n sectorData.copy(output, outPos, 0, copyLen);\n outPos += copyLen;\n }\n\n return output;\n}\n\n/**\n * Read a single-unit file (no sector division).\n *\n * Files with MPQ_FILE_SINGLE_UNIT flag are stored as a single block\n * without sector offset tables.\n *\n * @param stream - File stream\n * @param archiveOffset - Offset of the MPQ archive within the file\n * @param fileEntry - File entry metadata\n * @param fileKey - File encryption key (0 if not encrypted)\n * @returns Complete file data\n */\nexport function readSingleUnitFile(\n stream: FileStream,\n archiveOffset: bigint,\n fileEntry: FileEntry,\n fileKey: number,\n): Buffer {\n const fileOffset = archiveOffset + fileEntry.byteOffset;\n\n // Read the entire compressed/encrypted data\n let data = stream.read(fileOffset, fileEntry.cmpSize);\n\n if (data.length < fileEntry.cmpSize) {\n throw new MpqCorruptError('Single-unit file data is truncated');\n }\n\n // Decrypt if encrypted\n if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {\n data = Buffer.from(data);\n decryptBlock(data, fileKey);\n }\n\n // Decompress if needed\n if (fileEntry.cmpSize < fileEntry.fileSize) {\n if (fileEntry.flags & MPQ_FILE_COMPRESS) {\n data = decompress(data, fileEntry.fileSize);\n } else if (fileEntry.flags & MPQ_FILE_IMPLODE) {\n const { decompressPkware } = require('../compression/pkware');\n data = decompressPkware(data, fileEntry.fileSize);\n }\n }\n\n return data;\n}\n","/**\n * MpqFile represents an open file handle within an MPQ archive.\n * It provides methods to read file data.\n */\n\nimport {\n MPQ_FILE_ENCRYPTED,\n MPQ_FILE_SINGLE_UNIT,\n MPQ_FILE_EXISTS,\n} from '../constants';\nimport type { FileEntry } from '../types';\nimport { decryptFileKey } from '../crypto/cipher';\nimport { readSectorFile, readSingleUnitFile } from './sector-reader';\nimport { FileStream } from '../stream/file-stream';\n\nexport class MpqFile {\n private stream: FileStream;\n private archiveOffset: bigint;\n private entry: FileEntry;\n private sectorSize: number;\n private fileKey: number;\n private closed = false;\n\n constructor(\n stream: FileStream,\n archiveOffset: bigint,\n entry: FileEntry,\n sectorSize: number,\n ) {\n this.stream = stream;\n this.archiveOffset = archiveOffset;\n this.entry = entry;\n this.sectorSize = sectorSize;\n\n // Calculate the file key if the file is encrypted\n if (entry.flags & MPQ_FILE_ENCRYPTED) {\n this.fileKey = decryptFileKey(\n entry.fileName,\n entry.byteOffset,\n entry.fileSize,\n entry.flags,\n );\n } else {\n this.fileKey = 0;\n }\n }\n\n /** Uncompressed file size */\n get size(): number {\n return this.entry.fileSize;\n }\n\n /** Compressed file size */\n get compressedSize(): number {\n return this.entry.cmpSize;\n }\n\n /** File flags */\n get flags(): number {\n return this.entry.flags;\n }\n\n /** File name */\n get name(): string {\n return this.entry.fileName;\n }\n\n /** The underlying file entry */\n get fileEntry(): FileEntry {\n return this.entry;\n }\n\n /**\n * Read the entire file contents.\n *\n * @returns Buffer containing the decompressed file data\n */\n read(): Buffer {\n if (this.closed) {\n throw new Error('File handle is closed');\n }\n\n if (this.entry.fileSize === 0) {\n return Buffer.alloc(0);\n }\n\n if (this.entry.flags & MPQ_FILE_SINGLE_UNIT) {\n return readSingleUnitFile(\n this.stream,\n this.archiveOffset,\n this.entry,\n this.fileKey,\n );\n }\n\n return readSectorFile(\n this.stream,\n this.archiveOffset,\n this.entry,\n this.sectorSize,\n this.fileKey,\n );\n }\n\n /**\n * Close the file handle.\n */\n close(): void {\n this.closed = true;\n }\n}\n","/**\n * MpqArchive - Main class for reading MPQ archives.\n *\n * This is the primary public API for opening and reading MPQ files.\n */\n\nimport {\n LISTFILE_NAME,\n ATTRIBUTES_NAME,\n MPQ_FILE_EXISTS,\n BLOCK_INDEX_MASK,\n MPQ_OPEN_NO_LISTFILE,\n MPQ_OPEN_NO_ATTRIBUTES,\n MPQ_OPEN_NO_HEADER_SEARCH,\n MPQ_OPEN_FORCE_MPQ_V1,\n MPQ_FORMAT_VERSION_1,\n MPQ_FORMAT_VERSION_3,\n} from '../constants';\nimport type { MpqHeader, MpqHashEntry, MpqBlockEntry, FileEntry, FileFindData, OpenArchiveOptions } from '../types';\nimport { MpqNotFoundError, MpqError, MpqEncryptionError } from '../errors';\nimport { FileStream } from '../stream/file-stream';\nimport {\n findHeader,\n getSectorSize,\n getHashTableOffset,\n getBlockTableOffset,\n getHiBlockTableOffset,\n getHetTableOffset,\n getBetTableOffset,\n type HeaderSearchResult,\n} from './header';\nimport { loadHashTable, findHashEntry } from '../tables/hash-table';\nimport { loadBlockTable, loadHiBlockTable } from '../tables/block-table';\nimport { loadHetTable, findInHetTable, type HetTable } from '../tables/het-table';\nimport { loadBetTable, getBetEntry, type BetTable } from '../tables/bet-table';\nimport { buildFileTable, buildFileTableFromHetBet, applyFileNames } from '../tables/file-table';\nimport { parseListfile, parseAttributes, type FileAttributes } from './listfile';\nimport { MpqFile } from '../file/mpq-file';\n\nexport class MpqArchive {\n private stream: FileStream;\n private header: MpqHeader;\n private archiveOffset: bigint;\n private sectorSize: number;\n\n private hashTable: MpqHashEntry[] = [];\n private blockTable: MpqBlockEntry[] = [];\n private hiBlockTable: Uint16Array | null = null;\n private hetTable: HetTable | null = null;\n private betTable: BetTable | null = null;\n private fileEntries: FileEntry[] = [];\n private attributes: FileAttributes | null = null;\n private closed = false;\n\n private constructor(\n stream: FileStream,\n header: MpqHeader,\n archiveOffset: bigint,\n ) {\n this.stream = stream;\n this.header = header;\n this.archiveOffset = archiveOffset;\n this.sectorSize = getSectorSize(header);\n }\n\n /**\n * Open an MPQ archive from a file path.\n *\n * @param path - Path to the MPQ file\n * @param options - Open options\n * @returns MpqArchive instance\n */\n static open(path: string, options?: OpenArchiveOptions): MpqArchive {\n const stream = FileStream.open(path);\n\n try {\n const noHeaderSearch = options?.noHeaderSearch ?? false;\n const { header, headerOffset } = findHeader(stream, noHeaderSearch);\n\n // Force V1 if requested\n if (options?.forceMpqV1) {\n header.wFormatVersion = MPQ_FORMAT_VERSION_1;\n }\n\n const archive = new MpqArchive(stream, header, headerOffset);\n archive.loadTables();\n\n // Load (listfile) unless disabled\n if (!options?.noListfile) {\n archive.loadListfile();\n }\n\n // Load (attributes) unless disabled\n if (!options?.noAttributes) {\n archive.loadAttributes();\n }\n\n return archive;\n } catch (err) {\n stream.close();\n throw err;\n }\n }\n\n /**\n * Load all archive tables (hash, block, HET, BET).\n */\n private loadTables(): void {\n const h = this.header;\n\n // Load classic hash and block tables\n if (h.dwHashTableSize > 0) {\n const hashOffset = getHashTableOffset(h, this.archiveOffset);\n this.hashTable = loadHashTable(this.stream, hashOffset, h.dwHashTableSize);\n }\n\n if (h.dwBlockTableSize > 0) {\n const blockOffset = getBlockTableOffset(h, this.archiveOffset);\n this.blockTable = loadBlockTable(this.stream, blockOffset, h.dwBlockTableSize);\n }\n\n // Load hi-block table (V2+)\n const hiBlockOffset = getHiBlockTableOffset(h, this.archiveOffset);\n if (hiBlockOffset !== 0n && this.blockTable.length > 0) {\n this.hiBlockTable = loadHiBlockTable(this.stream, hiBlockOffset, this.blockTable.length);\n }\n\n // Load HET/BET tables (V3+)\n if (h.wFormatVersion >= MPQ_FORMAT_VERSION_3) {\n const hetOffset = getHetTableOffset(h, this.archiveOffset);\n if (hetOffset !== 0n) {\n this.hetTable = loadHetTable(this.stream, hetOffset, h.hetTableSize64);\n }\n\n const betOffset = getBetTableOffset(h, this.archiveOffset);\n if (betOffset !== 0n) {\n this.betTable = loadBetTable(this.stream, betOffset, h.betTableSize64);\n }\n }\n\n // Build the unified file table\n if (this.hetTable && this.betTable) {\n this.fileEntries = buildFileTableFromHetBet(this.hetTable, this.betTable);\n } else {\n this.fileEntries = buildFileTable(this.hashTable, this.blockTable, this.hiBlockTable);\n }\n }\n\n /**\n * Load and parse the (listfile) to populate file names.\n */\n private loadListfile(): void {\n try {\n const data = this.extractFileByName(LISTFILE_NAME);\n if (data) {\n const names = parseListfile(data);\n applyFileNames(this.fileEntries, this.hashTable, names);\n }\n } catch {\n // (listfile) may not exist - that's okay\n }\n }\n\n /**\n * Load and parse the (attributes) file.\n */\n private loadAttributes(): void {\n try {\n const data = this.extractFileByName(ATTRIBUTES_NAME);\n if (data) {\n this.attributes = parseAttributes(data, this.fileEntries.length);\n\n // Apply attributes to file entries\n if (this.attributes) {\n for (let i = 0; i < this.fileEntries.length; i++) {\n if (i < this.attributes.crc32s.length) {\n this.fileEntries[i].crc32 = this.attributes.crc32s[i];\n }\n if (i < this.attributes.fileTimes.length) {\n this.fileEntries[i].fileTime = this.attributes.fileTimes[i];\n }\n if (i < this.attributes.md5s.length) {\n this.fileEntries[i].md5 = this.attributes.md5s[i];\n }\n }\n }\n }\n } catch {\n // (attributes) may not exist - that's okay\n }\n }\n\n /**\n * Internal: extract a file by name without relying on the listfile.\n * Used for bootstrapping (listfile) and (attributes) loading.\n */\n private extractFileByName(fileName: string): Buffer | null {\n // Try hash table lookup first\n const hashEntry = findHashEntry(\n this.hashTable,\n fileName,\n 0,\n this.fileEntries.length,\n );\n\n if (!hashEntry) return null;\n\n const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;\n if (blockIndex >= this.fileEntries.length) return null;\n\n const entry = this.fileEntries[blockIndex];\n if (!(entry.flags & MPQ_FILE_EXISTS)) return null;\n\n // Temporarily set the file name for key derivation\n const savedName = entry.fileName;\n entry.fileName = fileName;\n\n try {\n const file = new MpqFile(this.stream, this.archiveOffset, entry, this.sectorSize);\n const data = file.read();\n file.close();\n return data;\n } finally {\n entry.fileName = savedName;\n }\n }\n\n /**\n * Check if a file exists in the archive.\n */\n hasFile(name: string): boolean {\n this.ensureOpen();\n\n // Try HET table first (V3+)\n if (this.hetTable && this.betTable) {\n const betIndex = findInHetTable(this.hetTable, name);\n if (betIndex >= 0 && betIndex < this.fileEntries.length) {\n return !!(this.fileEntries[betIndex].flags & MPQ_FILE_EXISTS);\n }\n }\n\n // Fall back to hash table\n const hashEntry = findHashEntry(this.hashTable, name, 0, this.fileEntries.length);\n if (!hashEntry) return false;\n\n const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;\n return blockIndex < this.fileEntries.length &&\n !!(this.fileEntries[blockIndex].flags & MPQ_FILE_EXISTS);\n }\n\n /**\n * Open a file within the archive for reading.\n *\n * @param name - File path within the archive\n * @returns MpqFile handle\n */\n openFile(name: string): MpqFile {\n this.ensureOpen();\n\n const entry = this.resolveFile(name);\n if (!entry) {\n throw new MpqNotFoundError(`File not found: ${name}`);\n }\n\n return new MpqFile(this.stream, this.archiveOffset, entry, this.sectorSize);\n }\n\n /**\n * Extract a file's contents directly.\n *\n * @param name - File path within the archive\n * @returns Buffer with the file contents\n */\n extractFile(name: string): Buffer {\n const file = this.openFile(name);\n try {\n return file.read();\n } finally {\n file.close();\n }\n }\n\n /**\n * Get the list of all known file names (from listfile).\n */\n getFileList(): string[] {\n this.ensureOpen();\n return this.fileEntries\n .filter(e => e.fileName && (e.flags & MPQ_FILE_EXISTS))\n .map(e => e.fileName);\n }\n\n /**\n * Find files matching a wildcard pattern.\n *\n * @param mask - Wildcard pattern (supports '*' and '?')\n * @returns Array of matching file entries\n */\n findFiles(mask = '*'): FileFindData[] {\n this.ensureOpen();\n const regex = wildcardToRegex(mask);\n const results: FileFindData[] = [];\n\n for (let i = 0; i < this.fileEntries.length; i++) {\n const entry = this.fileEntries[i];\n if (!(entry.flags & MPQ_FILE_EXISTS)) continue;\n if (!entry.fileName) continue;\n\n if (regex.test(entry.fileName)) {\n const plainName = entry.fileName.replace(/^.*[\\\\/]/, '');\n results.push({\n fileName: entry.fileName,\n plainName,\n hashIndex: 0,\n blockIndex: i,\n fileSize: entry.fileSize,\n compSize: entry.cmpSize,\n fileFlags: entry.flags,\n locale: 0,\n });\n }\n }\n\n return results;\n }\n\n /**\n * Apply an external list of file names to resolve unnamed entries.\n * Equivalent to providing an external listfile to SFileFindFirstFile.\n *\n * @param names - Array of file names to try\n * @returns Number of newly resolved names\n */\n addListfile(names: string[]): number {\n this.ensureOpen();\n const before = this.fileEntries.filter(e => e.fileName).length;\n applyFileNames(this.fileEntries, this.hashTable, names);\n return this.fileEntries.filter(e => e.fileName).length - before;\n }\n\n /**\n * Enumerate all existing file entries, including those without names.\n * Unnamed entries get a synthetic name like \"File00001234.xxx\".\n */\n enumerateFiles(): FileFindData[] {\n this.ensureOpen();\n const results: FileFindData[] = [];\n\n for (let i = 0; i < this.fileEntries.length; i++) {\n const entry = this.fileEntries[i];\n if (!(entry.flags & MPQ_FILE_EXISTS)) continue;\n\n const fileName = entry.fileName || `File${String(i).padStart(8, '0')}.xxx`;\n const plainName = fileName.replace(/^.*[\\\\/]/, '');\n results.push({\n fileName,\n plainName,\n hashIndex: 0,\n blockIndex: i,\n fileSize: entry.fileSize,\n compSize: entry.cmpSize,\n fileFlags: entry.flags,\n locale: 0,\n });\n }\n\n return results;\n }\n\n /** Get the archive header */\n getHeader(): Readonly<MpqHeader> {\n return this.header;\n }\n\n /** Get the number of file entries */\n get fileCount(): number {\n return this.fileEntries.length;\n }\n\n /** Get the sector size */\n getSectorSize(): number {\n return this.sectorSize;\n }\n\n /**\n * Close the archive and release resources.\n */\n close(): void {\n if (!this.closed) {\n this.stream.close();\n this.closed = true;\n }\n }\n\n /**\n * Resolve a file name to its FileEntry.\n */\n private resolveFile(name: string): FileEntry | null {\n // Try HET table first (V3+)\n if (this.hetTable && this.betTable) {\n const betIndex = findInHetTable(this.hetTable, name);\n if (betIndex >= 0 && betIndex < this.fileEntries.length) {\n const entry = this.fileEntries[betIndex];\n if (entry.flags & MPQ_FILE_EXISTS) {\n if (!entry.fileName) entry.fileName = name;\n return entry;\n }\n }\n }\n\n // Fall back to hash table\n const hashEntry = findHashEntry(this.hashTable, name, 0, this.fileEntries.length);\n if (!hashEntry) return null;\n\n const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;\n if (blockIndex >= this.fileEntries.length) return null;\n\n const entry = this.fileEntries[blockIndex];\n if (!(entry.flags & MPQ_FILE_EXISTS)) return null;\n\n // Ensure file name is set for encryption key derivation\n if (!entry.fileName) {\n entry.fileName = name;\n }\n\n return entry;\n }\n\n private ensureOpen(): void {\n if (this.closed) {\n throw new MpqError('Archive is closed');\n }\n }\n}\n\n/**\n * Convert a simple wildcard pattern to a RegExp.\n * Supports '*' (any characters) and '?' (any single character).\n */\nfunction wildcardToRegex(pattern: string): RegExp {\n const escaped = pattern\n .replace(/[.+^${}()|[\\]\\\\]/g, '\\\\$&')\n .replace(/\\*/g, '.*')\n .replace(/\\?/g, '.');\n return new RegExp(`^${escaped}$`, 'i');\n}\n"],"mappings":"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MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,IAC5C;AAGA,IAAM,cAAwB;AAAA,MAC5B;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAC1C;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM;AAAA,MAAM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,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA;AAAA,EAC1F;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAC1F;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAC1F;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAC1F;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAC1F;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAC1F;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAC1F;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AA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AA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IAAQ;AAAA,IACxD;AAAA,IAAQ;AAAA,IAAQ;AAAA,IA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","names":["readBits","pako","decompressPkware","entry"]}