@rhyster/wow-casc-dbc 2.6.19 → 2.7.1

package/dist/parsers/rootFile.d.ts

@@ -0,0 +1,45 @@
+declare const ContentFlags: {
+    readonly Install: 4;
+    readonly LoadOnWindows: 8;
+    readonly LoadOnMacOS: 16;
+    readonly x86_32: 32;
+    readonly x86_64: 64;
+    readonly LowViolence: 128;
+    readonly DoNotLoad: 256;
+    readonly UpdatePlugin: 2048;
+    readonly ARM64: 32768;
+    readonly Encrypted: 134217728;
+    readonly NoNameHash: 268435456;
+    readonly UncommonResolution: 536870912;
+    readonly Bundle: 1073741824;
+    readonly NoCompression: 2147483648;
+};
+declare const LocaleFlags: {
+    readonly enUS: 2;
+    readonly koKR: 4;
+    readonly frFR: 16;
+    readonly deDE: 32;
+    readonly zhCN: 64;
+    readonly esES: 128;
+    readonly zhTW: 256;
+    readonly enGB: 512;
+    readonly esMX: 4096;
+    readonly ruRU: 8192;
+    readonly ptBR: 16384;
+    readonly itIT: 32768;
+    readonly ptPT: 65536;
+};
+interface FileInfo {
+    cKey: string;
+    contentFlags: number;
+    localeFlags: number;
+}
+interface RootData {
+    fileDataID2CKey: Map<number, FileInfo[]>;
+    nameHash2FileDataID: Map<string, number>;
+}
+declare const parseRootFile: (inputBuffer: Buffer, eKey: string, cKey: string) => RootData;
+export default parseRootFile;
+export { ContentFlags, LocaleFlags };
+export type { FileInfo, RootData };
+//# sourceMappingURL=rootFile.d.ts.map

package/dist/parsers/rootFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootFile.d.ts","sourceRoot":"","sources":["../../src/parsers/rootFile.ts"],"names":[],"mappings":"AASA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;CAeR,CAAC;AAEX,QAAA,MAAM,WAAW;;;;;;;;;;;;;;CAgBP,CAAC;AAEX,UAAU,QAAQ;IACd,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,QAAQ;IACd,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IACzC,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C;AAED,QAAA,MAAM,aAAa,gBAAiB,MAAM,QAAQ,MAAM,QAAQ,MAAM,KAAG,QA8GxE,CAAC;AAEF,eAAe,aAAa,CAAC;AAE7B,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC;AAErC,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC"}

package/dist/salsa20.d.ts

@@ -0,0 +1,14 @@
+export default class Salsa20 {
+    private readonly fixed;
+    private readonly key;
+    private readonly nonce;
+    private counter;
+    private state;
+    private block;
+    private position;
+    constructor(key: Uint8Array, nonce: Uint8Array);
+    private QR;
+    private generateBlock;
+    process(input: Uint8Array): Uint8Array;
+}
+//# sourceMappingURL=salsa20.d.ts.map

package/dist/salsa20.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"salsa20.d.ts","sourceRoot":"","sources":["../src/salsa20.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,OAAO,OAAO,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IAEpC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAElC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IAEpC,OAAO,CAAC,OAAO,CAA2B;IAE1C,OAAO,CAAC,KAAK,CAAuB;IAEpC,OAAO,CAAC,KAAK,CAAsB;IAEnC,OAAO,CAAC,QAAQ,CAAK;gBAET,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;IAwC9C,OAAO,CAAC,EAAE;IAgBV,OAAO,CAAC,aAAa;IAmDrB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU;CAgBzC"}

package/dist/store.d.ts

@@ -0,0 +1,9 @@
+export default class Store<K extends string | number | symbol, V> {
+    private data;
+    private dataFile;
+    private promise;
+    constructor(dataFile: string);
+    get(key: K): Promise<V | undefined>;
+    set(key: K, value: V): Promise<void>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5D,OAAO,CAAC,IAAI,CAA2B;IAEvC,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,CAAC,OAAO,CAAgB;gBAEnB,QAAQ,EAAE,MAAM;IAiBf,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAKnC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAKpD"}

package/dist/test/salsa20.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=salsa20.test.d.ts.map

package/dist/test/salsa20.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"salsa20.test.d.ts","sourceRoot":"","sources":["../../src/test/salsa20.test.ts"],"names":[],"mappings":""}

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const formatFileSize: (input: number) => string;
+export declare const resolveCDNHost: (hosts: string[], path: string) => Promise<string[]>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,cAAc,UAAW,MAAM,WAsC3C,CAAC;AAEF,eAAO,MAAM,cAAc,UAChB,MAAM,EAAE,QACT,MAAM,KACb,OAAO,CAAC,MAAM,EAAE,CAqBlB,CAAC"}

package/dist/wdc.d.ts

@@ -0,0 +1,104 @@
+import type ADBReader from './adb.ts';
+import type { MissingKeyBlock } from './blte.ts';
+interface FieldStructure {
+    size: number;
+    position: number;
+}
+interface FieldStorageInfoCompressionNone {
+    fieldOffsetBits: number;
+    fieldSizeBits: number;
+    additionalDataSize: number;
+    storageType: 'none';
+}
+interface FieldStorageInfoCompressionBitpacked {
+    fieldOffsetBits: number;
+    fieldSizeBits: number;
+    additionalDataSize: number;
+    storageType: 'bitpacked';
+    bitpackingOffsetBits: number;
+    bitpackingSizeBits: number;
+    flags: number;
+}
+interface FieldStorageInfoCompressionCommonData {
+    fieldOffsetBits: number;
+    fieldSizeBits: number;
+    additionalDataSize: number;
+    storageType: 'commonData';
+    defaultValue: number;
+}
+interface FieldStorageInfoCompressionBitpackedIndexed {
+    fieldOffsetBits: number;
+    fieldSizeBits: number;
+    additionalDataSize: number;
+    storageType: 'bitpackedIndexed';
+    bitpackingOffsetBits: number;
+    bitpackingSizeBits: number;
+}
+interface FieldStorageInfoCompressionBitpackedIndexedArray {
+    fieldOffsetBits: number;
+    fieldSizeBits: number;
+    additionalDataSize: number;
+    storageType: 'bitpackedIndexedArray';
+    bitpackingOffsetBits: number;
+    bitpackingSizeBits: number;
+    arrayCount: number;
+}
+interface FieldStorageInfoCompressionBitpackedSigned {
+    fieldOffsetBits: number;
+    fieldSizeBits: number;
+    additionalDataSize: number;
+    storageType: 'bitpackedSigned';
+    bitpackingOffsetBits: number;
+    bitpackingSizeBits: number;
+    flags: number;
+}
+type FieldStorageInfo = FieldStorageInfoCompressionNone | FieldStorageInfoCompressionBitpacked | FieldStorageInfoCompressionCommonData | FieldStorageInfoCompressionBitpackedIndexed | FieldStorageInfoCompressionBitpackedIndexedArray | FieldStorageInfoCompressionBitpackedSigned;
+interface ParsedFieldNone {
+    type: 'none';
+    data: number | bigint;
+    string?: string;
+}
+interface ParsedFieldCommonData {
+    type: 'commonData';
+    data: number;
+}
+interface ParsedFieldBitpacked {
+    type: 'bitpacked';
+    data: number;
+}
+interface ParsedFieldBitpackedArray {
+    type: 'bitpackedArray';
+    data: number[];
+}
+type ParsedField = ParsedFieldNone | ParsedFieldCommonData | ParsedFieldBitpacked | ParsedFieldBitpackedArray;
+interface SparseRow {
+    type: 'sparse';
+    data: Buffer;
+}
+interface HotfixModify {
+    type: 'modify';
+    data: Buffer;
+}
+interface HotfixDelete {
+    type: 'delete';
+}
+type Hotfix = HotfixModify | HotfixDelete;
+export default class WDCReader {
+    readonly tableHash: number;
+    readonly layoutHash: number;
+    readonly locale: number;
+    readonly isNormal: boolean;
+    readonly hasRelationshipData: boolean;
+    readonly fields: FieldStructure[];
+    readonly fieldsInfo: FieldStorageInfo[];
+    readonly rows: Map<number, SparseRow | ParsedField[]>;
+    readonly relationships: Map<number, number>;
+    readonly copyTable: Map<number, number>;
+    readonly hotfixes: Map<number, Hotfix>;
+    constructor(buffer: Buffer, blocks?: MissingKeyBlock[], adb?: ADBReader);
+    getAllIDs(): number[];
+    getRowData(id: number): ParsedField[] | SparseRow | undefined;
+    getRowRelationship(id: number): number | undefined;
+}
+export type { FieldStructure, FieldStorageInfo, FieldStorageInfoCompressionNone, FieldStorageInfoCompressionBitpacked, FieldStorageInfoCompressionCommonData, FieldStorageInfoCompressionBitpackedIndexed, FieldStorageInfoCompressionBitpackedIndexedArray, FieldStorageInfoCompressionBitpackedSigned, ParsedField, ParsedFieldNone, ParsedFieldCommonData, ParsedFieldBitpacked, ParsedFieldBitpackedArray, SparseRow, Hotfix, HotfixModify, HotfixDelete, };
+//# sourceMappingURL=wdc.d.ts.map

package/dist/wdc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wdc.d.ts","sourceRoot":"","sources":["../src/wdc.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhyster/wow-casc-dbc",
-  "version": "2.6.19",
+  "version": "2.7.1",
   "description": "Fetch World of Warcraft data files from CASC and parse DBC/DB2 files.",
   "type": "module",
   "exports": {
@@ -14,10 +14,11 @@
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
-    "build": "unbuild",
+    "build": "unbuild && tsc --project .",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "tsx --test"
@@ -37,7 +38,7 @@
   "author": "Rhythm",
   "license": "MIT",
   "devDependencies": {
-    "@rhyster/eslint-config": "^1.6.4",
+    "@rhyster/eslint-config": "^1.6.6",
     "@types/async": "^3.2.24",
     "@types/cli-progress": "^3.11.6",
     "@types/node": "^22.10.2",

package/src/adb.ts

@@ -0,0 +1,70 @@
+import assert from 'node:assert';
+
+const ADB_MAGIC = 0x58465448;
+
+export interface HotfixEntry {
+    regionID: number,
+    pushID: number,
+    uniqueID: number,
+    tableHash: number,
+    recordID: number,
+    dataSize: number,
+    recordState: number,
+    data: Buffer,
+}
+
+export default class ADBReader {
+    public build: number;
+
+    public entries: HotfixEntry[] = [];
+
+    public tableEntries = new Map<number, HotfixEntry[]>();
+
+    constructor(buffer: Buffer) {
+        const magic = buffer.readUInt32BE(0);
+        assert(magic === ADB_MAGIC, `[ADB]: Invalid magic: ${magic.toString(16).padStart(8, '0')}`);
+
+        const version = buffer.readUInt32LE(4);
+        assert(version === 9, `[ADB]: Invalid version: ${version.toString()}`);
+
+        const build = buffer.readUInt32LE(8);
+        this.build = build;
+
+        let pointer = 44;
+        while (pointer < buffer.byteLength) {
+            const offset = pointer;
+
+            const entryMagic = buffer.readUInt32BE(offset);
+            assert(entryMagic === ADB_MAGIC, `[ADB]: Invalid entry magic: ${magic.toString(16).padStart(8, '0')}`);
+
+            const regionID = buffer.readInt32LE(offset + 4);
+            const pushID = buffer.readInt32LE(offset + 8);
+            const uniqueID = buffer.readUInt32LE(offset + 12);
+            const tableHash = buffer.readUInt32LE(offset + 16);
+            const recordID = buffer.readUInt32LE(offset + 20);
+            const dataSize = buffer.readUInt32LE(offset + 24);
+            const recordState = buffer.readUInt32LE(offset + 28);
+
+            const data = buffer.subarray(offset + 32, offset + 32 + dataSize);
+
+            const entry: HotfixEntry = {
+                regionID,
+                pushID,
+                uniqueID,
+                tableHash,
+                recordID,
+                dataSize,
+                recordState,
+                data,
+            };
+            this.entries.push(entry);
+
+            if (!this.tableEntries.has(tableHash)) {
+                this.tableEntries.set(tableHash, []);
+            }
+            this.tableEntries.get(tableHash)?.push(entry);
+
+            pointer += 32 + dataSize;
+        }
+    }
+}

package/src/blte.ts

@@ -0,0 +1,220 @@
+import assert from 'node:assert';
+import crypto from 'node:crypto';
+import zlib from 'node:zlib';
+
+import Salsa20 from './salsa20.ts';
+
+interface Block {
+    compressedSize: number,
+    decompressedSize: number,
+    hash: string,
+}
+
+interface MissingKeyBlock {
+    offset: number,
+    size: number,
+    blockIndex: number,
+    keyName: string,
+}
+
+const BLTE_MAGIC = 0x424c5445;
+const ENC_TYPE_SALSA20 = 0x53;
+const EMPTY_HASH = '00000000000000000000000000000000';
+
+export default class BLTEReader {
+    public buffer: Buffer;
+
+    public readonly blte: Buffer;
+
+    public readonly blocks: Block[] = [];
+
+    public readonly keys: Map<string, Uint8Array>;
+
+    private processedBlock = 0;
+
+    private processedOffset = 0;
+
+    constructor(buffer: Buffer, eKey: string, keys = new Map<string, Uint8Array>()) {
+        this.blte = buffer;
+        this.buffer = Buffer.alloc(0);
+        this.keys = keys;
+
+        const size = buffer.byteLength;
+        assert(size >= 8, `[BLTE]: Invalid size: ${size.toString()} < 8`);
+
+        const magic = buffer.readUInt32BE(0);
+        assert(magic === BLTE_MAGIC, `[BLTE]: Invalid magic: ${magic.toString(16).padStart(8, '0')}`);
+
+        const headerSize = buffer.readUInt32BE(4);
+        if (headerSize === 0) {
+            const blteHash = crypto.createHash('md5').update(buffer).digest('hex');
+            assert(blteHash === eKey, `[BLTE]: Invalid hash: expected ${eKey}, got ${blteHash}`);
+
+            this.blocks.push({
+                compressedSize: size - 8,
+                decompressedSize: size - 9,
+                hash: EMPTY_HASH,
+            });
+            this.processedOffset = 8;
+
+            return;
+        }
+
+        const blteHash = crypto.createHash('md5').update(buffer.subarray(0, headerSize)).digest('hex');
+        assert(blteHash === eKey, `[BLTE]: Invalid hash: expected ${eKey}, got ${blteHash}`);
+
+        assert(size >= 12, `[BLTE]: Invalid size: ${size.toString()} < 12`);
+
+        const flag = buffer.readUInt8(8);
+        const numBlocks = buffer.readIntBE(9, 3);
+
+        assert(numBlocks > 0, `[BLTE]: Invalid number of blocks: ${numBlocks.toString()}`);
+        assert(flag === 0x0f, `[BLTE]: Invalid flag: ${flag.toString(16).padStart(2, '0')}`);
+
+        const blockHeaderSize = numBlocks * 24;
+        assert(headerSize === blockHeaderSize + 12, `[BLTE]: Invalid header size: header size ${headerSize.toString()} != block header size ${blockHeaderSize.toString()} + 12`);
+
+        assert(size >= headerSize, `[BLTE]: Invalid size: ${size.toString()} < ${headerSize.toString()}`);
+
+        for (let i = 0; i < numBlocks; i += 1) {
+            const offset = 12 + i * 24;
+            const compressedSize = buffer.readUInt32BE(offset);
+            const decompressedSize = buffer.readUInt32BE(offset + 4);
+            const hash = buffer.toString('hex', offset + 8, offset + 24);
+
+            this.blocks.push({
+                compressedSize,
+                decompressedSize,
+                hash,
+            });
+        }
+
+        this.processedOffset = headerSize;
+    }
+
+    private processBlock(buffer: Buffer, index: number, allowMissingKey: false): Buffer;
+    private processBlock(buffer: Buffer, index: number, allowMissingKey: true): Buffer | string;
+    private processBlock(buffer: Buffer, index: number, allowMissingKey: boolean): Buffer | string {
+        const flag = buffer.readUInt8(0);
+        switch (flag) {
+            case 0x45: { // Encrypted
+                let offset = 1;
+
+                const keyNameLength = buffer.readUInt8(offset);
+                offset += 1;
+
+                const keyNameBE = buffer.toString('hex', offset, offset + keyNameLength);
+                offset += keyNameLength;
+
+                const ivLength = buffer.readUInt8(offset);
+                offset += 1;
+
+                const ivBuffer = buffer.subarray(offset, offset + ivLength);
+                offset += ivLength;
+
+                const encryptType = buffer.readUInt8(offset);
+                offset += 1;
+
+                assert(encryptType === ENC_TYPE_SALSA20, `[BLTE]: Invalid encrypt type: ${encryptType.toString(16).padStart(2, '0')} at block ${index.toString()}`);
+
+                const keyName = [...keyNameBE.matchAll(/.{2}/g)].map((v) => v[0]).reverse().join('').toLowerCase();
+                const key = this.keys.get(keyName);
+                if (!key) {
+                    if (allowMissingKey) {
+                        return keyName;
+                    }
+                    throw new Error(`[BLTE]: Missing key: ${keyName} at block ${index.toString()}`);
+                }
+
+                const iv = new Uint8Array(8);
+                for (let i = 0; i < 8; i += 1) {
+                    if (i < ivLength) {
+                        // eslint-disable-next-line no-bitwise
+                        iv[i] = ivBuffer.readUInt8(i) ^ ((index >>> (8 * i)) & 0xff);
+                    } else {
+                        iv[i] = 0x00;
+                    }
+                }
+
+                const handler = new Salsa20(key, iv);
+                const decrypted = handler.process(buffer.subarray(offset));
+
+                if (allowMissingKey) {
+                    return this.processBlock(Buffer.from(decrypted.buffer), index, true);
+                }
+                return this.processBlock(Buffer.from(decrypted.buffer), index, false);
+            }
+            case 0x46: // Frame (Recursive)
+                throw new Error(`[BLTE]: Frame (Recursive) block not supported at block ${index.toString()}`);
+            case 0x4e: // Frame (Normal)
+                return buffer.subarray(1);
+            case 0x5a: // Compressed
+                return zlib.inflateSync(buffer.subarray(1));
+            default:
+                throw new Error(`[BLTE]: Invalid block flag: ${flag.toString(16).padStart(2, '0')} at block ${index.toString()}`);
+        }
+    }
+
+    processBytes(allowMissingKey?: false, size?: number): undefined;
+    processBytes(allowMissingKey: true, size?: number): MissingKeyBlock[];
+    processBytes(allowMissingKey = false, size = Infinity): MissingKeyBlock[] | undefined {
+        const missingKeyBlocks: MissingKeyBlock[] = [];
+
+        while (
+            this.processedBlock < this.blocks.length
+            && size > this.buffer.byteLength
+        ) {
+            const blockIndex = this.processedBlock;
+            const block = this.blocks[blockIndex];
+
+            const blockBuffer = this.blte.subarray(
+                this.processedOffset,
+                this.processedOffset + block.compressedSize,
+            );
+            if (block.hash !== EMPTY_HASH) {
+                const blockHash = crypto.createHash('md5').update(blockBuffer).digest('hex');
+                assert(blockHash === block.hash, `[BLTE]: Invalid block hash: expected ${block.hash}, got ${blockHash}`);
+            }
+
+            if (allowMissingKey) {
+                const buffer = this.processBlock(blockBuffer, blockIndex, allowMissingKey);
+                if (typeof buffer === 'string') {
+                    missingKeyBlocks.push({
+                        offset: this.buffer.byteLength,
+                        size: block.decompressedSize,
+                        blockIndex,
+                        keyName: buffer,
+                    });
+
+                    this.buffer = Buffer.concat([
+                        this.buffer,
+                        Buffer.alloc(block.decompressedSize),
+                    ]);
+                } else {
+                    assert(
+                        buffer.byteLength === block.decompressedSize,
+                        `[BLTE]: Invalid decompressed size: expected ${block.decompressedSize.toString()}, got ${buffer.byteLength.toString()}`,
+                    );
+
+                    this.buffer = Buffer.concat([this.buffer, buffer]);
+                }
+            } else {
+                const buffer = this.processBlock(blockBuffer, blockIndex, allowMissingKey);
+
+                assert(
+                    buffer.byteLength === block.decompressedSize,
+                    `[BLTE]: Invalid decompressed size: expected ${block.decompressedSize.toString()}, got ${buffer.byteLength.toString()}`,
+                );
+
+                this.buffer = Buffer.concat([this.buffer, buffer]);
+            }
+
+            this.processedBlock += 1;
+            this.processedOffset += block.compressedSize;
+        }
+
+        return allowMissingKey ? missingKeyBlocks : undefined;
+    }
+}
+
+export type { MissingKeyBlock };