@rhyster/wow-casc-dbc 2.6.19 → 2.7.0

package/src/jenkins96.ts

@@ -0,0 +1,75 @@
+/* eslint-disable no-bitwise */
+
+const hashlittle2 = (key: string, pc = 0, pb = 0): [number, number] => {
+    const { length } = key;
+    let offset = 0;
+
+    let a = 0xdeadbeef + length + pc | 0;
+    let b = 0xdeadbeef + length + pc | 0;
+    let c = 0xdeadbeef + length + pc + pb | 0;
+
+    while (length - offset > 12) {
+        a += key.charCodeAt(offset + 0);
+        a += key.charCodeAt(offset + 1) << 8;
+        a += key.charCodeAt(offset + 2) << 16;
+        a += key.charCodeAt(offset + 3) << 24;
+
+        b += key.charCodeAt(offset + 4);
+        b += key.charCodeAt(offset + 5) << 8;
+        b += key.charCodeAt(offset + 6) << 16;
+        b += key.charCodeAt(offset + 7) << 24;
+
+        c += key.charCodeAt(offset + 8);
+        c += key.charCodeAt(offset + 9) << 8;
+        c += key.charCodeAt(offset + 10) << 16;
+        c += key.charCodeAt(offset + 11) << 24;
+
+        // mix(a, b, c);
+        a -= c; a ^= (c << 4) | (c >>> 28); c = c + b | 0;
+        b -= a; b ^= (a << 6) | (a >>> 26); a = a + c | 0;
+        c -= b; c ^= (b << 8) | (b >>> 24); b = b + a | 0;
+        a -= c; a ^= (c << 16) | (c >>> 16); c = c + b | 0;
+        b -= a; b ^= (a << 19) | (a >>> 13); a = a + c | 0;
+        c -= b; c ^= (b << 4) | (b >>> 28); b = b + a | 0;
+
+        offset += 12;
+    }
+
+    if (length - offset > 0) {
+        // zero length strings require no mixing
+        // eslint-disable-next-line default-case
+        switch (length - offset) {
+            case 12: c += key.charCodeAt(offset + 11) << 24; // falls through
+            case 11: c += key.charCodeAt(offset + 10) << 16; // falls through
+            case 10: c += key.charCodeAt(offset + 9) << 8; // falls through
+            case 9: c += key.charCodeAt(offset + 8); // falls through
+            case 8: b += key.charCodeAt(offset + 7) << 24; // falls through
+            case 7: b += key.charCodeAt(offset + 6) << 16; // falls through
+            case 6: b += key.charCodeAt(offset + 5) << 8; // falls through
+            case 5: b += key.charCodeAt(offset + 4); // falls through
+            case 4: a += key.charCodeAt(offset + 3) << 24; // falls through
+            case 3: a += key.charCodeAt(offset + 2) << 16; // falls through
+            case 2: a += key.charCodeAt(offset + 1) << 8; // falls through
+            case 1: a += key.charCodeAt(offset + 0);
+        }
+
+        // final(a, b, c);
+        c ^= b; c -= (b << 14) | (b >>> 18);
+        a ^= c; a -= (c << 11) | (c >>> 21);
+        b ^= a; b -= (a << 25) | (a >>> 7);
+        c ^= b; c -= (b << 16) | (b >>> 16);
+        a ^= c; a -= (c << 4) | (c >>> 28);
+        b ^= a; b -= (a << 14) | (a >>> 18);
+        c ^= b; c -= (b << 24) | (b >>> 8);
+    }
+
+    return [c >>> 0, b >>> 0];
+};
+
+const getNameHash = (name: string): string => {
+    const normalized = name.replace(/\//g, '\\').toUpperCase();
+    const [pc, pb] = hashlittle2(normalized);
+    return `${pc.toString(16).padStart(8, '0')}${pb.toString(16).padStart(8, '0')}`;
+};
+
+export default getNameHash;

package/src/parsers/archiveIndex.ts

@@ -0,0 +1,119 @@
+import assert from 'node:assert';
+import crypto from 'node:crypto';
+
+const VERSION_SUB_OFFSET = -12;
+const CHECKSUM_SIZE_SUB_OFFSET = -5;
+
+const BLOCK_SIZE_OFFSET = 3;
+const OFFSET_BYTES_OFFSET = 4;
+const SIZE_BYTES_OFFSET = 5;
+const KEY_SIZE_OFFSET = 6;
+// const CHECKSUM_SIZE_OFFSET = 7;
+const NUM_ELEMENTS_OFFSET = 8;
+const CHECKSUM_OFFSET = 12;
+
+const CHECKSUM_TRIES = [
+    10,
+    9,
+    8,
+    7,
+    6,
+    5,
+    4,
+    3,
+    2,
+    1,
+    0,
+];
+
+interface ArchiveIndex {
+    key: string,
+    size: number,
+    offset: number,
+}
+
+const tryArchiveIndexChecksumSize = (buffer: Buffer, cKey: string): number => {
+    const res = CHECKSUM_TRIES.filter(
+        (index) => (
+            buffer.readUInt8(buffer.byteLength - index + CHECKSUM_SIZE_SUB_OFFSET) === index
+            && buffer.readUInt8(buffer.byteLength - index + VERSION_SUB_OFFSET) === 1
+        ),
+    );
+
+    if (res.length === 1) {
+        return res[0];
+    }
+
+    throw new Error(`Invalid checksum size: ${res.join(', ')} in ${cKey}`);
+};
+
+const parseArchiveIndex = (buffer: Buffer, cKey: string): Map<string, ArchiveIndex> => {
+    const checksumSize = tryArchiveIndexChecksumSize(buffer, cKey);
+
+    const versionOffset = buffer.byteLength - checksumSize + VERSION_SUB_OFFSET;
+    const footerOffset = versionOffset - checksumSize;
+
+    const tocChecksum = buffer.toString('hex', footerOffset, versionOffset);
+    const version = buffer.readUInt8(versionOffset);
+    const blockSizeKB = buffer.readUInt8(versionOffset + BLOCK_SIZE_OFFSET);
+    const offsetBytes = buffer.readUInt8(versionOffset + OFFSET_BYTES_OFFSET);
+    const sizeBytes = buffer.readUInt8(versionOffset + SIZE_BYTES_OFFSET);
+    const keySize = buffer.readUInt8(versionOffset + KEY_SIZE_OFFSET);
+    const numElements = buffer.readUInt32LE(versionOffset + NUM_ELEMENTS_OFFSET);
+    const footerChecksum = buffer.toString('hex', versionOffset + CHECKSUM_OFFSET);
+
+    assert(version === 1, `Invalid version: ${version.toString()} in ${cKey}`);
+
+    const entrySize = keySize + offsetBytes + sizeBytes;
+    const blockSize = blockSizeKB * 1024;
+    const numBlocks = footerOffset / (blockSize + keySize + checksumSize);
+    const tocSize = (keySize + checksumSize) * numBlocks;
+    const toc = buffer.subarray(footerOffset - tocSize, footerOffset);
+    const footer = buffer.subarray(footerOffset);
+    const footerCheckBuffer = Buffer.concat([
+        buffer.subarray(versionOffset, buffer.byteLength - checksumSize),
+        Buffer.alloc(checksumSize),
+    ]);
+
+    const hash = crypto.createHash('md5').update(footer).digest('hex');
+    assert(hash === cKey, `Invalid footer hash in ${cKey}: expected ${cKey}, got ${hash}`);
+
+    const footerHash = crypto.createHash('md5').update(footerCheckBuffer).digest('hex').slice(0, checksumSize * 2);
+    assert(footerHash === footerChecksum, `Invalid footer checksum in ${cKey}: expected ${footerChecksum}, got ${footerHash}`);
+
+    const tocHash = crypto.createHash('md5').update(toc).digest('hex').slice(0, checksumSize * 2);
+    assert(tocHash === tocChecksum, `Invalid toc checksum in ${cKey}: expected ${tocChecksum}, got ${tocHash}`);
+
+    const result = new Map<string, ArchiveIndex>();
+    for (let i = 0; i < numBlocks; i += 1) {
+        const lastEkey = toc.toString('hex', i * keySize, (i + 1) * keySize);
+        const blockChecksum = toc.toString('hex', numBlocks * keySize + i * checksumSize, numBlocks * keySize + (i + 1) * checksumSize);
+        const blockOffset = i * blockSize;
+
+        const blockHash = crypto.createHash('md5').update(buffer.subarray(i * blockSize, (i + 1) * blockSize)).digest('hex').slice(0, checksumSize * 2);
+        assert(blockChecksum === blockHash, `Invalid block hash in ${cKey} at ${i.toString()}: expected ${blockChecksum}, got ${blockHash}`);
+
+        let length = 0;
+        while (length < blockSize) {
+            const entryOffset = blockOffset + length * entrySize;
+            const eKey = buffer.toString('hex', entryOffset, entryOffset + keySize);
+            const size = buffer.readUIntBE(entryOffset + keySize, sizeBytes);
+            const offset = buffer.readUIntBE(entryOffset + keySize + sizeBytes, offsetBytes);
+
+            result.set(eKey, { key: cKey, size, offset });
+            length += 1;
+
+            if (eKey === lastEkey) {
+                break;
+            }
+        }
+    }
+
+    assert(result.size === numElements, `Invalid number of elements: ${result.size.toString()} != ${numElements.toString()} in ${cKey}`);
+
+    return result;
+};
+
+export default parseArchiveIndex;
+
+export type { ArchiveIndex };

package/src/parsers/config.ts

@@ -0,0 +1,75 @@
+import assert from 'node:assert';
+
+const normalizeKey = (key: string): string => key
+    .split('-')
+    .map((part, index) => (
+        index === 0
+            ? part
+            : `${part.charAt(0).toUpperCase()}${part.slice(1)}`
+    ))
+    .join('');
+
+const parseConfig = (text: string): Record<string, string> => {
+    const entries: Record<string, string> = {};
+
+    text
+        .split(/\r?\n/)
+        .filter((line) => line.trim().length !== 0 && !line.startsWith('#'))
+        .forEach((line) => {
+            const match = /([^\s]+)\s?=\s?(.*)/.exec(line);
+            assert(match !== null, 'Invalid token encountered parsing CDN config');
+
+            const [key, value] = match.slice(1);
+            entries[normalizeKey(key)] = value;
+        });
+
+    return entries;
+};
+
+interface CDNConfig {
+    archives: string,
+    archivesIndexSize: string,
+    archiveGroup: string,
+    patchArchives: string,
+    patchArchivesIndexSize: string,
+    patchArchiveGroup: string,
+    fileIndex: string,
+    fileIndexSize: string,
+    patchFileIndex: string,
+    patchFileIndexSize: string,
+}
+
+const parseCDNConfig = (
+    text: string,
+): CDNConfig => parseConfig(text) as unknown as CDNConfig;
+
+interface BuildConfig {
+    root: string,
+    install: string,
+    installSize: string,
+    download: string,
+    downloadSize: string,
+    size: string,
+    sizeSize: string,
+    encoding: string,
+    encodingSize: string,
+    patchIndex: string,
+    patchIndexSize: string,
+    patch: string,
+    patchSize: string,
+    patchConfig: string,
+    buildName: string,
+    buildUid: string,
+    buildProduct: string,
+    buildPlaybuildInstaller: string,
+    buildPartialPriority: string,
+    vfsRoot: string,
+    vfsRootSize: string,
+    [key: `vfs${number}` | `vfs${number}Size`]: string,
+}
+
+const parseBuildConfig = (
+    text: string,
+): BuildConfig => parseConfig(text) as unknown as BuildConfig;
+
+export { parseCDNConfig, parseBuildConfig };

package/src/parsers/encodingFile.ts

@@ -0,0 +1,159 @@
+import assert from 'node:assert';
+import crypto from 'node:crypto';
+
+import BLTEReader from '../blte.ts';
+
+const ENC_MAGIC = 0x454e;
+
+const MAGIC_OFFSET = 0;
+const VERSION_OFFSET = 2;
+const HASH_SIZE_CKEY_OFFSET = 3;
+const HASH_SIZE_EKEY_OFFSET = 4;
+const CKEY_PAGE_SIZE_OFFSET = 5;
+const EKEY_PAGE_SIZE_OFFSET = 7;
+const CKEY_PAGE_COUNT_OFFSET = 9;
+const EKEY_PAGE_COUNT_OFFSET = 13;
+// const UNK11_OFFSET = 17;
+const SPEC_BLOCK_SIZE_OFFSET = 18;
+const SPEC_BLOCK_OFFSET = 22;
+
+interface EncodingData {
+    eSpec: string[],
+    cKey2FileSize: Map<string, number>,
+    cKey2EKey: Map<string, string | string[]>,
+    eKey2ESpecIndex: Map<string, number>,
+    eKey2FileSize: Map<string, number>,
+}
+
+const parseEncodingFile = (inputBuffer: Buffer, eKey: string, cKey: string): EncodingData => {
+    const reader = new BLTEReader(inputBuffer, eKey);
+    reader.processBytes();
+
+    const { buffer } = reader;
+
+    const encodingHash = crypto.createHash('md5').update(buffer).digest('hex');
+    assert(encodingHash === cKey, `Invalid encoding hash: expected ${cKey}, got ${encodingHash}`);
+
+    const magic = buffer.readUInt16BE(MAGIC_OFFSET);
+    assert(magic === ENC_MAGIC, `Invalid encoding magic: ${magic.toString(16).padStart(4, '0')}`);
+
+    const version = buffer.readUInt8(VERSION_OFFSET);
+    const hashSizeCKey = buffer.readUInt8(HASH_SIZE_CKEY_OFFSET);
+    const hashSizeEKey = buffer.readUInt8(HASH_SIZE_EKEY_OFFSET);
+    const cKeyPageSizeKB = buffer.readUInt16BE(CKEY_PAGE_SIZE_OFFSET);
+    const eKeyPageSizeKB = buffer.readUInt16BE(EKEY_PAGE_SIZE_OFFSET);
+    const cKeyPageCount = buffer.readUInt32BE(CKEY_PAGE_COUNT_OFFSET);
+    const eKeyPageCount = buffer.readUInt32BE(EKEY_PAGE_COUNT_OFFSET);
+    const specBlockSize = buffer.readUInt32BE(SPEC_BLOCK_SIZE_OFFSET);
+
+    assert(version === 1, `Invalid encoding version: ${version.toString()}`);
+
+    const eSpec: string[] = [];
+    let eSpecStringStart = SPEC_BLOCK_OFFSET;
+    for (
+        let i = SPEC_BLOCK_OFFSET;
+        i < SPEC_BLOCK_OFFSET + specBlockSize;
+        i += 1
+    ) {
+        if (buffer[i] === 0x00) {
+            eSpec.push(buffer.toString('ascii', eSpecStringStart, i));
+            eSpecStringStart = i + 1;
+        }
+    }
+
+    const cKey2FileSize = new Map<string, number>();
+    const cKey2EKey = new Map<string, string | string[]>();
+    const cKeyPageIndexOffset = SPEC_BLOCK_OFFSET + specBlockSize;
+    const cKeyPageIndexEntrySize = hashSizeCKey + 0x10;
+    const cKeyPageOffset = cKeyPageIndexOffset + cKeyPageIndexEntrySize * cKeyPageCount;
+    const cKeyPageSize = cKeyPageSizeKB * 1024;
+    for (let i = 0; i < cKeyPageCount; i += 1) {
+        const indexOffset = cKeyPageIndexOffset + i * cKeyPageIndexEntrySize;
+        const pageOffset = cKeyPageOffset + i * cKeyPageSize;
+
+        const firstCKey = buffer.toString('hex', indexOffset, indexOffset + hashSizeCKey);
+        const pageChecksum = buffer.toString('hex', indexOffset + hashSizeCKey, indexOffset + hashSizeCKey + 0x10);
+
+        const pageBuffer = buffer.subarray(pageOffset, pageOffset + cKeyPageSize);
+        const pageHash = crypto.createHash('md5').update(pageBuffer).digest('hex');
+        assert(pageHash === pageChecksum, `Invalid ckey page ${i.toString()} checksum: expected ${pageChecksum}, got ${pageHash}`);
+
+        const pageFirstCKey = pageBuffer.toString('hex', 6, 6 + hashSizeCKey);
+        assert(pageFirstCKey === firstCKey, `Invalid ckey page ${i.toString()} first ckey: expected ${firstCKey}, got ${pageFirstCKey}`);
+
+        let pagePointer = 0;
+        while (pagePointer < cKeyPageSize) {
+            const keyCount = pageBuffer.readUInt8(pagePointer);
+            pagePointer += 1;
+            if (keyCount === 0x00) {
+                break;
+            }
+
+            const fileSize = pageBuffer.readUIntBE(pagePointer, 5);
+            pagePointer += 5;
+
+            const fileCKey = pageBuffer.toString('hex', pagePointer, pagePointer + hashSizeCKey);
+            pagePointer += hashSizeCKey;
+
+            cKey2FileSize.set(fileCKey, fileSize);
+
+            if (keyCount === 1) {
+                const fileEKey = pageBuffer.toString('hex', pagePointer, pagePointer + hashSizeEKey);
+                cKey2EKey.set(fileCKey, fileEKey);
+                pagePointer += hashSizeEKey;
+            } else {
+                const fileEKeys: string[] = [];
+                for (let j = 0; j < keyCount; j += 1) {
+                    const fileEKey = pageBuffer.toString('hex', pagePointer, pagePointer + hashSizeEKey);
+                    fileEKeys.push(fileEKey);
+                    pagePointer += hashSizeEKey;
+                }
+                cKey2EKey.set(fileCKey, fileEKeys);
+            }
+        }
+    }
+
+    const eKey2ESpecIndex = new Map<string, number>();
+    const eKey2FileSize = new Map<string, number>();
+    const eKeyPageIndexOffset = cKeyPageOffset + cKeyPageSize * cKeyPageCount;
+    const eKeyPageIndexEntrySize = hashSizeEKey + 0x10;
+    const eKeyPageOffset = eKeyPageIndexOffset + eKeyPageIndexEntrySize * eKeyPageCount;
+    const eKeyPageSize = eKeyPageSizeKB * 1024;
+    const eKeyPageEntrySize = hashSizeEKey + 0x04 + 0x05;
+    for (let i = 0; i < eKeyPageCount; i += 1) {
+        const indexOffset = eKeyPageIndexOffset + i * eKeyPageIndexEntrySize;
+        const pageOffset = eKeyPageOffset + i * eKeyPageSize;
+
+        const firstEKey = buffer.toString('hex', indexOffset, indexOffset + hashSizeEKey);
+        const pageChecksum = buffer.toString('hex', indexOffset + hashSizeEKey, indexOffset + hashSizeEKey + 0x10);
+
+        const pageBuffer = buffer.subarray(pageOffset, pageOffset + eKeyPageSize);
+        const pageHash = crypto.createHash('md5').update(pageBuffer).digest('hex');
+        assert(pageHash === pageChecksum, `Invalid ekey page ${i.toString()} checksum: expected ${pageChecksum}, got ${pageHash}`);
+
+        const pageFirstEKey = pageBuffer.toString('hex', 0, hashSizeEKey);
+        assert(pageFirstEKey === firstEKey, `Invalid ekey page ${i.toString()} first ekey: expected ${firstEKey}, got ${pageFirstEKey}`);
+
+        let pagePointer = 0;
+        while (pagePointer + eKeyPageEntrySize <= eKeyPageSize) {
+            const fileEKey = pageBuffer.toString('hex', pagePointer, pagePointer + hashSizeEKey);
+            pagePointer += hashSizeEKey;
+
+            const eSpecIndex = pageBuffer.readUInt32BE(pagePointer);
+            pagePointer += 4;
+            eKey2ESpecIndex.set(fileEKey, eSpecIndex);
+
+            const fileSize = pageBuffer.readUIntBE(pagePointer, 5);
+            pagePointer += 5;
+            eKey2FileSize.set(fileEKey, fileSize);
+        }
+    }
+
+    return {
+        eSpec, cKey2FileSize, cKey2EKey, eKey2ESpecIndex, eKey2FileSize,
+    };
+};
+
+export default parseEncodingFile;
+
+export type { EncodingData };

package/src/parsers/productConfig.ts

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
+const parseProductConfig = (text: string): Record<string, string>[] => {
+    const lines = text.split(/\r?\n/);
+
+    // First line contains field definitions.
+    // Example: Name!STRING:0|Path!STRING:0|Hosts!STRING:0|Servers!STRING:0|ConfigPath!STRING:0
+    // Whitespace is replaced so that a field like 'Install Key' becomes 'InstallKey'.
+    // This just improves coding readability when accessing the fields later on.
+    const headers = lines[0]
+        .split('|')
+        .map((header) => header.split('!')[0].replace(' ', ''));
+
+    const entries = lines
+        .filter((line, index) => index > 0 && line.trim().length !== 0 && !line.startsWith('#'))
+        .map((line) => {
+            const node: Record<string, string> = {};
+            const entryFields = line.split('|');
+            for (let i = 0, n = entryFields.length; i < n; i += 1) {
+                node[headers[i]] = entryFields[i];
+            }
+
+            return node;
+        });
+
+    return entries;
+};
+
+interface Version {
+    Region: string,
+    BuildConfig: string,
+    CDNConfig: string,
+    KeyRing: string,
+    BuildId: string,
+    VersionsName: string,
+    ProductConfig: string,
+}
+
+const parseProductVersions = (
+    text: string,
+): Version[] => parseProductConfig(text) as unknown as Version[];
+
+interface CDN {
+    Name: string,
+    Path: string,
+    Hosts: string,
+    Servers: string,
+    ConfigPath: string,
+}
+
+const parseProductCDNs = (
+    text: string,
+): CDN[] => parseProductConfig(text) as unknown as CDN[];
+
+export { parseProductVersions, parseProductCDNs };
+
+export type { Version };

package/src/parsers/rootFile.ts

@@ -0,0 +1,172 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import assert from 'node:assert';
+import crypto from 'node:crypto';
+
+import BLTEReader from '../blte.ts';
+
+const MFST_MAGIC = 0x4d465354;
+
+const ContentFlags = {
+    Install: 0x4,
+    LoadOnWindows: 0x8,
+    LoadOnMacOS: 0x10,
+    x86_32: 0x20,
+    x86_64: 0x40,
+    LowViolence: 0x80,
+    DoNotLoad: 0x100,
+    UpdatePlugin: 0x800,
+    ARM64: 0x8000,
+    Encrypted: 0x8000000,
+    NoNameHash: 0x10000000,
+    UncommonResolution: 0x20000000,
+    Bundle: 0x40000000,
+    NoCompression: 0x80000000,
+} as const;
+
+const LocaleFlags = {
+    enUS: 0x2,
+    koKR: 0x4,
+    frFR: 0x10,
+    deDE: 0x20,
+    zhCN: 0x40,
+    esES: 0x80,
+    zhTW: 0x100,
+    enGB: 0x200,
+    // enCN: 0x400,
+    // enTW: 0x800,
+    esMX: 0x1000,
+    ruRU: 0x2000,
+    ptBR: 0x4000,
+    itIT: 0x8000,
+    ptPT: 0x10000,
+} as const;
+
+interface FileInfo {
+    cKey: string,
+    contentFlags: number,
+    localeFlags: number,
+}
+
+interface RootData {
+    fileDataID2CKey: Map<number, FileInfo[]>,
+    nameHash2FileDataID: Map<string, number>,
+}
+
+const parseRootFile = (inputBuffer: Buffer, eKey: string, cKey: string): RootData => {
+    const reader = new BLTEReader(inputBuffer, eKey);
+    reader.processBytes();
+
+    const { buffer } = reader;
+
+    const rootHash = crypto.createHash('md5').update(buffer).digest('hex');
+    assert(rootHash === cKey, `Invalid root hash: expected ${cKey}, got ${rootHash}`);
+
+    const fileDataID2CKey = new Map<number, FileInfo[]>();
+    const nameHash2FileDataID = new Map<string, number>();
+
+    const magic = buffer.readUInt32LE(0);
+    if (magic === MFST_MAGIC) {
+        // post 8.2.0
+        const firstEntry = buffer.readUInt32LE(4);
+        const newFormat = firstEntry < 100; // post 10.1.7
+
+        const headerSize = newFormat ? firstEntry : 12;
+        // const version = newFormat ? buffer.readUInt32LE(8) : 0;
+        const totalFileCount = newFormat ? buffer.readUInt32LE(12) : firstEntry;
+        const namedFileCount = newFormat ? buffer.readUInt32LE(16) : buffer.readUInt32LE(8);
+
+        const allowNonNamedFiles = totalFileCount !== namedFileCount;
+
+        let pointer = headerSize;
+        while (pointer < buffer.byteLength) {
+            const numRecords = buffer.readUInt32LE(pointer);
+            const contentFlags = buffer.readUInt32LE(pointer + 4);
+            const localeFlags = buffer.readUInt32LE(pointer + 8);
+            pointer += 12;
+
+            const fileDataIDs = [];
+            let currFileDataID = -1;
+            for (let i = 0; i < numRecords; i += 1) {
+                currFileDataID += buffer.readUInt32LE(pointer) + 1;
+                fileDataIDs.push(currFileDataID);
+                pointer += 4;
+            }
+
+            for (let i = 0; i < numRecords; i += 1) {
+                const fileDataID = fileDataIDs[i];
+                const fileCKey = buffer.toString('hex', pointer, pointer + 16);
+                pointer += 16;
+
+                if (fileDataID2CKey.has(fileDataID)) {
+                    fileDataID2CKey.get(fileDataID)?.push({
+                        cKey: fileCKey,
+                        contentFlags,
+                        localeFlags,
+                    });
+                } else {
+                    fileDataID2CKey.set(fileDataID, [
+                        { cKey: fileCKey, contentFlags, localeFlags },
+                    ]);
+                }
+            }
+
+            // eslint-disable-next-line no-bitwise
+            if (!(allowNonNamedFiles && (contentFlags & ContentFlags.NoNameHash))) {
+                for (let i = 0; i < numRecords; i += 1) {
+                    const fileDataID = fileDataIDs[i];
+                    const nameHash = buffer.readBigUInt64LE(pointer).toString(16).padStart(16, '0');
+                    pointer += 8;
+
+                    nameHash2FileDataID.set(nameHash, fileDataID);
+                }
+            }
+        }
+    } else {
+        // pre 8.2.0
+        let pointer = 0;
+        while (pointer < buffer.byteLength) {
+            const numRecords = buffer.readUInt32LE(pointer);
+            const contentFlags = buffer.readUInt32LE(pointer + 4);
+            const localeFlags = buffer.readUInt32LE(pointer + 8);
+            pointer += 12;
+
+            const fileDataIDs = [];
+            let currFileDataID = -1;
+            for (let i = 0; i < numRecords; i += 1) {
+                currFileDataID += buffer.readUInt32LE(pointer) + 1;
+                fileDataIDs.push(currFileDataID);
+                pointer += 4;
+            }
+
+            for (let i = 0; i < numRecords; i += 1) {
+                const fileDataID = fileDataIDs[i];
+                const fileCKey = buffer.toString('hex', pointer, pointer + 16);
+                const nameHash = buffer.toString('hex', pointer + 16, pointer + 24);
+                pointer += 24;
+
+                if (fileDataID2CKey.has(fileDataID)) {
+                    fileDataID2CKey.get(fileDataID)?.push({
+                        cKey: fileCKey,
+                        contentFlags,
+                        localeFlags,
+                    });
+                } else {
+                    fileDataID2CKey.set(fileDataID, [
+                        { cKey: fileCKey, contentFlags, localeFlags },
+                    ]);
+                }
+
+                nameHash2FileDataID.set(nameHash, fileDataID);
+            }
+        }
+    }
+
+    return { fileDataID2CKey, nameHash2FileDataID };
+};
+
+export default parseRootFile;
+
+export { ContentFlags, LocaleFlags };
+
+export type { FileInfo, RootData };