stormlib-js 0.1.0 → 0.1.1

package/dist/index.browser.mjs

@@ -0,0 +1,693 @@
+import {
+  ATTRIBUTES_NAME,
+  BLOCK_INDEX_MASK,
+  ID_MPQ,
+  ID_MPQ_USERDATA,
+  LISTFILE_NAME,
+  MPQ_COMPRESSION_ADPCM_MONO,
+  MPQ_COMPRESSION_ADPCM_STEREO,
+  MPQ_COMPRESSION_BZIP2,
+  MPQ_COMPRESSION_HUFFMANN,
+  MPQ_COMPRESSION_LZMA,
+  MPQ_COMPRESSION_PKWARE,
+  MPQ_COMPRESSION_SPARSE,
+  MPQ_COMPRESSION_ZLIB,
+  MPQ_FILE_COMPRESS,
+  MPQ_FILE_ENCRYPTED,
+  MPQ_FILE_EXISTS,
+  MPQ_FILE_IMPLODE,
+  MPQ_FILE_KEY_V2,
+  MPQ_FILE_SECTOR_CRC,
+  MPQ_FILE_SINGLE_UNIT,
+  MPQ_FORMAT_VERSION_1,
+  MPQ_FORMAT_VERSION_2,
+  MPQ_FORMAT_VERSION_3,
+  MPQ_FORMAT_VERSION_4,
+  MpqCompressionError,
+  MpqCorruptError,
+  MpqEncryptionError,
+  MpqError,
+  MpqNotFoundError,
+  MpqUnsupportedError,
+  SIGNATURE_NAME,
+  applyFileNames,
+  buildFileTable,
+  buildFileTableFromHetBet,
+  decompress,
+  decompressPkware,
+  decryptBlock,
+  decryptFileKey,
+  encryptBlock,
+  findHashEntry,
+  findHeader,
+  findInHetTable,
+  getBetTableOffset,
+  getBlockTableOffset,
+  getHashTableOffset,
+  getHetTableOffset,
+  getHiBlockTableOffset,
+  getSectorSize,
+  getStormBuffer,
+  hashFileKey,
+  hashNameA,
+  hashNameB,
+  hashString,
+  hashTableIndex,
+  init_pkware,
+  jenkinsHash,
+  loadBetTable,
+  loadBlockTable,
+  loadHashTable,
+  loadHetTable,
+  loadHiBlockTable,
+  parseAttributes,
+  parseListfile
+} from "./chunk-RRBXXQVG.mjs";
+
+// src/index.browser.ts
+import { Buffer as BufferPolyfill } from "buffer";
+
+// src/stream/file-stream.browser.ts
+var FileStream = class _FileStream {
+  constructor(fileSize, filePath, memoryData) {
+    this.fileSize = fileSize;
+    this.filePath = filePath;
+    this.memoryData = memoryData;
+  }
+  /**
+   * Path-based open is not available in browsers.
+   */
+  static open(_path) {
+    throw new Error("Path-based archive open is not available in browser runtime. Use MpqArchive.openFromBuffer().");
+  }
+  /**
+   * Create an in-memory stream from binary data.
+   */
+  static fromBuffer(data, filePath = "[buffer]") {
+    const buffer = _FileStream.normalizeBuffer(data);
+    return new _FileStream(BigInt(buffer.length), filePath, buffer);
+  }
+  static normalizeBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+  }
+  /**
+   * Read bytes at a given offset.
+   */
+  read(offset, length) {
+    if (!this.memoryData) {
+      return Buffer.alloc(0);
+    }
+    const start = Number(offset);
+    if (start >= this.memoryData.length || length <= 0) {
+      return Buffer.alloc(0);
+    }
+    const end = Math.min(start + length, this.memoryData.length);
+    return this.memoryData.subarray(start, end);
+  }
+  /**
+   * Read bytes into an existing buffer.
+   */
+  readInto(offset, buffer, bufOffset, length) {
+    if (!this.memoryData) {
+      return 0;
+    }
+    const start = Number(offset);
+    if (start >= this.memoryData.length || length <= 0) {
+      return 0;
+    }
+    const end = Math.min(start + length, this.memoryData.length);
+    return this.memoryData.copy(buffer, bufOffset, start, end);
+  }
+  /**
+   * Get the total file size.
+   */
+  getSize() {
+    return this.fileSize;
+  }
+  /**
+   * Get the file path.
+   */
+  getPath() {
+    return this.filePath;
+  }
+  /**
+   * Close the stream.
+   */
+  close() {
+    this.memoryData = null;
+  }
+};
+
+// src/file/sector-reader.browser.ts
+init_pkware();
+function readSectorOffsets(stream, fileOffset, fileEntry, sectorSize, fileKey) {
+  const sectorCount = Math.ceil(fileEntry.fileSize / sectorSize);
+  let offsetCount = sectorCount + 1;
+  if (fileEntry.flags & MPQ_FILE_SECTOR_CRC) {
+    offsetCount++;
+  }
+  const tableSize = offsetCount * 4;
+  const tableData = stream.read(fileOffset, tableSize);
+  if (tableData.length < tableSize) {
+    throw new MpqCorruptError("Sector offset table is truncated");
+  }
+  if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {
+    decryptBlock(tableData, fileKey - 1 >>> 0);
+  }
+  const offsets = new Uint32Array(offsetCount);
+  for (let i = 0; i < offsetCount; i++) {
+    offsets[i] = tableData.readUInt32LE(i * 4);
+  }
+  return offsets;
+}
+function readSector(stream, fileOffset, sectorOffsets, sectorIndex, fileEntry, sectorSize, fileKey) {
+  const rawOffset = sectorOffsets[sectorIndex];
+  const rawEnd = sectorOffsets[sectorIndex + 1];
+  const rawSize = rawEnd - rawOffset;
+  const sectorStart = sectorIndex * sectorSize;
+  const expectedSize = Math.min(sectorSize, fileEntry.fileSize - sectorStart);
+  let sectorData = stream.read(fileOffset + BigInt(rawOffset), rawSize);
+  if (sectorData.length < rawSize) {
+    throw new MpqCorruptError(`Sector ${sectorIndex} data is truncated`);
+  }
+  if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {
+    sectorData = Buffer.from(sectorData);
+    decryptBlock(sectorData, fileKey + sectorIndex >>> 0);
+  }
+  if (rawSize < expectedSize) {
+    if (fileEntry.flags & MPQ_FILE_COMPRESS) {
+      sectorData = decompress(sectorData, expectedSize);
+    } else if (fileEntry.flags & MPQ_FILE_IMPLODE) {
+      sectorData = decompressPkware(sectorData, expectedSize);
+    }
+  }
+  return sectorData;
+}
+function readSectorFile(stream, archiveOffset, fileEntry, sectorSize, fileKey) {
+  const fileOffset = archiveOffset + fileEntry.byteOffset;
+  const sectorOffsets = readSectorOffsets(stream, fileOffset, fileEntry, sectorSize, fileKey);
+  const sectorCount = Math.ceil(fileEntry.fileSize / sectorSize);
+  const output = Buffer.alloc(fileEntry.fileSize);
+  let outPos = 0;
+  for (let i = 0; i < sectorCount; i++) {
+    const sectorData = readSector(
+      stream,
+      fileOffset,
+      sectorOffsets,
+      i,
+      fileEntry,
+      sectorSize,
+      fileKey
+    );
+    const copyLen = Math.min(sectorData.length, fileEntry.fileSize - outPos);
+    sectorData.copy(output, outPos, 0, copyLen);
+    outPos += copyLen;
+  }
+  return output;
+}
+function readSingleUnitFile(stream, archiveOffset, fileEntry, fileKey) {
+  const fileOffset = archiveOffset + fileEntry.byteOffset;
+  let data = stream.read(fileOffset, fileEntry.cmpSize);
+  if (data.length < fileEntry.cmpSize) {
+    throw new MpqCorruptError("Single-unit file data is truncated");
+  }
+  if (fileEntry.flags & MPQ_FILE_ENCRYPTED) {
+    data = Buffer.from(data);
+    decryptBlock(data, fileKey);
+  }
+  if (fileEntry.cmpSize < fileEntry.fileSize) {
+    if (fileEntry.flags & MPQ_FILE_COMPRESS) {
+      data = decompress(data, fileEntry.fileSize);
+    } else if (fileEntry.flags & MPQ_FILE_IMPLODE) {
+      data = decompressPkware(data, fileEntry.fileSize);
+    }
+  }
+  return data;
+}
+
+// src/file/mpq-file.browser.ts
+var MpqFile = class {
+  constructor(stream, archiveOffset, entry, sectorSize) {
+    this.closed = false;
+    this.stream = stream;
+    this.archiveOffset = archiveOffset;
+    this.entry = entry;
+    this.sectorSize = sectorSize;
+    if (entry.flags & MPQ_FILE_ENCRYPTED) {
+      this.fileKey = decryptFileKey(
+        entry.fileName,
+        entry.byteOffset,
+        entry.fileSize,
+        entry.flags
+      );
+    } else {
+      this.fileKey = 0;
+    }
+  }
+  /** Uncompressed file size */
+  get size() {
+    return this.entry.fileSize;
+  }
+  /** Compressed file size */
+  get compressedSize() {
+    return this.entry.cmpSize;
+  }
+  /** File flags */
+  get flags() {
+    return this.entry.flags;
+  }
+  /** File name */
+  get name() {
+    return this.entry.fileName;
+  }
+  /** The underlying file entry */
+  get fileEntry() {
+    return this.entry;
+  }
+  /**
+   * Read the entire file contents.
+   *
+   * @returns Buffer containing the decompressed file data
+   */
+  read() {
+    if (this.closed) {
+      throw new Error("File handle is closed");
+    }
+    if (this.entry.fileSize === 0) {
+      return Buffer.alloc(0);
+    }
+    if (this.entry.flags & MPQ_FILE_SINGLE_UNIT) {
+      return readSingleUnitFile(
+        this.stream,
+        this.archiveOffset,
+        this.entry,
+        this.fileKey
+      );
+    }
+    return readSectorFile(
+      this.stream,
+      this.archiveOffset,
+      this.entry,
+      this.sectorSize,
+      this.fileKey
+    );
+  }
+  /**
+   * Close the file handle.
+   */
+  close() {
+    this.closed = true;
+  }
+};
+
+// src/archive/mpq-archive.browser.ts
+var asNodeStream = (stream) => stream;
+var MpqArchive = class _MpqArchive {
+  constructor(stream, header, archiveOffset) {
+    this.hashTable = [];
+    this.blockTable = [];
+    this.hiBlockTable = null;
+    this.hetTable = null;
+    this.betTable = null;
+    this.fileEntries = [];
+    this.attributes = null;
+    this.closed = false;
+    this.stream = stream;
+    this.header = header;
+    this.archiveOffset = archiveOffset;
+    this.sectorSize = getSectorSize(header);
+  }
+  /**
+   * Open an MPQ archive from a file path.
+   *
+   * @param path - Path to the MPQ file
+   * @param options - Open options
+   * @returns MpqArchive instance
+   */
+  static open(path, options) {
+    const stream = FileStream.open(path);
+    return _MpqArchive.openFromStream(stream, options);
+  }
+  /**
+   * Open an MPQ archive from in-memory binary data.
+   *
+   * This API works in both Node.js and browser runtimes.
+   *
+   * @param data - MPQ binary contents
+   * @param options - Open options
+   * @returns MpqArchive instance
+   */
+  static openFromBuffer(data, options) {
+    const stream = FileStream.fromBuffer(data);
+    return _MpqArchive.openFromStream(stream, options);
+  }
+  static openFromStream(stream, options) {
+    try {
+      const noHeaderSearch = options?.noHeaderSearch ?? false;
+      const { header, headerOffset } = findHeader(asNodeStream(stream), noHeaderSearch);
+      if (options?.forceMpqV1) {
+        header.wFormatVersion = MPQ_FORMAT_VERSION_1;
+      }
+      const archive = new _MpqArchive(stream, header, headerOffset);
+      archive.loadTables();
+      if (!options?.noListfile) {
+        archive.loadListfile();
+      }
+      if (!options?.noAttributes) {
+        archive.loadAttributes();
+      }
+      return archive;
+    } catch (err) {
+      stream.close();
+      throw err;
+    }
+  }
+  /**
+   * Load all archive tables (hash, block, HET, BET).
+   */
+  loadTables() {
+    const h = this.header;
+    const stream = asNodeStream(this.stream);
+    if (h.dwHashTableSize > 0) {
+      const hashOffset = getHashTableOffset(h, this.archiveOffset);
+      this.hashTable = loadHashTable(stream, hashOffset, h.dwHashTableSize);
+    }
+    if (h.dwBlockTableSize > 0) {
+      const blockOffset = getBlockTableOffset(h, this.archiveOffset);
+      this.blockTable = loadBlockTable(stream, blockOffset, h.dwBlockTableSize);
+    }
+    const hiBlockOffset = getHiBlockTableOffset(h, this.archiveOffset);
+    if (hiBlockOffset !== 0n && this.blockTable.length > 0) {
+      this.hiBlockTable = loadHiBlockTable(stream, hiBlockOffset, this.blockTable.length);
+    }
+    if (h.wFormatVersion >= MPQ_FORMAT_VERSION_3) {
+      const hetOffset = getHetTableOffset(h, this.archiveOffset);
+      if (hetOffset !== 0n) {
+        this.hetTable = loadHetTable(stream, hetOffset, h.hetTableSize64);
+      }
+      const betOffset = getBetTableOffset(h, this.archiveOffset);
+      if (betOffset !== 0n) {
+        this.betTable = loadBetTable(stream, betOffset, h.betTableSize64);
+      }
+    }
+    if (this.hetTable && this.betTable) {
+      this.fileEntries = buildFileTableFromHetBet(this.hetTable, this.betTable);
+    } else {
+      this.fileEntries = buildFileTable(this.hashTable, this.blockTable, this.hiBlockTable);
+    }
+  }
+  /**
+   * Load and parse the (listfile) to populate file names.
+   */
+  loadListfile() {
+    try {
+      const data = this.extractFileByName(LISTFILE_NAME);
+      if (data) {
+        const names = parseListfile(data);
+        applyFileNames(this.fileEntries, this.hashTable, names);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Load and parse the (attributes) file.
+   */
+  loadAttributes() {
+    try {
+      const data = this.extractFileByName(ATTRIBUTES_NAME);
+      if (data) {
+        this.attributes = parseAttributes(data, this.fileEntries.length);
+        if (this.attributes) {
+          for (let i = 0; i < this.fileEntries.length; i++) {
+            if (i < this.attributes.crc32s.length) {
+              this.fileEntries[i].crc32 = this.attributes.crc32s[i];
+            }
+            if (i < this.attributes.fileTimes.length) {
+              this.fileEntries[i].fileTime = this.attributes.fileTimes[i];
+            }
+            if (i < this.attributes.md5s.length) {
+              this.fileEntries[i].md5 = this.attributes.md5s[i];
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Internal: extract a file by name without relying on the listfile.
+   * Used for bootstrapping (listfile) and (attributes) loading.
+   */
+  extractFileByName(fileName) {
+    const hashEntry = findHashEntry(
+      this.hashTable,
+      fileName,
+      0,
+      this.fileEntries.length
+    );
+    if (!hashEntry) return null;
+    const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;
+    if (blockIndex >= this.fileEntries.length) return null;
+    const entry = this.fileEntries[blockIndex];
+    if (!(entry.flags & MPQ_FILE_EXISTS)) return null;
+    const savedName = entry.fileName;
+    entry.fileName = fileName;
+    try {
+      const file = new MpqFile(this.stream, this.archiveOffset, entry, this.sectorSize);
+      const data = file.read();
+      file.close();
+      return data;
+    } finally {
+      entry.fileName = savedName;
+    }
+  }
+  /**
+   * Check if a file exists in the archive.
+   */
+  hasFile(name) {
+    this.ensureOpen();
+    if (this.hetTable && this.betTable) {
+      const betIndex = findInHetTable(this.hetTable, name);
+      if (betIndex >= 0 && betIndex < this.fileEntries.length) {
+        return !!(this.fileEntries[betIndex].flags & MPQ_FILE_EXISTS);
+      }
+    }
+    const hashEntry = findHashEntry(this.hashTable, name, 0, this.fileEntries.length);
+    if (!hashEntry) return false;
+    const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;
+    return blockIndex < this.fileEntries.length && !!(this.fileEntries[blockIndex].flags & MPQ_FILE_EXISTS);
+  }
+  /**
+   * Open a file within the archive for reading.
+   *
+   * @param name - File path within the archive
+   * @returns MpqFile handle
+   */
+  openFile(name) {
+    this.ensureOpen();
+    const entry = this.resolveFile(name);
+    if (!entry) {
+      throw new MpqNotFoundError(`File not found: ${name}`);
+    }
+    return new MpqFile(this.stream, this.archiveOffset, entry, this.sectorSize);
+  }
+  /**
+   * Extract a file's contents directly.
+   *
+   * @param name - File path within the archive
+   * @returns Buffer with the file contents
+   */
+  extractFile(name) {
+    const file = this.openFile(name);
+    try {
+      return file.read();
+    } finally {
+      file.close();
+    }
+  }
+  /**
+   * Get the list of all known file names (from listfile).
+   */
+  getFileList() {
+    this.ensureOpen();
+    return this.fileEntries.filter((e) => e.fileName && e.flags & MPQ_FILE_EXISTS).map((e) => e.fileName);
+  }
+  /**
+   * Find files matching a wildcard pattern.
+   *
+   * @param mask - Wildcard pattern (supports '*' and '?')
+   * @returns Array of matching file entries
+   */
+  findFiles(mask = "*") {
+    this.ensureOpen();
+    const regex = wildcardToRegex(mask);
+    const results = [];
+    for (let i = 0; i < this.fileEntries.length; i++) {
+      const entry = this.fileEntries[i];
+      if (!(entry.flags & MPQ_FILE_EXISTS)) continue;
+      if (!entry.fileName) continue;
+      if (regex.test(entry.fileName)) {
+        const plainName = entry.fileName.replace(/^.*[\\/]/, "");
+        results.push({
+          fileName: entry.fileName,
+          plainName,
+          hashIndex: 0,
+          blockIndex: i,
+          fileSize: entry.fileSize,
+          compSize: entry.cmpSize,
+          fileFlags: entry.flags,
+          locale: 0
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Apply an external list of file names to resolve unnamed entries.
+   * Equivalent to providing an external listfile to SFileFindFirstFile.
+   *
+   * @param names - Array of file names to try
+   * @returns Number of newly resolved names
+   */
+  addListfile(names) {
+    this.ensureOpen();
+    const before = this.fileEntries.filter((e) => e.fileName).length;
+    applyFileNames(this.fileEntries, this.hashTable, names);
+    return this.fileEntries.filter((e) => e.fileName).length - before;
+  }
+  /**
+   * Enumerate all existing file entries, including those without names.
+   * Unnamed entries get a synthetic name like "File00001234.xxx".
+   */
+  enumerateFiles() {
+    this.ensureOpen();
+    const results = [];
+    for (let i = 0; i < this.fileEntries.length; i++) {
+      const entry = this.fileEntries[i];
+      if (!(entry.flags & MPQ_FILE_EXISTS)) continue;
+      const fileName = entry.fileName || `File${String(i).padStart(8, "0")}.xxx`;
+      const plainName = fileName.replace(/^.*[\\/]/, "");
+      results.push({
+        fileName,
+        plainName,
+        hashIndex: 0,
+        blockIndex: i,
+        fileSize: entry.fileSize,
+        compSize: entry.cmpSize,
+        fileFlags: entry.flags,
+        locale: 0
+      });
+    }
+    return results;
+  }
+  /** Get the archive header */
+  getHeader() {
+    return this.header;
+  }
+  /** Get the number of file entries */
+  get fileCount() {
+    return this.fileEntries.length;
+  }
+  /** Get the sector size */
+  getSectorSize() {
+    return this.sectorSize;
+  }
+  /**
+   * Close the archive and release resources.
+   */
+  close() {
+    if (!this.closed) {
+      this.stream.close();
+      this.closed = true;
+    }
+  }
+  /**
+   * Resolve a file name to its FileEntry.
+   */
+  resolveFile(name) {
+    if (this.hetTable && this.betTable) {
+      const betIndex = findInHetTable(this.hetTable, name);
+      if (betIndex >= 0 && betIndex < this.fileEntries.length) {
+        const entry2 = this.fileEntries[betIndex];
+        if (entry2.flags & MPQ_FILE_EXISTS) {
+          if (!entry2.fileName) entry2.fileName = name;
+          return entry2;
+        }
+      }
+    }
+    const hashEntry = findHashEntry(this.hashTable, name, 0, this.fileEntries.length);
+    if (!hashEntry) return null;
+    const blockIndex = hashEntry.dwBlockIndex & BLOCK_INDEX_MASK;
+    if (blockIndex >= this.fileEntries.length) return null;
+    const entry = this.fileEntries[blockIndex];
+    if (!(entry.flags & MPQ_FILE_EXISTS)) return null;
+    if (!entry.fileName) {
+      entry.fileName = name;
+    }
+    return entry;
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new MpqError("Archive is closed");
+    }
+  }
+};
+function wildcardToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+
+// src/index.browser.ts
+if (typeof globalThis !== "undefined" && typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = BufferPolyfill;
+}
+export {
+  ATTRIBUTES_NAME,
+  ID_MPQ,
+  ID_MPQ_USERDATA,
+  LISTFILE_NAME,
+  MPQ_COMPRESSION_ADPCM_MONO,
+  MPQ_COMPRESSION_ADPCM_STEREO,
+  MPQ_COMPRESSION_BZIP2,
+  MPQ_COMPRESSION_HUFFMANN,
+  MPQ_COMPRESSION_LZMA,
+  MPQ_COMPRESSION_PKWARE,
+  MPQ_COMPRESSION_SPARSE,
+  MPQ_COMPRESSION_ZLIB,
+  MPQ_FILE_COMPRESS,
+  MPQ_FILE_ENCRYPTED,
+  MPQ_FILE_EXISTS,
+  MPQ_FILE_IMPLODE,
+  MPQ_FILE_KEY_V2,
+  MPQ_FILE_SINGLE_UNIT,
+  MPQ_FORMAT_VERSION_1,
+  MPQ_FORMAT_VERSION_2,
+  MPQ_FORMAT_VERSION_3,
+  MPQ_FORMAT_VERSION_4,
+  MpqArchive,
+  MpqCompressionError,
+  MpqCorruptError,
+  MpqEncryptionError,
+  MpqError,
+  MpqFile,
+  MpqNotFoundError,
+  MpqUnsupportedError,
+  SIGNATURE_NAME,
+  decryptBlock,
+  decryptFileKey,
+  encryptBlock,
+  getStormBuffer,
+  hashFileKey,
+  hashNameA,
+  hashNameB,
+  hashString,
+  hashTableIndex,
+  jenkinsHash
+};
+//# sourceMappingURL=index.browser.mjs.map