@rhyster/wow-casc-dbc 1.0.1

package/dist/index.mjs

@@ -0,0 +1,1850 @@
+import assert from 'node:assert';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import http from 'node:http';
+import zlib from 'node:zlib';
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Store {
+  constructor(dataFile) {
+    __publicField$5(this, "data");
+    __publicField$5(this, "dataFile");
+    __publicField$5(this, "promise");
+    this.dataFile = dataFile;
+    this.data = {};
+    this.promise = new Promise((resolve) => {
+      fs.readFile(dataFile, "utf-8").then((file) => {
+        this.data = JSON.parse(file);
+        resolve();
+      }).catch(() => {
+        resolve();
+      });
+    });
+  }
+  async get(key) {
+    await this.promise;
+    return this.data[key];
+  }
+  async set(key, value) {
+    await this.promise;
+    this.data[key] = value;
+    await fs.writeFile(this.dataFile, JSON.stringify(this.data), "utf-8");
+  }
+}
+
+const USER_AGENT = "node-wow-casc-dbc";
+const CACHE_ROOT = path.resolve("cache");
+const CACHE_DIRS = {
+  build: "builds",
+  indexes: "indices",
+  data: "data",
+  dbd: "dbd"
+};
+const CACHE_INTEGRITY_FILE = path.resolve(CACHE_ROOT, "integrity.json");
+const cacheIntegrity = new Store(CACHE_INTEGRITY_FILE);
+const formatCDNKey = (key) => `${key.substring(0, 2)}/${key.substring(2, 4)}/${key}`;
+const requestData = async (url, partialOffset = void 0, partialLength = void 0) => new Promise((resolve, reject) => {
+  const options = {
+    headers: {
+      "User-Agent": USER_AGENT,
+      Range: partialOffset && partialLength ? `bytes=${partialOffset.toString()}-${(partialOffset + partialLength - 1).toString()}` : "bytes=0-"
+    }
+  };
+  http.get(url, options, (res) => {
+    if (res.statusCode === 301 || res.statusCode === 302) {
+      if (res.headers.location) {
+        requestData(res.headers.location, partialOffset, partialLength).then(resolve).catch(reject);
+      } else {
+        reject(new Error(`Failed to request ${url}, Status Code: ${res.statusCode.toString()}`));
+      }
+      return;
+    }
+    if (!res.statusCode || res.statusCode < 200 || res.statusCode > 302) {
+      reject(new Error(`Failed to request ${url}, Status Code: ${res.statusCode?.toString() ?? "undefined"}`));
+      return;
+    }
+    const chunks = [];
+    res.on("data", (chunk) => chunks.push(chunk));
+    res.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+  }).on("error", reject).end();
+});
+const downloadFile = (prefixes, type, key, partialOffset = void 0, partialLength = void 0) => {
+  const urls = prefixes.map((prefix) => `${prefix}/${type}/${formatCDNKey(key)}`);
+  return urls.reduce(
+    (prev, url) => prev.catch(() => requestData(url, partialOffset, partialLength)),
+    Promise.reject(new Error(""))
+  );
+};
+const getFileCache = async (file) => {
+  const integrity = await cacheIntegrity.get(file);
+  if (integrity) {
+    try {
+      const buffer = await fs.readFile(path.resolve(CACHE_ROOT, file));
+      const hash = crypto.createHash("sha256").update(buffer).digest("hex");
+      if (hash === integrity) {
+        return buffer;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+};
+const getDataFile = async (prefixes, key, type, buildCKey, name, partialOffset = void 0, partialLength = void 0) => {
+  const dir = type === "build" ? path.join(CACHE_DIRS[type], buildCKey) : CACHE_DIRS[type];
+  const file = name ? path.join(dir, name) : path.join(dir, key);
+  const cacheBuffer = await getFileCache(file);
+  if (cacheBuffer) {
+    if (name === void 0 && partialOffset !== void 0 && partialLength !== void 0) {
+      return cacheBuffer.subarray(partialOffset, partialOffset + partialLength);
+    }
+    return cacheBuffer;
+  }
+  const downloadBuffer = await downloadFile(prefixes, "data", key, partialOffset, partialLength);
+  if (partialOffset === void 0 && partialLength === void 0 || name) {
+    await fs.mkdir(path.resolve(CACHE_ROOT, dir), { recursive: true });
+    await fs.writeFile(path.resolve(CACHE_ROOT, file), downloadBuffer);
+    const hash = crypto.createHash("sha256").update(downloadBuffer).digest("hex");
+    await cacheIntegrity.set(file, hash);
+  }
+  return downloadBuffer;
+};
+const getConfigFile = async (prefixes, key) => {
+  const downloadBuffer = await downloadFile(prefixes, "config", key);
+  return downloadBuffer.toString("utf-8");
+};
+const getProductVersions = async (region, product) => {
+  const url = `http://${region}.patch.battle.net:1119/${product}/versions`;
+  const headers = {
+    "User-Agent": USER_AGENT
+  };
+  const res = await fetch(url, { headers });
+  return res.text();
+};
+const getProductCDNs = async (region, product) => {
+  const url = `http://${region}.patch.battle.net:1119/${product}/cdns`;
+  const headers = {
+    "User-Agent": USER_AGENT
+  };
+  const res = await fetch(url, { headers });
+  return res.text();
+};
+
+const parseProductConfig = (text) => {
+  const lines = text.split(/\r?\n/);
+  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 = {};
+    const entryFields = line.split("|");
+    for (let i = 0, n = entryFields.length; i < n; i += 1) {
+      node[headers[i]] = entryFields[i];
+    }
+    return node;
+  });
+  return entries;
+};
+const parseProductVersions = (text) => parseProductConfig(text);
+const parseProductCDNs = (text) => parseProductConfig(text);
+
+const normalizeKey = (key) => key.split("-").map((part, index) => index === 0 ? part : `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+const parseConfig = (text) => {
+  const entries = {};
+  text.split(/\r?\n/).filter((line) => line.trim().length !== 0 && !line.startsWith("#")).forEach((line) => {
+    const match = line.match(/([^\s]+)\s?=\s?(.*)/);
+    assert(match !== null, "Invalid token encountered parsing CDN config");
+    const [key, value] = match.slice(1);
+    entries[normalizeKey(key)] = value;
+  });
+  return entries;
+};
+const parseCDNConfig = (text) => parseConfig(text);
+const parseBuildConfig = (text) => parseConfig(text);
+
+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 NUM_ELEMENTS_OFFSET = 8;
+const CHECKSUM_OFFSET = 12;
+const CHECKSUM_TRIES = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
+const tryArchiveIndexChecksumSize = (buffer, cKey) => {
+  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, cKey) => {
+  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 = /* @__PURE__ */ new Map();
+  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;
+};
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Salsa20 {
+  constructor(key, nonce) {
+    __publicField$4(this, "fixed");
+    __publicField$4(this, "key");
+    __publicField$4(this, "nonce");
+    __publicField$4(this, "counter", new Uint32Array([0, 0]));
+    __publicField$4(this, "state", new Uint32Array(16));
+    __publicField$4(this, "block", new Uint8Array(64));
+    __publicField$4(this, "position", 0);
+    assert(key.length === 32 || key.length === 16, "Salsa20 requires 128-bit or 256-bit key");
+    assert(nonce.length === 8, "Salsa20 requires 64-bit nonce");
+    this.key = new Uint32Array(8);
+    const keyView = new DataView(key.buffer);
+    if (key.length === 32) {
+      for (let i = 0; i < 8; i += 1) {
+        this.key[i] = keyView.getUint32(i * 4, true);
+      }
+      this.fixed = new Uint32Array([
+        1634760805,
+        857760878,
+        2036477234,
+        1797285236
+      ]);
+    } else {
+      for (let i = 0; i < 4; i += 1) {
+        const word = keyView.getUint32(i * 4, true);
+        this.key[i] = word;
+        this.key[i + 4] = word;
+      }
+      this.fixed = new Uint32Array([
+        1634760805,
+        824206446,
+        2036477238,
+        1797285236
+      ]);
+    }
+    this.nonce = new Uint32Array(2);
+    const nonceView = new DataView(nonce.buffer);
+    for (let i = 0; i < 2; i += 1) {
+      this.nonce[i] = nonceView.getUint32(i * 4, true);
+    }
+    this.generateBlock();
+  }
+  QR(a, b, c, d) {
+    let t;
+    t = this.state[a] + this.state[d] & 4294967295;
+    this.state[b] ^= t << 7 | t >>> 25;
+    t = this.state[b] + this.state[a] & 4294967295;
+    this.state[c] ^= t << 9 | t >>> 23;
+    t = this.state[c] + this.state[b] & 4294967295;
+    this.state[d] ^= t << 13 | t >>> 19;
+    t = this.state[d] + this.state[c] & 4294967295;
+    this.state[a] ^= t << 18 | t >>> 14;
+  }
+  generateBlock() {
+    const init = new Uint32Array([
+      this.fixed[0],
+      this.key[0],
+      this.key[1],
+      this.key[2],
+      this.key[3],
+      this.fixed[1],
+      this.nonce[0],
+      this.nonce[1],
+      this.counter[0],
+      this.counter[1],
+      this.fixed[2],
+      this.key[4],
+      this.key[5],
+      this.key[6],
+      this.key[7],
+      this.fixed[3]
+    ]);
+    this.state = new Uint32Array(init);
+    for (let i = 0; i < 20; i += 2) {
+      this.QR(0, 4, 8, 12);
+      this.QR(5, 9, 13, 1);
+      this.QR(10, 14, 2, 6);
+      this.QR(15, 3, 7, 11);
+      this.QR(0, 1, 2, 3);
+      this.QR(5, 6, 7, 4);
+      this.QR(10, 11, 8, 9);
+      this.QR(15, 12, 13, 14);
+    }
+    for (let i = 0; i < 16; i += 1) {
+      const word = this.state[i] + init[i] & 4294967295;
+      this.block[i * 4] = word & 255;
+      this.block[i * 4 + 1] = word >>> 8 & 255;
+      this.block[i * 4 + 2] = word >>> 16 & 255;
+      this.block[i * 4 + 3] = word >>> 24 & 255;
+    }
+    this.counter[0] = this.counter[0] + 1 & 4294967295;
+    if (this.counter[0] === 0) {
+      this.counter[1] = this.counter[1] + 1 & 4294967295;
+    }
+  }
+  process(input) {
+    const { length } = input;
+    const result = new Uint8Array(length);
+    for (let i = 0; i < length; i += 1) {
+      if (this.position === 64) {
+        this.generateBlock();
+        this.position = 0;
+      }
+      result[i] = input[i] ^ this.block[this.position];
+      this.position += 1;
+    }
+    return result;
+  }
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const BLTE_MAGIC = 1112298565;
+const ENC_TYPE_SALSA20 = 83;
+const EMPTY_HASH = "00000000000000000000000000000000";
+class BLTEReader {
+  constructor(buffer, eKey, keys = /* @__PURE__ */ new Map()) {
+    __publicField$3(this, "buffer");
+    __publicField$3(this, "blte");
+    __publicField$3(this, "blocks", []);
+    __publicField$3(this, "keys");
+    __publicField$3(this, "processedBlock", 0);
+    __publicField$3(this, "processedOffset", 0);
+    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 blteHash2 = crypto.createHash("md5").update(buffer).digest("hex");
+      assert(blteHash2 === eKey, `[BLTE]: Invalid hash: expected ${eKey}, got ${blteHash2}`);
+      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 === 15, `[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;
+  }
+  processBlock(buffer, index, allowMissingKey) {
+    const flag = buffer.readUInt8(0);
+    switch (flag) {
+      case 69: {
+        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")}`);
+        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}`);
+        }
+        const iv = new Uint8Array(8);
+        for (let i = 0; i < 8; i += 1) {
+          const byte = ivBuffer.byteLength > i ? ivBuffer.readUInt8(i) : void 0;
+          iv[i] = byte ? byte ^ index >> 8 * i & 255 : 0;
+        }
+        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 70:
+        throw new Error("[BLTE]: Frame (Recursive) block not supported");
+      case 78:
+        return buffer.subarray(1);
+      case 90:
+        return zlib.inflateSync(buffer.subarray(1));
+      default:
+        throw new Error(`[BLTE]: Invalid block flag: ${flag.toString(16).padStart(2, "0")}`);
+    }
+  }
+  processBytes(allowMissingKey = false, size = Infinity) {
+    const missingKeyBlocks = [];
+    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 (buffer instanceof Buffer) {
+          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 {
+          missingKeyBlocks.push({
+            offset: this.buffer.byteLength,
+            size: block.decompressedSize,
+            blockIndex,
+            keyName: buffer
+          });
+          this.buffer = Buffer.concat([
+            this.buffer,
+            Buffer.alloc(block.decompressedSize)
+          ]);
+        }
+      } 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 : void 0;
+  }
+}
+
+const ENC_MAGIC = 17742;
+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 SPEC_BLOCK_SIZE_OFFSET = 18;
+const SPEC_BLOCK_OFFSET = 22;
+const parseEncodingFile = (inputBuffer, eKey, cKey) => {
+  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 = [];
+  let eSpecStringStart = SPEC_BLOCK_OFFSET;
+  for (let i = SPEC_BLOCK_OFFSET; i < SPEC_BLOCK_OFFSET + specBlockSize; i += 1) {
+    if (buffer[i] === 0) {
+      eSpec.push(buffer.toString("ascii", eSpecStringStart, i));
+      eSpecStringStart = i + 1;
+    }
+  }
+  const cKey2FileSize = /* @__PURE__ */ new Map();
+  const cKey2EKey = /* @__PURE__ */ new Map();
+  const cKeyPageIndexOffset = SPEC_BLOCK_OFFSET + specBlockSize;
+  const cKeyPageIndexEntrySize = hashSizeCKey + 16;
+  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 + 16);
+    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 === 0) {
+        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 = [];
+        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 = /* @__PURE__ */ new Map();
+  const eKey2FileSize = /* @__PURE__ */ new Map();
+  const eKeyPageIndexOffset = cKeyPageOffset + cKeyPageSize * cKeyPageCount;
+  const eKeyPageIndexEntrySize = hashSizeEKey + 16;
+  const eKeyPageOffset = eKeyPageIndexOffset + eKeyPageIndexEntrySize * eKeyPageCount;
+  const eKeyPageSize = eKeyPageSizeKB * 1024;
+  const eKeyPageEntrySize = hashSizeEKey + 4 + 5;
+  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 + 16);
+    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
+  };
+};
+
+const MFST_MAGIC = 1296454484;
+const ContentFlags = {
+  Install: 4,
+  LoadOnWindows: 8,
+  LoadOnMacOS: 16,
+  x86_32: 32,
+  x86_64: 64,
+  LowViolence: 128,
+  DoNotLoad: 256,
+  UpdatePlugin: 2048,
+  ARM64: 32768,
+  Encrypted: 134217728,
+  NoNameHash: 268435456,
+  UncommonResolution: 536870912,
+  Bundle: 1073741824,
+  NoCompression: 2147483648
+};
+const LocaleFlags = {
+  enUS: 2,
+  koKR: 4,
+  frFR: 16,
+  deDE: 32,
+  zhCN: 64,
+  esES: 128,
+  zhTW: 256,
+  enGB: 512,
+  // enCN: 0x400,
+  // enTW: 0x800,
+  esMX: 4096,
+  ruRU: 8192,
+  ptBR: 16384,
+  itIT: 32768,
+  ptPT: 65536
+};
+const parseRootFile = (inputBuffer, eKey, cKey) => {
+  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 = /* @__PURE__ */ new Map();
+  const nameHash2FileDataID = /* @__PURE__ */ new Map();
+  const magic = buffer.readUInt32LE(0);
+  if (magic === MFST_MAGIC) {
+    const firstEntry = buffer.readUInt32LE(4);
+    const newFormat = firstEntry < 100;
+    const headerSize = newFormat ? firstEntry : 12;
+    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 }
+          ]);
+        }
+      }
+      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 {
+    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 };
+};
+
+const hashlittle2 = (key, pc = 0, pb = 0) => {
+  const { length } = key;
+  let offset = 0;
+  let a = 3735928559 + length + pc | 0;
+  let b = 3735928559 + length + pc | 0;
+  let c = 3735928559 + 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;
+    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) {
+    switch (length - offset) {
+      case 12:
+        c += key.charCodeAt(offset + 11) << 24;
+      case 11:
+        c += key.charCodeAt(offset + 10) << 16;
+      case 10:
+        c += key.charCodeAt(offset + 9) << 8;
+      case 9:
+        c += key.charCodeAt(offset + 8);
+      case 8:
+        b += key.charCodeAt(offset + 7) << 24;
+      case 7:
+        b += key.charCodeAt(offset + 6) << 16;
+      case 6:
+        b += key.charCodeAt(offset + 5) << 8;
+      case 5:
+        b += key.charCodeAt(offset + 4);
+      case 4:
+        a += key.charCodeAt(offset + 3) << 24;
+      case 3:
+        a += key.charCodeAt(offset + 2) << 16;
+      case 2:
+        a += key.charCodeAt(offset + 1) << 8;
+      case 1:
+        a += key.charCodeAt(offset + 0);
+    }
+    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) => {
+  const normalized = name.replace(/\//g, "\\").toUpperCase();
+  const [pc, pb] = hashlittle2(normalized);
+  return `${pc.toString(16).padStart(8, "0")}${pb.toString(16).padStart(8, "0")}`;
+};
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const WDC5_MAGIC = 1464091445;
+const readBitpackedValue = (buffer, fieldOffsetBits, fieldSizeBits, signed = false) => {
+  const offsetBytes = fieldOffsetBits >>> 3;
+  const bitOffset = fieldOffsetBits & 7;
+  const sizeBytes = Math.ceil((fieldSizeBits + bitOffset) / 8);
+  if (sizeBytes <= 6) {
+    const rawValue = buffer.readUIntLE(offsetBytes, sizeBytes);
+    return Number(
+      signed ? BigInt.asIntN(fieldSizeBits, BigInt(rawValue >>> bitOffset)) : BigInt.asUintN(fieldSizeBits, BigInt(rawValue >>> bitOffset))
+    );
+  }
+  let remain = sizeBytes;
+  let value = 0n;
+  while (remain > 0) {
+    const byteLength = Math.min(remain, 6);
+    const offset = offsetBytes + remain - byteLength;
+    const rawValue = buffer.readUIntLE(offset, byteLength);
+    value = value << BigInt(byteLength * 8) | BigInt(rawValue);
+    remain -= byteLength;
+  }
+  return signed ? BigInt.asIntN(fieldSizeBits, value >> BigInt(bitOffset)) : BigInt.asUintN(fieldSizeBits, value >> BigInt(bitOffset));
+};
+class WDCReader {
+  constructor(buffer, blocks = []) {
+    __publicField$2(this, "tableHash");
+    __publicField$2(this, "layoutHash");
+    __publicField$2(this, "locale");
+    __publicField$2(this, "isNormal");
+    __publicField$2(this, "hasRelationshipData");
+    __publicField$2(this, "fields");
+    __publicField$2(this, "fieldsInfo");
+    __publicField$2(this, "rows", /* @__PURE__ */ new Map());
+    __publicField$2(this, "relationships", /* @__PURE__ */ new Map());
+    __publicField$2(this, "copyTable", /* @__PURE__ */ new Map());
+    const magic = buffer.readUInt32BE(0);
+    const fieldCount = buffer.readUInt32LE(140);
+    const recordSize = buffer.readUInt32LE(144);
+    const tableHash = buffer.readUInt32LE(152);
+    const layoutHash = buffer.readUInt32LE(156);
+    const locale = buffer.readUInt32LE(168);
+    const flags = buffer.readUInt16LE(172);
+    const idIndex = buffer.readUInt16LE(174);
+    const fieldStorageInfoSize = buffer.readUInt32LE(188);
+    const commonDataSize = buffer.readUInt32LE(192);
+    const palletDataSize = buffer.readUInt32LE(196);
+    const sectionCount = buffer.readUInt32LE(200);
+    assert(magic === WDC5_MAGIC, `Invalid magic: ${magic.toString(16).padStart(8, "0")}`);
+    this.tableHash = tableHash;
+    this.layoutHash = layoutHash;
+    this.locale = locale;
+    const isNormal = !(flags & 1);
+    const hasRelationshipData = !!(flags & 2);
+    this.isNormal = isNormal;
+    this.hasRelationshipData = hasRelationshipData;
+    const sectionHeaders = [];
+    const sectionHeadersOffset = 204;
+    for (let i = 0; i < sectionCount; i += 1) {
+      const sectionHeaderOffset = sectionHeadersOffset + i * 40;
+      sectionHeaders.push({
+        tactKeyHash: buffer.readBigUInt64LE(sectionHeaderOffset),
+        fileOffset: buffer.readUInt32LE(sectionHeaderOffset + 8),
+        recordCount: buffer.readUInt32LE(sectionHeaderOffset + 12),
+        stringTableSize: buffer.readUInt32LE(sectionHeaderOffset + 16),
+        offsetRecordsEnd: buffer.readUInt32LE(sectionHeaderOffset + 20),
+        idListSize: buffer.readUInt32LE(sectionHeaderOffset + 24),
+        relationshipDataSize: buffer.readUInt32LE(sectionHeaderOffset + 28),
+        offsetMapIDCount: buffer.readUInt32LE(sectionHeaderOffset + 32),
+        copyTableCount: buffer.readUInt32LE(sectionHeaderOffset + 36)
+      });
+    }
+    const fields = [];
+    const fieldsOffset = 204 + sectionCount * 40;
+    for (let i = 0; i < fieldCount; i += 1) {
+      const fieldOffset = fieldsOffset + i * 4;
+      fields.push({
+        size: buffer.readInt16LE(fieldOffset),
+        position: buffer.readUInt16LE(fieldOffset + 2)
+      });
+    }
+    this.fields = fields;
+    const fieldsInfo = [];
+    const fieldsInfoOffset = fieldsOffset + fieldCount * 4;
+    for (let i = 0; i < fieldStorageInfoSize / 24; i += 1) {
+      const fieldInfoOffset = fieldsInfoOffset + i * 24;
+      const fieldOffsetBits = buffer.readUInt16LE(fieldInfoOffset);
+      const fieldSizeBits = buffer.readUInt16LE(fieldInfoOffset + 2);
+      const additionalDataSize = buffer.readUInt32LE(fieldInfoOffset + 4);
+      const storageType = buffer.readUInt32LE(fieldInfoOffset + 8);
+      const arg1 = buffer.readUInt32LE(fieldInfoOffset + 12);
+      const arg2 = buffer.readUInt32LE(fieldInfoOffset + 16);
+      const arg3 = buffer.readUInt32LE(fieldInfoOffset + 20);
+      switch (storageType) {
+        case 0:
+          fieldsInfo.push({
+            fieldOffsetBits,
+            fieldSizeBits,
+            additionalDataSize,
+            storageType: "none"
+          });
+          break;
+        case 1:
+          fieldsInfo.push({
+            fieldOffsetBits,
+            fieldSizeBits,
+            additionalDataSize,
+            storageType: "bitpacked",
+            bitpackingOffsetBits: arg1,
+            bitpackingSizeBits: arg2,
+            flags: arg3
+          });
+          break;
+        case 2:
+          fieldsInfo.push({
+            fieldOffsetBits,
+            fieldSizeBits,
+            additionalDataSize,
+            storageType: "commonData",
+            defaultValue: arg1
+          });
+          break;
+        case 3:
+          fieldsInfo.push({
+            fieldOffsetBits,
+            fieldSizeBits,
+            additionalDataSize,
+            storageType: "bitpackedIndexed",
+            bitpackingOffsetBits: arg1,
+            bitpackingSizeBits: arg2
+          });
+          break;
+        case 4:
+          fieldsInfo.push({
+            fieldOffsetBits,
+            fieldSizeBits,
+            additionalDataSize,
+            storageType: "bitpackedIndexedArray",
+            bitpackingOffsetBits: arg1,
+            bitpackingSizeBits: arg2,
+            arrayCount: arg3
+          });
+          break;
+        case 5:
+          fieldsInfo.push({
+            fieldOffsetBits,
+            fieldSizeBits,
+            additionalDataSize,
+            storageType: "bitpackedSigned",
+            bitpackingOffsetBits: arg1,
+            bitpackingSizeBits: arg2,
+            flags: arg3
+          });
+          break;
+        default:
+          throw new Error(`Unknown storage type: ${storageType.toString(16).padStart(8, "0")}`);
+      }
+    }
+    this.fieldsInfo = fieldsInfo;
+    const palletData = /* @__PURE__ */ new Map();
+    const palletDataOffset = fieldsInfoOffset + fieldStorageInfoSize;
+    let palletDataPointer = palletDataOffset;
+    for (let i = 0; i < fieldsInfo.length; i += 1) {
+      const fieldInfo = fieldsInfo[i];
+      if (fieldInfo.storageType === "bitpackedIndexed" || fieldInfo.storageType === "bitpackedIndexedArray") {
+        const data = [];
+        for (let j = 0; j < fieldInfo.additionalDataSize / 4; j += 1) {
+          data.push(buffer.readUInt32LE(palletDataPointer));
+          palletDataPointer += 4;
+        }
+        palletData.set(i, data);
+      }
+    }
+    assert(
+      palletDataPointer === palletDataOffset + palletDataSize,
+      `Invalid pallet data size: ${(palletDataPointer - palletDataOffset).toString()} != ${palletDataSize.toString()}`
+    );
+    const commonData = /* @__PURE__ */ new Map();
+    const commonDataOffset = palletDataPointer;
+    let commonDataPointer = commonDataOffset;
+    for (let i = 0; i < fieldsInfo.length; i += 1) {
+      const fieldInfo = fieldsInfo[i];
+      if (fieldInfo.storageType === "commonData") {
+        const map = /* @__PURE__ */ new Map();
+        for (let j = 0; j < fieldInfo.additionalDataSize / 8; j += 1) {
+          map.set(
+            buffer.readUInt32LE(commonDataPointer),
+            buffer.readUInt32LE(commonDataPointer + 4)
+          );
+          commonDataPointer += 8;
+        }
+        commonData.set(i, map);
+      }
+    }
+    assert(
+      commonDataPointer === commonDataOffset + commonDataSize,
+      `Invalid common data size: ${(commonDataPointer - commonDataOffset).toString()} != ${commonDataSize.toString()}`
+    );
+    const encryptedIDs = /* @__PURE__ */ new Map();
+    const encryptedRecordsOffset = commonDataPointer;
+    let encryptedRecordsPointer = encryptedRecordsOffset;
+    for (let i = 0; i < sectionHeaders.length; i += 1) {
+      const sectionHeader = sectionHeaders[i];
+      if (sectionHeader.tactKeyHash !== 0n) {
+        const count = buffer.readUInt32LE(encryptedRecordsPointer);
+        encryptedRecordsPointer += 4;
+        const data = [];
+        for (let j = 0; j < count; j += 1) {
+          data.push(buffer.readUInt32LE(encryptedRecordsPointer));
+          encryptedRecordsPointer += 4;
+        }
+        encryptedIDs.set(i, data);
+      }
+    }
+    const stringTable = /* @__PURE__ */ new Map();
+    let stringTableDelta = 0;
+    const sectionsOffset = encryptedRecordsPointer;
+    let sectionPointer = sectionsOffset;
+    const sections = sectionHeaders.map((sectionHeader) => {
+      assert(
+        sectionPointer === sectionHeader.fileOffset,
+        `Invalid section offset: ${sectionPointer.toString()} != ${sectionHeader.fileOffset.toString()}`
+      );
+      const sectionSize = (isNormal ? sectionHeader.recordCount * recordSize + sectionHeader.stringTableSize : sectionHeader.offsetRecordsEnd - sectionPointer) + sectionHeader.idListSize + sectionHeader.copyTableCount * 8 + sectionHeader.offsetMapIDCount * 10 + sectionHeader.relationshipDataSize;
+      const recordDataSize = isNormal ? recordSize * sectionHeader.recordCount : sectionHeader.offsetRecordsEnd - sectionHeader.fileOffset;
+      const isZeroed = blocks.some((block) => {
+        const sectionStart = sectionHeader.fileOffset;
+        const sectionEnd = sectionStart + sectionSize;
+        const blockStart = block.offset;
+        const blockEnd = blockStart + block.size;
+        return sectionStart >= blockStart && sectionEnd <= blockEnd;
+      });
+      if (isZeroed) {
+        sectionPointer += sectionSize;
+        if (isNormal) {
+          stringTableDelta += sectionHeader.stringTableSize;
+        }
+        return {
+          header: sectionHeader,
+          isZeroed,
+          recordDataSize,
+          records: [],
+          idList: [],
+          offsetMap: [],
+          relationshipMap: /* @__PURE__ */ new Map()
+        };
+      }
+      const records = [];
+      if (isNormal) {
+        for (let j = 0; j < sectionHeader.recordCount; j += 1) {
+          records.push(buffer.subarray(sectionPointer, sectionPointer + recordSize));
+          sectionPointer += recordSize;
+        }
+        const stringTableOffset = sectionPointer;
+        let stringStartPointer = stringTableOffset;
+        while (sectionPointer < stringTableOffset + sectionHeader.stringTableSize) {
+          if (buffer[sectionPointer] === 0) {
+            if (sectionPointer - stringStartPointer > 0) {
+              const string = buffer.toString("utf-8", stringStartPointer, sectionPointer);
+              stringTable.set(
+                stringStartPointer - stringTableOffset + stringTableDelta,
+                string
+              );
+            }
+            stringStartPointer = sectionPointer + 1;
+          }
+          sectionPointer += 1;
+        }
+        stringTableDelta += sectionHeader.stringTableSize;
+      } else {
+        sectionPointer = sectionHeader.offsetRecordsEnd;
+      }
+      const idList = [];
+      for (let j = 0; j < sectionHeader.idListSize / 4; j += 1) {
+        idList.push(buffer.readUInt32LE(sectionPointer));
+        sectionPointer += 4;
+      }
+      for (let j = 0; j < sectionHeader.copyTableCount; j += 1) {
+        const dst = buffer.readUInt32LE(sectionPointer);
+        const src = buffer.readUInt32LE(sectionPointer + 4);
+        this.copyTable.set(dst, src);
+        sectionPointer += 8;
+      }
+      const offsetMap = [];
+      for (let j = 0; j < sectionHeader.offsetMapIDCount; j += 1) {
+        const offset = buffer.readUInt32LE(sectionPointer);
+        const size = buffer.readUInt16LE(sectionPointer + 4);
+        const data = buffer.subarray(offset, offset + size);
+        sectionPointer += 6;
+        offsetMap.push({
+          offset,
+          size,
+          data
+        });
+      }
+      const offsetMapIDList = [];
+      if (hasRelationshipData) {
+        for (let j = 0; j < sectionHeader.offsetMapIDCount; j += 1) {
+          offsetMapIDList.push(buffer.readUInt32LE(sectionPointer));
+          sectionPointer += 4;
+        }
+      }
+      const relationshipMap = /* @__PURE__ */ new Map();
+      if (sectionHeader.relationshipDataSize > 0) {
+        const numEntries = buffer.readUInt32LE(sectionPointer);
+        sectionPointer += 12;
+        for (let j = 0; j < numEntries; j += 1) {
+          const foreignID = buffer.readUInt32LE(sectionPointer);
+          const recordIndex = buffer.readUInt32LE(sectionPointer + 4);
+          sectionPointer += 8;
+          relationshipMap.set(recordIndex, foreignID);
+        }
+      }
+      if (!hasRelationshipData) {
+        for (let j = 0; j < sectionHeader.offsetMapIDCount; j += 1) {
+          offsetMapIDList.push(buffer.readUInt32LE(sectionPointer));
+          sectionPointer += 4;
+        }
+      }
+      return {
+        header: sectionHeader,
+        isZeroed,
+        recordDataSize,
+        records,
+        idList,
+        offsetMap,
+        relationshipMap
+      };
+    });
+    const totalRecordDataSize = sections.reduce((acc, section) => acc + section.recordDataSize, 0);
+    sections.forEach((section) => {
+      const {
+        header,
+        isZeroed,
+        records,
+        idList,
+        offsetMap,
+        relationshipMap
+      } = section;
+      const prevRecordDataSize = sections.filter((s) => s.header.fileOffset < header.fileOffset).reduce((acc, s) => acc + s.recordDataSize, 0);
+      if (isZeroed) {
+        return;
+      }
+      for (let recordIndex = 0; recordIndex < header.recordCount; recordIndex += 1) {
+        let recordID = idList.length > 0 ? idList[recordIndex] : void 0;
+        const recordBuffer = isNormal ? records[recordIndex] : offsetMap[recordIndex].data;
+        if (isNormal) {
+          const recordData = fieldsInfo.map((fieldInfo, fieldIndex) => {
+            switch (fieldInfo.storageType) {
+              case "none": {
+                const value = readBitpackedValue(
+                  recordBuffer,
+                  fieldInfo.fieldOffsetBits,
+                  fieldInfo.fieldSizeBits
+                );
+                if (typeof value === "bigint") {
+                  return {
+                    type: "none",
+                    data: value
+                  };
+                }
+                if (!recordID && fieldIndex === idIndex) {
+                  recordID = value;
+                }
+                const fieldOffset = fieldInfo.fieldOffsetBits >>> 3;
+                const offset = prevRecordDataSize - totalRecordDataSize + recordSize * recordIndex + fieldOffset + value;
+                return {
+                  type: "none",
+                  data: value,
+                  string: stringTable.get(offset)
+                };
+              }
+              case "commonData": {
+                const value = (recordID ? commonData.get(fieldIndex)?.get(recordID) : void 0) ?? fieldInfo.defaultValue;
+                return {
+                  type: "commonData",
+                  data: value
+                };
+              }
+              case "bitpacked":
+              case "bitpackedSigned":
+              case "bitpackedIndexed":
+              case "bitpackedIndexedArray": {
+                let value = readBitpackedValue(
+                  recordBuffer,
+                  fieldInfo.fieldOffsetBits,
+                  fieldInfo.fieldSizeBits,
+                  fieldInfo.storageType === "bitpackedSigned"
+                );
+                assert(typeof value === "number", "Bitpacked value must be a number");
+                if (fieldInfo.storageType === "bitpackedIndexedArray") {
+                  const fieldPalletData = palletData.get(fieldIndex);
+                  assert(fieldPalletData, `No pallet data for field ${fieldIndex.toString()}`);
+                  const data = [];
+                  const palletStart = value * fieldInfo.arrayCount;
+                  for (let j = 0; j < fieldInfo.arrayCount; j += 1) {
+                    data.push(fieldPalletData[palletStart + j]);
+                  }
+                  return {
+                    type: "bitpackedArray",
+                    data
+                  };
+                }
+                if (fieldInfo.storageType === "bitpackedIndexed") {
+                  const fieldPalletData = palletData.get(fieldIndex);
+                  assert(fieldPalletData, `No pallet data for field ${fieldIndex.toString()}`);
+                  value = fieldPalletData[value];
+                }
+                if (!recordID && fieldIndex === idIndex) {
+                  recordID = value;
+                }
+                return {
+                  type: "bitpacked",
+                  data: value
+                };
+              }
+              default:
+                throw new Error("Unreachable");
+            }
+          });
+          assert(recordID !== void 0, "No record ID found");
+          this.rows.set(recordID, recordData);
+          const foreignID = relationshipMap.get(recordIndex);
+          if (foreignID) {
+            this.relationships.set(recordID, foreignID);
+          }
+        } else {
+          const recordData = {
+            type: "sparse",
+            data: recordBuffer
+          };
+          assert(recordID !== void 0, "No record ID found");
+          this.rows.set(recordID, recordData);
+          const foreignID = relationshipMap.get(recordIndex);
+          if (foreignID) {
+            this.relationships.set(recordID, foreignID);
+          }
+        }
+      }
+    });
+  }
+  getAllIDs() {
+    return [...this.rows.keys(), ...this.copyTable.keys()];
+  }
+  getRowData(id) {
+    const dst = this.copyTable.get(id);
+    if (dst) {
+      return this.rows.get(dst);
+    }
+    return this.rows.get(id);
+  }
+  getRowRelationship(id) {
+    const dst = this.copyTable.get(id);
+    if (dst) {
+      return this.relationships.get(dst);
+    }
+    return this.relationships.get(id);
+  }
+}
+
+const resolveCDNHost = async (hosts, path) => {
+  const latencies = await Promise.allSettled(
+    hosts.map(async (host) => {
+      const start = Date.now();
+      await fetch(`http://${host}/`);
+      const end = Date.now();
+      return {
+        host,
+        latency: end - start
+      };
+    })
+  );
+  const resolved = latencies.filter((result) => result.status === "fulfilled").map((result) => result.value).sort((a, b) => a.latency - b.latency);
+  return resolved.map((result) => `http://${result.host}/${path}`);
+};
+const startProcessBar = (total, screenWidth = 80) => {
+  const totalText = total.toString();
+  const barLength = screenWidth - totalText.length * 2 - 4;
+  const bar = " ".repeat(barLength);
+  process.stdout.write(`[${bar}] ${"0".padStart(totalText.length, " ")}/${totalText}`);
+  process.stdout.cursorTo(0);
+};
+const updateProcessBar = (current, total, screenWidth = 80) => {
+  const totalText = total.toString();
+  const barLength = screenWidth - totalText.length * 2 - 4;
+  const bar = "=".repeat(Math.floor(current / total * barLength));
+  process.stdout.write(`[${bar.padEnd(barLength, " ")}] ${current.toString().padStart(totalText.length, " ")}/${totalText}`);
+  process.stdout.cursorTo(0);
+};
+const endProcessBar = () => {
+  process.stdout.write("\n");
+};
+const asyncQueue = (items, handler, limit) => {
+  if (items.length === 0) {
+    return Promise.resolve([]);
+  }
+  return new Promise((resolve, reject) => {
+    const results = [];
+    let current = 0;
+    let pending = 0;
+    let completed = 0;
+    const next = () => {
+      if (current < items.length) {
+        const index = current;
+        current += 1;
+        pending += 1;
+        handler(items[index]).then((result) => {
+          results[index] = result;
+        }).catch(reject).finally(() => {
+          pending -= 1;
+          completed += 1;
+          updateProcessBar(completed, items.length);
+          next();
+        });
+      } else if (pending === 0) {
+        endProcessBar();
+        resolve(results);
+      }
+    };
+    startProcessBar(items.length);
+    for (let i = 0; i < limit; i += 1) {
+      next();
+    }
+  });
+};
+const JEDEC = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+const formatFileSize = (input) => {
+  if (Number.isNaN(input))
+    return "";
+  let size = Number(input);
+  const isNegative = size < 0;
+  const result = [];
+  if (isNegative)
+    size = -size;
+  let exponent = Math.floor(Math.log(size) / Math.log(1024));
+  if (exponent < 0)
+    exponent = 0;
+  if (exponent > 8)
+    exponent = 8;
+  if (size === 0) {
+    result[0] = 0;
+    result[1] = JEDEC[exponent];
+  } else {
+    const val = size / 2 ** (exponent * 10);
+    result[0] = Number(val.toFixed(exponent > 0 ? 2 : 0));
+    if (result[0] === 1024 && exponent < 8) {
+      result[0] = 1;
+      exponent += 1;
+    }
+    result[1] = JEDEC[exponent];
+  }
+  if (isNegative)
+    result[0] = -result[0];
+  return result.join(" ");
+};
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["error"] = 0] = "error";
+  LogLevel2[LogLevel2["warn"] = 1] = "warn";
+  LogLevel2[LogLevel2["info"] = 2] = "info";
+  LogLevel2[LogLevel2["debug"] = 3] = "debug";
+  return LogLevel2;
+})(LogLevel || {});
+const textLogLevel = ["ERROR", "WARN", "INFO", "DEBUG"];
+class CASCClient {
+  constructor(region, product, version, logLevel = 2 /* info */) {
+    __publicField$1(this, "region");
+    __publicField$1(this, "product");
+    __publicField$1(this, "version");
+    __publicField$1(this, "name2FileDataID", /* @__PURE__ */ new Map());
+    __publicField$1(this, "keys", /* @__PURE__ */ new Map());
+    __publicField$1(this, "preload");
+    __publicField$1(this, "logLevel");
+    this.region = region;
+    this.product = product;
+    this.version = version;
+    this.logLevel = logLevel;
+  }
+  static async getProductVersion(region, product) {
+    const versionsText = await getProductVersions(region, product);
+    const versions = parseProductVersions(versionsText);
+    return versions.find((version) => version.Region === region);
+  }
+  log(level, message) {
+    if (level <= this.logLevel) {
+      if (level >= 0 /* error */) {
+        console.error(`${( new Date()).toISOString()} [${textLogLevel[level]}]:`, message);
+      } else {
+        console.log(`${( new Date()).toISOString()} [${textLogLevel[level]}]:`, message);
+      }
+    }
+  }
+  async init() {
+    this.log(2 /* info */, "Preloading remote CASC build:");
+    this.log(2 /* info */, this.version);
+    this.log(2 /* info */, "Fetching CDN configuration...");
+    const serverConfigText = await getProductCDNs(this.region, this.product);
+    const serverConfig = parseProductCDNs(serverConfigText).find(
+      (config) => config.Name === this.region
+    );
+    assert(serverConfig, "No server config found");
+    this.log(2 /* info */, "Locating fastest CDN server...");
+    const prefixes = await resolveCDNHost(
+      serverConfig.Hosts.split(" "),
+      serverConfig.Path
+    );
+    this.log(2 /* info */, "Resolved CDN servers:");
+    prefixes.forEach((prefix) => {
+      this.log(2 /* info */, prefix);
+    });
+    this.log(2 /* info */, "Fetching build configurations...");
+    const cdnConfigText = await getConfigFile(prefixes, this.version.CDNConfig);
+    const cdnConfig = parseCDNConfig(cdnConfigText);
+    const buildConfigText = await getConfigFile(prefixes, this.version.BuildConfig);
+    const buildConfig = parseBuildConfig(buildConfigText);
+    this.log(2 /* info */, "Loading archives...");
+    const archiveKeys = cdnConfig.archives.split(" ");
+    const archiveCount = archiveKeys.length;
+    const archiveTotalSize = cdnConfig.archivesIndexSize.split(" ").reduce((a, b) => a + parseInt(b, 10), 0);
+    const archives = new Map(
+      (await asyncQueue(
+        archiveKeys,
+        async (key) => {
+          const fileName = `${key}.index`;
+          const buffer = await getDataFile(prefixes, fileName, "indexes", this.version.BuildConfig);
+          return parseArchiveIndex(buffer, key);
+        },
+        50
+      )).flatMap((e) => [...e])
+    );
+    this.log(
+      2 /* info */,
+      `Loaded ${archiveCount.toString()} archives (${archives.size.toString()} entries, ${formatFileSize(archiveTotalSize)})`
+    );
+    this.log(2 /* info */, "Loading encoding table...");
+    const [encodingCKey, encodingEKey] = buildConfig.encoding.split(" ");
+    const encodingBuffer = await getDataFile(prefixes, encodingEKey, "build", this.version.BuildConfig, "encoding");
+    this.log(2 /* info */, `Loaded encoding table (${formatFileSize(encodingBuffer.byteLength)})`);
+    this.log(2 /* info */, "Parsing encoding table...");
+    const encoding = parseEncodingFile(encodingBuffer, encodingEKey, encodingCKey);
+    this.log(2 /* info */, `Parsed encoding table (${encoding.cKey2EKey.size.toString()} entries)`);
+    this.log(2 /* info */, "Loading root table...");
+    const rootCKey = buildConfig.root;
+    const rootEKeys = encoding.cKey2EKey.get(rootCKey);
+    assert(rootEKeys, "Failing to find EKey for root table.");
+    const rootEKey = typeof rootEKeys === "string" ? rootEKeys : rootEKeys[0];
+    const rootBuffer = await getDataFile(prefixes, rootEKey, "build", this.version.BuildConfig, "root");
+    this.log(2 /* info */, `Loaded root table (${formatFileSize(rootBuffer.byteLength)})`);
+    this.log(2 /* info */, "Parsing root file...");
+    const rootFile = parseRootFile(rootBuffer, rootEKey, rootCKey);
+    this.log(2 /* info */, `Parsed root file (${rootFile.fileDataID2CKey.size.toString()} entries, ${rootFile.nameHash2FileDataID.size.toString()} hashes)`);
+    this.preload = {
+      prefixes,
+      archives,
+      encoding,
+      rootFile
+    };
+  }
+  async loadRemoteListFile() {
+    const url = "https://github.com/wowdev/wow-listfile/releases/download/202402031841/community-listfile.csv";
+    const text = await (await fetch(url)).text();
+    const lines = text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    lines.forEach((line) => {
+      const [fileDataID, name] = line.split(";");
+      this.name2FileDataID.set(name.trim(), parseInt(fileDataID.trim(), 10));
+    });
+  }
+  async loadRemoteTACTKeys() {
+    const url = "https://raw.githubusercontent.com/wowdev/TACTKeys/master/WoW.txt";
+    const text = await (await fetch(url)).text();
+    const lines = text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    lines.forEach((line) => {
+      const [keyName, keyHex] = line.split(" ");
+      assert(keyName.length === 16, `Invalid keyName length: ${keyName.length.toString()}`);
+      assert(keyHex.length === 32, `Invalid key length: ${keyHex.length.toString()}`);
+      const key = Uint8Array.from(Buffer.from(keyHex, "hex"));
+      this.keys.set(keyName.toLowerCase(), key);
+    });
+  }
+  async loadTACTKeys() {
+    const keysCKeys = this.getContentKeysByFileDataID(1302850);
+    const lookupCKeys = this.getContentKeysByFileDataID(1302851);
+    assert(keysCKeys?.[0], "Failing to find dbfilesclient/tactkey.db2");
+    assert(lookupCKeys?.[0], "Failing to find dbfilesclient/tactkeylookup.db2");
+    const [keysResult, lookupResult] = await Promise.all([
+      this.getFileByContentKey(keysCKeys[0].cKey),
+      this.getFileByContentKey(lookupCKeys[0].cKey)
+    ]);
+    const keysReader = new WDCReader(keysResult.buffer);
+    const lookupReader = new WDCReader(lookupResult.buffer);
+    [...lookupReader.rows.keys()].forEach((keyID) => {
+      const lookupRow = lookupReader.rows.get(keyID);
+      const keyRow = keysReader.rows.get(keyID);
+      if (keyRow) {
+        assert(Array.isArray(lookupRow) && lookupRow[0], `Invalid TACTKeyLookup table row at id ${keyID.toString()}`);
+        assert(Array.isArray(keyRow) && keyRow[0], `Invalid TACTKey table row at id ${keyID.toString()}`);
+        const keyName = lookupRow[0].data.toString(16).padStart(16, "0");
+        const keyHexLE = keyRow[0].data.toString(16).padStart(32, "0");
+        assert(keyName.length === 16, `Invalid keyName length: ${keyName.length.toString()}`);
+        assert(keyHexLE.length === 32, `Invalid key length: ${keyHexLE.length.toString()}`);
+        const keyHex = [...keyHexLE.matchAll(/.{2}/g)].map((v) => v[0]).reverse().join("");
+        const key = Uint8Array.from(Buffer.from(keyHex, "hex"));
+        this.keys.set(keyName.toLowerCase(), key);
+      }
+    });
+  }
+  getFileDataIDByName(name) {
+    assert(this.preload, "Client not initialized");
+    const { rootFile } = this.preload;
+    const { nameHash2FileDataID } = rootFile;
+    const nameHash = getNameHash(name);
+    return nameHash2FileDataID.get(nameHash) ?? this.name2FileDataID.get(name);
+  }
+  getContentKeysByFileDataID(fileDataID) {
+    assert(this.preload, "Client not initialized");
+    const { rootFile } = this.preload;
+    return rootFile.fileDataID2CKey.get(fileDataID);
+  }
+  async getFileByContentKey(cKey, allowMissingKey = false) {
+    assert(this.preload, "Client not initialized");
+    const { prefixes, encoding, archives } = this.preload;
+    const eKeys = encoding.cKey2EKey.get(cKey);
+    assert(eKeys, `Failing to find encoding key for ${cKey}`);
+    const eKey = typeof eKeys === "string" ? eKeys : eKeys[0];
+    const archive = archives.get(eKey);
+    const blte = archive ? await getDataFile(prefixes, archive.key, "data", this.version.BuildConfig, eKey, archive.offset, archive.size) : await getDataFile(prefixes, eKey, "data", this.version.BuildConfig);
+    const reader = new BLTEReader(blte, eKey, this.keys);
+    if (!allowMissingKey) {
+      reader.processBytes(allowMissingKey);
+      return {
+        type: "full",
+        buffer: reader.buffer
+      };
+    }
+    const blocks = reader.processBytes(allowMissingKey);
+    if (blocks.length === 0) {
+      const hash = crypto.createHash("md5").update(reader.buffer).digest("hex");
+      assert(hash === cKey, `Invalid hash: expected ${cKey}, got ${hash}`);
+      return {
+        type: "full",
+        buffer: reader.buffer
+      };
+    }
+    return {
+      type: "partial",
+      buffer: reader.buffer,
+      blocks
+    };
+  }
+}
+__publicField$1(CASCClient, "LocaleFlags", LocaleFlags);
+__publicField$1(CASCClient, "ContentFlags", ContentFlags);
+__publicField$1(CASCClient, "LogLevel", LogLevel);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const PATTERN_COLUMN = /^(int|float|locstring|string)(<[^:]+::[^>]+>)?\s([^\s]+)/;
+const PATTERN_LAYOUT = /^LAYOUT\s(.*)/;
+const PATTERN_FIELD = /^(\$([^$]+)\$)?([^<[]+)(<(u|)(\d+)>)?(\[(\d+)\])?$/;
+const castIntegerBySize = (value, src, srcSigned, dst, dstSigned) => {
+  const castBuffer = Buffer.alloc(6);
+  if (srcSigned) {
+    castBuffer.writeIntLE(value, 0, src);
+  } else {
+    castBuffer.writeUIntLE(value, 0, src);
+  }
+  return dstSigned ? castBuffer.readIntLE(0, dst) : castBuffer.readUIntLE(0, dst);
+};
+const castFloat = (value, src, srcSigned) => {
+  const castBuffer = Buffer.alloc(4);
+  if (srcSigned) {
+    castBuffer.writeIntLE(value, 0, src);
+  } else {
+    castBuffer.writeUIntLE(value, 0, src);
+  }
+  const result = castBuffer.readFloatLE(0);
+  return Math.round(result * 100) / 100;
+};
+const castBigInt64 = (value, srcSigned, dstSigned) => {
+  const castBuffer = Buffer.alloc(8);
+  if (srcSigned) {
+    castBuffer.writeBigInt64LE(value, 0);
+  } else {
+    castBuffer.writeBigUInt64LE(value, 0);
+  }
+  return dstSigned ? castBuffer.readBigInt64LE(0) : castBuffer.readBigUInt64LE(0);
+};
+class DBDParser {
+  constructor(wdc) {
+    __publicField(this, "wdc");
+    __publicField(this, "definitions", /* @__PURE__ */ new Map());
+    __publicField(this, "columns", []);
+    this.wdc = wdc;
+  }
+  async init() {
+    const manifestsURL = "https://raw.githubusercontent.com/wowdev/WoWDBDefs/master/manifest.json";
+    const manifests = await (await fetch(manifestsURL)).json();
+    const tableHashHex = this.wdc.tableHash.toString(16).padStart(8, "0").toLowerCase();
+    const manifest = manifests.find((v) => v.tableHash.toLowerCase() === tableHashHex);
+    assert(manifest?.tableName, `No manifest found for table hash ${tableHashHex}`);
+    const url = `https://raw.githubusercontent.com/wowdev/WoWDBDefs/master/definitions/${manifest.tableName}.dbd`;
+    const text = await (await fetch(url)).text();
+    const lines = text.split("\n").map((v) => v.trim());
+    const chunks = lines.reduce((acc, line) => {
+      if (line.length > 0) {
+        acc[acc.length - 1].push(line);
+      } else {
+        acc.push([]);
+      }
+      return acc;
+    }, [[]]).filter((chunk) => chunk.length > 0);
+    const columnsChunk = chunks.shift();
+    assert(columnsChunk?.[0] === "COLUMNS", "No column definitions found");
+    columnsChunk.shift();
+    columnsChunk.forEach((line) => {
+      const match = line.match(PATTERN_COLUMN);
+      if (match) {
+        const [, type, , name] = match;
+        this.definitions.set(name.replace("?", ""), type);
+      }
+    });
+    const layoutHashHex = this.wdc.layoutHash.toString(16).padStart(8, "0").toLowerCase();
+    const versionChunk = chunks.find((chunk) => chunk.find((line) => {
+      const layoutsMatch = line.match(PATTERN_LAYOUT);
+      const layouts = layoutsMatch?.[1].split(",").map((v) => v.trim().toLowerCase());
+      return layouts?.includes(layoutHashHex);
+    }));
+    assert(versionChunk, `No version definition found for layout hash ${layoutHashHex}`);
+    versionChunk.forEach((line) => {
+      if (line.startsWith("LAYOUT") || line.startsWith("BUILD") || line.startsWith("COMMENT")) {
+        return;
+      }
+      const match = line.match(PATTERN_FIELD);
+      if (match) {
+        const [, , annotationsText, name, , unsigned, sizeText, , arraySizeText] = match;
+        const type = this.definitions.get(name);
+        assert(type, `No type found for column ${name}`);
+        const annotations = annotationsText ? annotationsText.split(",").map((v) => v.trim()) : void 0;
+        const size = sizeText ? parseInt(sizeText, 10) : void 0;
+        const arraySize = arraySizeText ? parseInt(arraySizeText, 10) : void 0;
+        const isID = !!annotations?.includes("id");
+        const isInline = !annotations?.includes("noninline");
+        const isRelation = !!annotations?.includes("relation");
+        const isSigned = !unsigned;
+        this.columns.push({
+          name,
+          type,
+          isID,
+          isInline,
+          isRelation,
+          isSigned,
+          size,
+          arraySize
+        });
+      }
+    });
+  }
+  getAllIDs() {
+    return this.wdc.getAllIDs();
+  }
+  getRowData(id) {
+    const row = this.wdc.getRowData(id);
+    if (!row) {
+      return void 0;
+    }
+    const data = {};
+    if (Array.isArray(row)) {
+      let fieldIndex = 0;
+      this.columns.forEach((column) => {
+        if (column.isID) {
+          data[column.name] = id;
+          if (column.isInline) {
+            fieldIndex += 1;
+          }
+        } else if (column.isInline) {
+          const cell = row[fieldIndex];
+          assert(cell, `No value found for column ${column.name}`);
+          const fieldInfo = this.wdc.fieldsInfo[fieldIndex];
+          const srcSigned = fieldInfo.storageType === "bitpackedSigned";
+          const srcSize = fieldInfo.storageType === "none" || fieldInfo.storageType === "bitpacked" || fieldInfo.storageType === "bitpackedSigned" ? Math.ceil(fieldInfo.fieldSizeBits / 8) : 4;
+          const dstSize = column.size ? Math.ceil(column.size / 8) : void 0;
+          if (cell.type === "bitpackedArray") {
+            data[column.name] = cell.data.map((v) => {
+              if (column.type === "float") {
+                return castFloat(v, srcSize, srcSigned);
+              }
+              if (dstSize) {
+                return castIntegerBySize(
+                  v,
+                  srcSize,
+                  srcSigned,
+                  dstSize,
+                  column.isSigned
+                );
+              }
+              return v;
+            });
+          } else if (column.type === "string" || column.type === "locstring") {
+            if (cell.data > 0) {
+              assert(cell.type === "none", `Invalid data type for string column ${column.name}`);
+              assert(typeof cell.string === "string", `Missing string for string column ${column.name}`);
+              data[column.name] = cell.string;
+            }
+          } else if (column.type === "float") {
+            assert(typeof cell.data === "number", `Invalid data type for float column ${column.name}`);
+            data[column.name] = castFloat(cell.data, srcSize, srcSigned);
+          } else if (typeof cell.data === "number") {
+            data[column.name] = castIntegerBySize(
+              cell.data,
+              srcSize,
+              srcSigned,
+              dstSize ?? srcSize,
+              column.isSigned
+            );
+          } else {
+            assert(!column.size || column.size === 64, `Unexpected size ${column.size?.toString() ?? ""} for column ${column.name}`);
+            if (srcSigned !== column.isSigned) {
+              data[column.name] = castBigInt64(
+                cell.data,
+                srcSigned,
+                column.isSigned
+              );
+            } else {
+              data[column.name] = cell.data;
+            }
+          }
+          fieldIndex += 1;
+        } else if (column.isRelation) {
+          const relation = this.wdc.getRowRelationship(id);
+          data[column.name] = relation ?? 0;
+        }
+      });
+    } else {
+      const buffer = row.data;
+      let offset = 0;
+      let fieldIndex = 0;
+      this.columns.forEach((column) => {
+        if (column.isID) {
+          data[column.name] = id;
+          if (column.isInline) {
+            fieldIndex += 1;
+          }
+        } else if (column.isInline) {
+          const values = [];
+          if (column.type === "string" || column.type === "locstring") {
+            const count = column.arraySize ?? 1;
+            for (let i = 0; i < count; i += 1) {
+              const startOffset = offset;
+              while (buffer[offset] !== 0) {
+                offset += 1;
+              }
+              values.push(buffer.toString("utf-8", startOffset, offset));
+              offset += 1;
+            }
+            data[column.name] = count > 1 ? values : values[0];
+          } else {
+            const currField = this.wdc.fields[fieldIndex];
+            const nextField = this.wdc.fields[fieldIndex + 1];
+            const size = Math.ceil((column.size ?? 32 - currField.size) / 8);
+            let count;
+            if (fieldIndex + 1 < this.wdc.fields.length) {
+              count = (nextField.position - currField.position) / size;
+            } else {
+              count = column.arraySize ? (buffer.byteLength - offset) / size : 1;
+            }
+            for (let i = 0; i < count; i += 1) {
+              if (column.type === "float") {
+                const value = buffer.readFloatLE(offset);
+                values.push(Math.round(value * 100) / 100);
+                offset += 4;
+              } else if (size > 6) {
+                assert(size === 8, `Unexpected size ${size.toString()} for column ${column.name}`);
+                const value = column.isSigned ? buffer.readBigInt64LE(offset) : buffer.readBigUInt64LE(offset);
+                values.push(value);
+                offset += size;
+              } else {
+                const value = column.isSigned ? buffer.readIntLE(offset, size) : buffer.readUIntLE(offset, size);
+                values.push(value);
+                offset += size;
+              }
+            }
+            data[column.name] = count > 1 ? values : values[0];
+          }
+          fieldIndex += 1;
+        } else if (column.isRelation) {
+          const relation = this.wdc.getRowRelationship(id);
+          data[column.name] = relation ?? 0;
+        }
+      });
+    }
+    return data;
+  }
+}
+
+export { CASCClient, DBDParser, WDCReader };