stormlib-js 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,163 +1,29 @@
-/** Raw MPQ header as parsed from disk (normalized to V4 superset) */
-interface MpqHeader {
-    /** 'MPQ\x1A' signature */
-    dwID: number;
-    /** Size of the header */
-    dwHeaderSize: number;
-    /** 32-bit archive size (V1) */
-    dwArchiveSize: number;
-    /** Format version: 0=V1, 1=V2, 2=V3, 3=V4 */
-    wFormatVersion: number;
-    /** Sector size shift (sector size = 512 << wSectorSize) */
-    wSectorSize: number;
-    /** Hash table offset (relative to archive start) */
-    dwHashTablePos: number;
-    /** Block table offset (relative to archive start) */
-    dwBlockTablePos: number;
-    /** Number of hash table entries */
-    dwHashTableSize: number;
-    /** Number of block table entries */
-    dwBlockTableSize: number;
-    /** 64-bit hi-block table offset */
-    hiBlockTablePos64: bigint;
-    /** High 16 bits of hash table offset */
-    wHashTablePosHi: number;
-    /** High 16 bits of block table offset */
-    wBlockTablePosHi: number;
-    /** 64-bit archive size */
-    archiveSize64: bigint;
-    /** 64-bit BET table position */
-    betTablePos64: bigint;
-    /** 64-bit HET table position */
-    hetTablePos64: bigint;
-    /** Compressed hash table size */
-    hashTableSize64: bigint;
-    /** Compressed block table size */
-    blockTableSize64: bigint;
-    /** Compressed hi-block table size */
-    hiBlockTableSize64: bigint;
-    /** Compressed HET table size */
-    hetTableSize64: bigint;
-    /** Compressed BET table size */
-    betTableSize64: bigint;
-    /** Raw chunk size for MD5 */
-    dwRawChunkSize: number;
-    /** MD5 checksums (V4) */
-    md5BlockTable: Uint8Array;
-    md5HashTable: Uint8Array;
-    md5HiBlockTable: Uint8Array;
-    md5BetTable: Uint8Array;
-    md5HetTable: Uint8Array;
-    md5MpqHeader: Uint8Array;
-}
-/** User data header that may precede the MPQ header */
-interface MpqUserData {
-    dwID: number;
-    cbUserDataSize: number;
-    dwHeaderOffs: number;
-    cbUserDataHeader: number;
-}
-/** Hash table entry (16 bytes on disk) */
-interface MpqHashEntry {
-    /** Hash of file path (method A) */
-    dwName1: number;
-    /** Hash of file path (method B) */
-    dwName2: number;
-    /** Windows LANGID locale */
-    lcLocale: number;
-    /** Platform (always 0) */
-    platform: number;
-    /** Index into block table (0xFFFFFFFF=free, 0xFFFFFFFE=deleted) */
-    dwBlockIndex: number;
-}
-/** Block table entry (16 bytes on disk) */
-interface MpqBlockEntry {
-    /** File data offset relative to archive start */
-    dwFilePos: number;
-    /** Compressed file size */
-    dwCSize: number;
-    /** Uncompressed file size */
-    dwFSize: number;
-    /** File flags */
-    dwFlags: number;
-}
-/** Unified file entry (in-memory representation) */
-interface FileEntry {
-    /** Jenkins hash (for BET table) */
-    fileNameHash: bigint;
-    /** File data offset relative to MPQ header */
-    byteOffset: bigint;
-    /** File time (FILETIME) from attributes */
-    fileTime: bigint;
-    /** Decompressed size */
-    fileSize: number;
-    /** Compressed size */
-    cmpSize: number;
-    /** File flags */
-    flags: number;
-    /** CRC32 from attributes */
-    crc32: number;
-    /** MD5 from attributes */
-    md5: Uint8Array;
-    /** File name (empty if unknown) */
-    fileName: string;
-}
-/** HET table header */
-interface HetTableHeader {
-    signature: number;
-    version: number;
-    dataSize: number;
-    tableSize: number;
-    maxFileCount: number;
-    hashTableSize: number;
-    hashEntrySize: number;
-    totalIndexSize: number;
-    indexSizeExtra: number;
-    indexSize: number;
-    blockTableSize: number;
-}
-/** BET table header */
-interface BetTableHeader {
-    signature: number;
-    version: number;
-    dataSize: number;
-    tableSize: number;
-    maxFileCount: number;
-    flagCount: number;
-}
-/** File search result */
-interface FileFindData {
-    fileName: string;
-    plainName: string;
-    hashIndex: number;
-    blockIndex: number;
-    fileSize: number;
-    compSize: number;
-    fileFlags: number;
-    locale: number;
-}
-/** Open archive flags */
-interface OpenArchiveOptions {
-    noListfile?: boolean;
-    noAttributes?: boolean;
-    noHeaderSearch?: boolean;
-    forceMpqV1?: boolean;
-    checkSectorCrc?: boolean;
-}
+import { F as FileEntry, O as OpenArchiveOptions, a as FileFindData, M as MpqHeader } from './storm-buffer-nHXHoPVG.js';
+export { A as ATTRIBUTES_NAME, B as BetTableHeader, H as HetTableHeader, I as ID_MPQ, b as ID_MPQ_USERDATA, L as LISTFILE_NAME, c as MPQ_COMPRESSION_ADPCM_MONO, d as MPQ_COMPRESSION_ADPCM_STEREO, e as MPQ_COMPRESSION_BZIP2, f as MPQ_COMPRESSION_HUFFMANN, g as MPQ_COMPRESSION_LZMA, h as MPQ_COMPRESSION_PKWARE, i as MPQ_COMPRESSION_SPARSE, j as MPQ_COMPRESSION_ZLIB, k as MPQ_FILE_COMPRESS, l as MPQ_FILE_ENCRYPTED, m as MPQ_FILE_EXISTS, n as MPQ_FILE_IMPLODE, o as MPQ_FILE_KEY_V2, p as MPQ_FILE_SINGLE_UNIT, q as MPQ_FORMAT_VERSION_1, r as MPQ_FORMAT_VERSION_2, s as MPQ_FORMAT_VERSION_3, t as MPQ_FORMAT_VERSION_4, u as MpqBlockEntry, v as MpqCompressionError, w as MpqCorruptError, x as MpqEncryptionError, y as MpqError, z as MpqHashEntry, C as MpqNotFoundError, D as MpqUnsupportedError, E as MpqUserData, S as SIGNATURE_NAME, G as decryptBlock, J as decryptFileKey, K as encryptBlock, N as getStormBuffer, P as hashFileKey, Q as hashNameA, R as hashNameB, T as hashString, U as hashTableIndex, V as jenkinsHash } from './storm-buffer-nHXHoPVG.js';
 
 /**
  * File stream abstraction for reading MPQ archives from disk.
  * Uses Node.js fs module for synchronous positioned reads.
  */
+type BinaryInput$1 = Buffer | Uint8Array | ArrayBuffer;
 declare class FileStream {
     private fd;
     private fileSize;
     private filePath;
+    private memoryData;
+    private static fsModule;
     private constructor();
     /**
      * Open a file for reading.
      */
     static open(path: string): FileStream;
+    /**
+     * Create an in-memory stream from binary data.
+     */
+    static fromBuffer(data: BinaryInput$1, filePath?: string): FileStream;
+    private static normalizeBuffer;
+    private static getRequire;
+    private static getFs;
     /**
      * Read bytes at a given offset.
      *
@@ -225,6 +91,7 @@ declare class MpqFile {
  * This is the primary public API for opening and reading MPQ files.
  */
 
+type BinaryInput = Buffer | Uint8Array | ArrayBuffer;
 declare class MpqArchive {
     private stream;
     private header;
@@ -247,6 +114,17 @@ declare class MpqArchive {
      * @returns MpqArchive instance
      */
     static open(path: string, options?: OpenArchiveOptions): MpqArchive;
+    /**
+     * 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: BinaryInput, options?: OpenArchiveOptions): MpqArchive;
+    private static openFromStream;
     /**
      * Load all archive tables (hash, block, HET, BET).
      */
@@ -323,98 +201,4 @@ declare class MpqArchive {
     private ensureOpen;
 }
 
-declare class MpqError extends Error {
-    constructor(message: string);
-}
-declare class MpqNotFoundError extends MpqError {
-    constructor(message?: string);
-}
-declare class MpqCorruptError extends MpqError {
-    constructor(message?: string);
-}
-declare class MpqUnsupportedError extends MpqError {
-    constructor(message?: string);
-}
-declare class MpqEncryptionError extends MpqError {
-    constructor(message?: string);
-}
-declare class MpqCompressionError extends MpqError {
-    constructor(message?: string);
-}
-
-declare const ID_MPQ = 441536589;
-declare const ID_MPQ_USERDATA = 458313805;
-declare const MPQ_FORMAT_VERSION_1 = 0;
-declare const MPQ_FORMAT_VERSION_2 = 1;
-declare const MPQ_FORMAT_VERSION_3 = 2;
-declare const MPQ_FORMAT_VERSION_4 = 3;
-declare const MPQ_FILE_IMPLODE = 256;
-declare const MPQ_FILE_COMPRESS = 512;
-declare const MPQ_FILE_ENCRYPTED = 65536;
-declare const MPQ_FILE_KEY_V2 = 131072;
-declare const MPQ_FILE_SINGLE_UNIT = 16777216;
-declare const MPQ_FILE_EXISTS = 2147483648;
-declare const MPQ_COMPRESSION_HUFFMANN = 1;
-declare const MPQ_COMPRESSION_ZLIB = 2;
-declare const MPQ_COMPRESSION_PKWARE = 8;
-declare const MPQ_COMPRESSION_BZIP2 = 16;
-declare const MPQ_COMPRESSION_LZMA = 18;
-declare const MPQ_COMPRESSION_SPARSE = 32;
-declare const MPQ_COMPRESSION_ADPCM_MONO = 64;
-declare const MPQ_COMPRESSION_ADPCM_STEREO = 128;
-declare const LISTFILE_NAME = "(listfile)";
-declare const SIGNATURE_NAME = "(signature)";
-declare const ATTRIBUTES_NAME = "(attributes)";
-
-/**
- * Compute MPQ hash of a string. The hashType selects which section of the
- * StormBuffer to use:
- * - MPQ_HASH_TABLE_INDEX (0x000): hash table slot
- * - MPQ_HASH_NAME_A (0x100): file name verification hash 1
- * - MPQ_HASH_NAME_B (0x200): file name verification hash 2
- * - MPQ_HASH_FILE_KEY (0x300): encryption key derivation
- */
-declare function hashString(str: string, hashType: number): number;
-/** Convenience: compute hash table index */
-declare function hashTableIndex(fileName: string): number;
-/** Convenience: compute name hash A */
-declare function hashNameA(fileName: string): number;
-/** Convenience: compute name hash B */
-declare function hashNameB(fileName: string): number;
-/** Convenience: compute file encryption key hash */
-declare function hashFileKey(fileName: string): number;
-/**
- * Jenkins hashlittle2 - used for HET/BET tables (64-bit hash).
- * Produces a 64-bit hash as a BigInt.
- */
-declare function jenkinsHash(str: string): bigint;
-
-/**
- * Decrypt an MPQ data block in-place.
- * The buffer must be DWORD-aligned (length must be a multiple of 4).
- *
- * @param data - Buffer to decrypt (modified in place)
- * @param key - Primary encryption key (DWORD)
- */
-declare function decryptBlock(data: Buffer, key: number): void;
-/**
- * Encrypt an MPQ data block in-place.
- *
- * @param data - Buffer to encrypt (modified in place)
- * @param key - Primary encryption key (DWORD)
- */
-declare function encryptBlock(data: Buffer, key: number): void;
-/**
- * Calculate the decryption key for a file within an MPQ archive.
- *
- * @param fileName - Full path of the file within the archive
- * @param byteOffset - File's offset within the archive (lower 32 bits)
- * @param fileSize - Uncompressed file size
- * @param flags - File flags from block table
- * @returns The file decryption key
- */
-declare function decryptFileKey(fileName: string, byteOffset: bigint, fileSize: number, flags: number): number;
-
-declare function getStormBuffer(): Uint32Array;
-
-export { ATTRIBUTES_NAME, type BetTableHeader, type FileEntry, type FileFindData, type HetTableHeader, 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, type MpqBlockEntry, MpqCompressionError, MpqCorruptError, MpqEncryptionError, MpqError, MpqFile, type MpqHashEntry, type MpqHeader, MpqNotFoundError, MpqUnsupportedError, type MpqUserData, type OpenArchiveOptions, SIGNATURE_NAME, decryptBlock, decryptFileKey, encryptBlock, getStormBuffer, hashFileKey, hashNameA, hashNameB, hashString, hashTableIndex, jenkinsHash };
+export { FileEntry, FileFindData, MpqArchive, MpqFile, MpqHeader, OpenArchiveOptions };

package/dist/index.js

@@ -719,21 +719,66 @@ var MpqCompressionError = class extends MpqError {
 };
 
 // src/stream/file-stream.ts
-var fs = __toESM(require("fs"));
-var FileStream = class _FileStream {
-  constructor(fd, fileSize, filePath) {
+var _FileStream = class _FileStream {
+  constructor(fd, fileSize, filePath, memoryData = null) {
     this.fd = fd;
     this.fileSize = fileSize;
     this.filePath = filePath;
+    this.memoryData = memoryData;
   }
   /**
    * Open a file for reading.
    */
   static open(path) {
+    const fs = _FileStream.getFs();
     const fd = fs.openSync(path, "r");
     const stat = fs.fstatSync(fd);
     return new _FileStream(fd, BigInt(stat.size), path);
   }
+  /**
+   * Create an in-memory stream from binary data.
+   */
+  static fromBuffer(data, filePath = "[buffer]") {
+    const buffer = _FileStream.normalizeBuffer(data);
+    return new _FileStream(-1, BigInt(buffer.length), filePath, buffer);
+  }
+  static normalizeBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+  }
+  static getRequire() {
+    try {
+      if (typeof require === "function") {
+        return require;
+      }
+    } catch {
+    }
+    try {
+      return Function('return typeof require === "function" ? require : null;')();
+    } catch {
+      return null;
+    }
+  }
+  static getFs() {
+    if (_FileStream.fsModule) {
+      return _FileStream.fsModule;
+    }
+    const req = _FileStream.getRequire();
+    if (!req) {
+      throw new Error("Node.js fs module is not available in this runtime. Use MpqArchive.openFromBuffer().");
+    }
+    const fs = req("fs");
+    if (!fs) {
+      throw new Error("Failed to load Node.js fs module.");
+    }
+    _FileStream.fsModule = fs;
+    return _FileStream.fsModule;
+  }
   /**
    * Read bytes at a given offset.
    *
@@ -742,6 +787,15 @@ var FileStream = class _FileStream {
    * @returns Buffer containing the read data
    */
   read(offset, length) {
+    if (this.memoryData) {
+      const start = Number(offset);
+      if (start >= this.memoryData.length || length <= 0) {
+        return Buffer.alloc(0);
+      }
+      const end = Math.min(start + length, this.memoryData.length);
+      return this.memoryData.subarray(start, end);
+    }
+    const fs = _FileStream.getFs();
     const buffer = Buffer.alloc(length);
     const bytesRead = fs.readSync(this.fd, buffer, 0, length, Number(offset));
     if (bytesRead < length) {
@@ -753,6 +807,15 @@ var FileStream = class _FileStream {
    * Read bytes into an existing buffer.
    */
   readInto(offset, buffer, bufOffset, length) {
+    if (this.memoryData) {
+      const start = Number(offset);
+      if (start >= this.memoryData.length || length <= 0) {
+        return 0;
+      }
+      const end = Math.min(start + length, this.memoryData.length);
+      return this.memoryData.copy(buffer, bufOffset, start, end);
+    }
+    const fs = _FileStream.getFs();
     return fs.readSync(this.fd, buffer, bufOffset, length, Number(offset));
   }
   /**
@@ -771,12 +834,16 @@ var FileStream = class _FileStream {
    * Close the file stream.
    */
   close() {
-    if (this.fd >= 0) {
+    if (this.fd >= 0 && !this.memoryData) {
+      const fs = _FileStream.getFs();
       fs.closeSync(this.fd);
       this.fd = -1;
     }
+    this.memoryData = null;
   }
 };
+_FileStream.fsModule = null;
+var FileStream = _FileStream;
 
 // src/archive/header.ts
 function createDefaultHeader() {
@@ -2639,6 +2706,22 @@ var MpqArchive = class _MpqArchive {
    */
   static open(path, options) {
     const stream = FileStream.open(path);
+    return _MpqArchive.openFromStream(stream, options);
+  }
+  /**
+   * Open an MPQ archive from in-memory binary data.
+   *
+   * This API works in both Node.js and browser runtimes.
+   *
+   * @param data - MPQ binary contents
+   * @param options - Open options
+   * @returns MpqArchive instance
+   */
+  static openFromBuffer(data, options) {
+    const stream = FileStream.fromBuffer(data);
+    return _MpqArchive.openFromStream(stream, options);
+  }
+  static openFromStream(stream, options) {
     try {
       const noHeaderSearch = options?.noHeaderSearch ?? false;
       const { header, headerOffset } = findHeader(stream, noHeaderSearch);