@rhyster/wow-casc-dbc 2.5.0 → 2.6.0

package/dist/index.cjs

@@ -4,20 +4,20 @@ const assert = require('node:assert');
 const crypto = require('node:crypto');
 const async = require('async');
 const cliProgress = require('cli-progress');
+const zlib = require('node:zlib');
 const fs = require('node:fs/promises');
-const path = require('node:path');
 const http = require('node:http');
-const zlib = require('node:zlib');
+const path = require('node:path');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const assert__default = /*#__PURE__*/_interopDefaultCompat(assert);
 const crypto__default = /*#__PURE__*/_interopDefaultCompat(crypto);
 const cliProgress__default = /*#__PURE__*/_interopDefaultCompat(cliProgress);
+const zlib__default = /*#__PURE__*/_interopDefaultCompat(zlib);
 const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-const path__default = /*#__PURE__*/_interopDefaultCompat(path);
 const http__default = /*#__PURE__*/_interopDefaultCompat(http);
-const zlib__default = /*#__PURE__*/_interopDefaultCompat(zlib);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
 
 var __defProp$6 = Object.defineProperty;
 var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -25,121 +25,448 @@ var __publicField$6 = (obj, key, value) => {
   __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-class Store {
-  constructor(dataFile) {
-    __publicField$6(this, "data");
-    __publicField$6(this, "dataFile");
-    __publicField$6(this, "promise");
-    this.dataFile = dataFile;
-    this.data = {};
-    this.promise = new Promise((resolve) => {
-      fs__default.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__default.writeFile(this.dataFile, JSON.stringify(this.data), "utf-8");
+const ADB_MAGIC = 1481004104;
+class ADBReader {
+  constructor(buffer) {
+    __publicField$6(this, "build");
+    __publicField$6(this, "entries", []);
+    __publicField$6(this, "tableEntries", /* @__PURE__ */ new Map());
+    const magic = buffer.readUInt32BE(0);
+    assert__default(magic === ADB_MAGIC, `[ADB]: Invalid magic: ${magic.toString(16).padStart(8, "0")}`);
+    const version = buffer.readUInt32LE(4);
+    assert__default(version === 9, `[ADB]: Invalid version: ${version.toString()}`);
+    const build = buffer.readUInt32LE(8);
+    this.build = build;
+    let pointer = 44;
+    while (pointer < buffer.byteLength) {
+      const offset = pointer;
+      const entryMagic = buffer.readUInt32BE(offset);
+      assert__default(entryMagic === ADB_MAGIC, `[ADB]: Invalid entry magic: ${magic.toString(16).padStart(8, "0")}`);
+      const regionID = buffer.readInt32LE(offset + 4);
+      const pushID = buffer.readInt32LE(offset + 8);
+      const uniqueID = buffer.readUInt32LE(offset + 12);
+      const tableHash = buffer.readUInt32LE(offset + 16);
+      const recordID = buffer.readUInt32LE(offset + 20);
+      const dataSize = buffer.readUInt32LE(offset + 24);
+      const recordState = buffer.readUInt32LE(offset + 28);
+      const data = buffer.subarray(offset + 32, offset + 32 + dataSize);
+      const entry = {
+        regionID,
+        pushID,
+        uniqueID,
+        tableHash,
+        recordID,
+        dataSize,
+        recordState,
+        data
+      };
+      this.entries.push(entry);
+      if (!this.tableEntries.has(tableHash)) {
+        this.tableEntries.set(tableHash, []);
+      }
+      this.tableEntries.get(tableHash)?.push(entry);
+      pointer += 32 + dataSize;
+    }
   }
 }
 
-const USER_AGENT = "node-wow-casc-dbc";
-const CACHE_ROOT = path__default.resolve("cache");
-const CACHE_DIRS = {
-  build: "builds",
-  indexes: "indices",
-  data: "data",
-  dbd: "dbd"
+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;
 };
-const CACHE_INTEGRITY_FILE = path__default.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,
-  partialLength,
-  showProgress
-} = {}) => new Promise((resolve, reject) => {
-  const options = {
-    headers: {
-      "User-Agent": USER_AGENT,
-      Range: partialOffset && partialLength ? `bytes=${partialOffset.toString()}-${(partialOffset + partialLength - 1).toString()}` : "bytes=0-"
-    }
-  };
-  http__default.get(url, options, (res) => {
-    if (res.statusCode === 301 || res.statusCode === 302) {
-      if (res.headers.location) {
-        requestData(res.headers.location, { partialOffset, partialLength, showProgress }).then(resolve).catch((err) => {
-          throw err;
-        });
-      } else {
-        reject(new Error(`Failed to request ${url}, Status Code: ${res.statusCode.toString()}`));
+class Salsa20 {
+  constructor(key, nonce) {
+    __publicField$5(this, "fixed");
+    __publicField$5(this, "key");
+    __publicField$5(this, "nonce");
+    __publicField$5(this, "counter", new Uint32Array([0, 0]));
+    __publicField$5(this, "state", new Uint32Array(16));
+    __publicField$5(this, "block", new Uint8Array(64));
+    __publicField$5(this, "position", 0);
+    assert__default(key.length === 32 || key.length === 16, "Salsa20 requires 128-bit or 256-bit key");
+    assert__default(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);
       }
-      return;
+      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
+      ]);
     }
-    if (!res.statusCode || res.statusCode < 200 || res.statusCode > 302) {
-      reject(new Error(`Failed to request ${url}, Status Code: ${res.statusCode?.toString() ?? "undefined"}`));
-      return;
+    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);
     }
-    const lengthText = res.headers["content-length"];
-    const length = lengthText ? parseInt(lengthText, 10) : 0;
-    const bar = showProgress && !Number.isNaN(length) && length >= 10485760 ? new cliProgress__default.SingleBar({ etaBuffer: 10240 }, cliProgress__default.Presets.shades_classic) : void 0;
-    bar?.start(length, 0);
-    const chunks = [];
-    res.on("data", (chunk) => {
-      bar?.increment(chunk.length);
-      chunks.push(chunk);
-    });
-    res.on("end", () => {
-      bar?.stop();
-      resolve(Buffer.concat(chunks));
-    });
-    res.on("error", (err) => {
-      bar?.stop();
-      reject(err);
-    });
-  }).on("error", reject).end();
-});
-const downloadFile = (prefixes, type, key, {
-  partialOffset,
-  partialLength,
-  showProgress,
-  showAttemptFail
-} = {}) => {
-  const urls = prefixes.map((prefix) => `${prefix}/${type}/${formatCDNKey(key)}`);
-  return urls.reduce(
-    (prev, url, index) => prev.catch((err) => {
-      if (showAttemptFail && index > 0 && err instanceof Error) {
-        console.warn(`${( new Date()).toISOString()} [WARN]:`, err.message);
-      }
-      return requestData(url, { partialOffset, partialLength, showProgress });
-    }),
-    Promise.reject(new Error(""))
-  );
-};
-const getFileCache = async (file) => {
-  const integrity = await cacheIntegrity.get(file);
-  if (integrity) {
-    try {
-      const buffer = await fs__default.readFile(path__default.resolve(CACHE_ROOT, file));
-      const hash = crypto__default.createHash("sha256").update(buffer).digest("hex");
-      if (hash === integrity) {
-        return buffer;
+    this.generateBlock();
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  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;
       }
-    } catch {
+      result[i] = input[i] ^ this.block[this.position];
+      this.position += 1;
     }
+    return result;
   }
-  return void 0;
+}
+
+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;
 };
-const getDataFile = async (prefixes, key, type, buildCKey, {
+const BLTE_MAGIC = 1112298565;
+const ENC_TYPE_SALSA20 = 83;
+const EMPTY_HASH = "00000000000000000000000000000000";
+class BLTEReader {
+  constructor(buffer, eKey, keys = /* @__PURE__ */ new Map()) {
+    __publicField$4(this, "buffer");
+    __publicField$4(this, "blte");
+    __publicField$4(this, "blocks", []);
+    __publicField$4(this, "keys");
+    __publicField$4(this, "processedBlock", 0);
+    __publicField$4(this, "processedOffset", 0);
+    this.blte = buffer;
+    this.buffer = Buffer.alloc(0);
+    this.keys = keys;
+    const size = buffer.byteLength;
+    assert__default(size >= 8, `[BLTE]: Invalid size: ${size.toString()} < 8`);
+    const magic = buffer.readUInt32BE(0);
+    assert__default(magic === BLTE_MAGIC, `[BLTE]: Invalid magic: ${magic.toString(16).padStart(8, "0")}`);
+    const headerSize = buffer.readUInt32BE(4);
+    if (headerSize === 0) {
+      const blteHash2 = crypto__default.createHash("md5").update(buffer).digest("hex");
+      assert__default(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__default.createHash("md5").update(buffer.subarray(0, headerSize)).digest("hex");
+    assert__default(blteHash === eKey, `[BLTE]: Invalid hash: expected ${eKey}, got ${blteHash}`);
+    assert__default(size >= 12, `[BLTE]: Invalid size: ${size.toString()} < 12`);
+    const flag = buffer.readUInt8(8);
+    const numBlocks = buffer.readIntBE(9, 3);
+    assert__default(numBlocks > 0, `[BLTE]: Invalid number of blocks: ${numBlocks.toString()}`);
+    assert__default(flag === 15, `[BLTE]: Invalid flag: ${flag.toString(16).padStart(2, "0")}`);
+    const blockHeaderSize = numBlocks * 24;
+    assert__default(headerSize === blockHeaderSize + 12, `[BLTE]: Invalid header size: header size ${headerSize.toString()} != block header size ${blockHeaderSize.toString()} + 12`);
+    assert__default(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__default(encryptType === ENC_TYPE_SALSA20, `[BLTE]: Invalid encrypt type: ${encryptType.toString(16).padStart(2, "0")} at block ${index.toString()}`);
+        const keyName = [...keyNameBE.matchAll(/.{2}/g)].map((v) => v[0]).reverse().join("").toLowerCase();
+        const key = this.keys.get(keyName);
+        if (!key) {
+          if (allowMissingKey) {
+            return keyName;
+          }
+          throw new Error(`[BLTE]: Missing key: ${keyName} at block ${index.toString()}`);
+        }
+        const iv = new Uint8Array(8);
+        for (let i = 0; i < 8; i += 1) {
+          if (i < ivLength) {
+            iv[i] = ivBuffer.readUInt8(i) ^ index >>> 8 * i & 255;
+          } else {
+            iv[i] = 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 at block ${index.toString()}`);
+      case 78:
+        return buffer.subarray(1);
+      case 90:
+        return zlib__default.inflateSync(buffer.subarray(1));
+      default:
+        throw new Error(`[BLTE]: Invalid block flag: ${flag.toString(16).padStart(2, "0")} at block ${index.toString()}`);
+    }
+  }
+  processBytes(allowMissingKey = false, size = 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__default.createHash("md5").update(blockBuffer).digest("hex");
+        assert__default(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__default(
+            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__default(
+          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;
+  }
+}
+
+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;
+};
+class Store {
+  constructor(dataFile) {
+    __publicField$3(this, "data");
+    __publicField$3(this, "dataFile");
+    __publicField$3(this, "promise");
+    this.dataFile = dataFile;
+    this.data = {};
+    this.promise = new Promise((resolve) => {
+      fs__default.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__default.writeFile(this.dataFile, JSON.stringify(this.data), "utf-8");
+  }
+}
+
+const USER_AGENT = "node-wow-casc-dbc";
+const CACHE_ROOT = path__default.resolve("cache");
+const CACHE_DIRS = {
+  build: "builds",
+  indexes: "indices",
+  data: "data",
+  dbd: "dbd"
+};
+const CACHE_INTEGRITY_FILE = path__default.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,
+  partialLength,
+  showProgress
+} = {}) => new Promise((resolve, reject) => {
+  const options = {
+    headers: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      "User-Agent": USER_AGENT,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Range: partialOffset !== void 0 && partialLength !== void 0 ? `bytes=${partialOffset.toString()}-${(partialOffset + partialLength - 1).toString()}` : "bytes=0-"
+    }
+  };
+  http__default.get(url, options, (res) => {
+    if (res.statusCode === 301 || res.statusCode === 302) {
+      if (res.headers.location !== void 0) {
+        requestData(res.headers.location, { partialOffset, partialLength, showProgress }).then(resolve).catch((err) => {
+          throw err;
+        });
+      } else {
+        reject(new Error(`Failed to request ${url}, Status Code: ${res.statusCode.toString()}`));
+      }
+      return;
+    }
+    if (res.statusCode === void 0 || res.statusCode < 200 || res.statusCode > 302) {
+      reject(new Error(`Failed to request ${url}, Status Code: ${res.statusCode?.toString() ?? "undefined"}`));
+      return;
+    }
+    const lengthText = res.headers["content-length"];
+    const length = lengthText !== void 0 ? parseInt(lengthText, 10) : 0;
+    const bar = showProgress === true && !Number.isNaN(length) && length >= 10485760 ? new cliProgress__default.SingleBar({ etaBuffer: 10240 }, cliProgress__default.Presets.shades_classic) : void 0;
+    bar?.start(length, 0);
+    const chunks = [];
+    res.on("data", (chunk) => {
+      bar?.increment(chunk.length);
+      chunks.push(chunk);
+    });
+    res.on("end", () => {
+      bar?.stop();
+      resolve(Buffer.concat(chunks));
+    });
+    res.on("error", (err) => {
+      bar?.stop();
+      reject(err);
+    });
+  }).on("error", reject).end();
+});
+const downloadFile = (prefixes, type, key, {
+  partialOffset,
+  partialLength,
+  showProgress,
+  showAttemptFail
+} = {}) => {
+  const urls = prefixes.map((prefix) => `${prefix}/${type}/${formatCDNKey(key)}`);
+  return urls.reduce(
+    (prev, url, index) => prev.catch((err) => {
+      if (showAttemptFail === true && index > 0 && err instanceof Error) {
+        console.warn(`${( new Date()).toISOString()} [WARN]:`, err.message);
+      }
+      return requestData(url, { partialOffset, partialLength, showProgress });
+    }),
+    Promise.reject(new Error(""))
+  );
+};
+const getFileCache = async (file) => {
+  const integrity = await cacheIntegrity.get(file);
+  if (integrity !== void 0) {
+    try {
+      const buffer = await fs__default.readFile(path__default.resolve(CACHE_ROOT, file));
+      const hash = crypto__default.createHash("sha256").update(buffer).digest("hex");
+      if (hash === integrity) {
+        return buffer;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+};
+const getDataFile = async (prefixes, key, type, buildCKey, {
   name,
   partialOffset,
   partialLength,
@@ -147,7 +474,7 @@ const getDataFile = async (prefixes, key, type, buildCKey, {
   showAttemptFail
 } = {}) => {
   const dir = type === "build" ? path__default.join(CACHE_DIRS[type], buildCKey) : CACHE_DIRS[type];
-  const file = name ? path__default.join(dir, name) : path__default.join(dir, key);
+  const file = name !== void 0 ? path__default.join(dir, name) : path__default.join(dir, key);
   const cacheBuffer = await getFileCache(file);
   if (cacheBuffer) {
     if (name === void 0 && partialOffset !== void 0 && partialLength !== void 0) {
@@ -161,7 +488,7 @@ const getDataFile = async (prefixes, key, type, buildCKey, {
     showProgress,
     showAttemptFail
   });
-  if (partialOffset === void 0 && partialLength === void 0 || name) {
+  if (partialOffset === void 0 && partialLength === void 0 || name !== void 0) {
     await fs__default.mkdir(path__default.resolve(CACHE_ROOT, dir), { recursive: true });
     await fs__default.writeFile(path__default.resolve(CACHE_ROOT, file), downloadBuffer);
     const hash = crypto__default.createHash("sha256").update(downloadBuffer).digest("hex");
@@ -178,391 +505,204 @@ const getConfigFile = async (prefixes, key, {
 };
 const getProductVersions = async (region, product) => {
   const url = `http://${region}.patch.battle.net:1119/${product}/versions`;
-  const headers = {
-    "User-Agent": USER_AGENT
-  };
+  const headers = new Headers();
+  headers.set("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 headers = new Headers();
+  headers.set("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__default(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__default(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__default.createHash("md5").update(footer).digest("hex");
-  assert__default(hash === cKey, `Invalid footer hash in ${cKey}: expected ${cKey}, got ${hash}`);
-  const footerHash = crypto__default.createHash("md5").update(footerCheckBuffer).digest("hex").slice(0, checksumSize * 2);
-  assert__default(footerHash === footerChecksum, `Invalid footer checksum in ${cKey}: expected ${footerChecksum}, got ${footerHash}`);
-  const tocHash = crypto__default.createHash("md5").update(toc).digest("hex").slice(0, checksumSize * 2);
-  assert__default(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__default.createHash("md5").update(buffer.subarray(i * blockSize, (i + 1) * blockSize)).digest("hex").slice(0, checksumSize * 2);
-    assert__default(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__default(result.size === numElements, `Invalid number of elements: ${result.size.toString()} != ${numElements.toString()} in ${cKey}`);
-  return result;
-};
-
-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 Salsa20 {
-  constructor(key, nonce) {
-    __publicField$5(this, "fixed");
-    __publicField$5(this, "key");
-    __publicField$5(this, "nonce");
-    __publicField$5(this, "counter", new Uint32Array([0, 0]));
-    __publicField$5(this, "state", new Uint32Array(16));
-    __publicField$5(this, "block", new Uint8Array(64));
-    __publicField$5(this, "position", 0);
-    assert__default(key.length === 32 || key.length === 16, "Salsa20 requires 128-bit or 256-bit key");
-    assert__default(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;
-    }
+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;
   }
-  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;
+  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);
     }
-    return result;
+    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;
   }
-}
-
-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;
+  return [c >>> 0, b >>> 0];
 };
-const BLTE_MAGIC = 1112298565;
-const ENC_TYPE_SALSA20 = 83;
-const EMPTY_HASH = "00000000000000000000000000000000";
-class BLTEReader {
-  constructor(buffer, eKey, keys = /* @__PURE__ */ new Map()) {
-    __publicField$4(this, "buffer");
-    __publicField$4(this, "blte");
-    __publicField$4(this, "blocks", []);
-    __publicField$4(this, "keys");
-    __publicField$4(this, "processedBlock", 0);
-    __publicField$4(this, "processedOffset", 0);
-    this.blte = buffer;
-    this.buffer = Buffer.alloc(0);
-    this.keys = keys;
-    const size = buffer.byteLength;
-    assert__default(size >= 8, `[BLTE]: Invalid size: ${size.toString()} < 8`);
-    const magic = buffer.readUInt32BE(0);
-    assert__default(magic === BLTE_MAGIC, `[BLTE]: Invalid magic: ${magic.toString(16).padStart(8, "0")}`);
-    const headerSize = buffer.readUInt32BE(4);
-    if (headerSize === 0) {
-      const blteHash2 = crypto__default.createHash("md5").update(buffer).digest("hex");
-      assert__default(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__default.createHash("md5").update(buffer.subarray(0, headerSize)).digest("hex");
-    assert__default(blteHash === eKey, `[BLTE]: Invalid hash: expected ${eKey}, got ${blteHash}`);
-    assert__default(size >= 12, `[BLTE]: Invalid size: ${size.toString()} < 12`);
-    const flag = buffer.readUInt8(8);
-    const numBlocks = buffer.readIntBE(9, 3);
-    assert__default(numBlocks > 0, `[BLTE]: Invalid number of blocks: ${numBlocks.toString()}`);
-    assert__default(flag === 15, `[BLTE]: Invalid flag: ${flag.toString(16).padStart(2, "0")}`);
-    const blockHeaderSize = numBlocks * 24;
-    assert__default(headerSize === blockHeaderSize + 12, `[BLTE]: Invalid header size: header size ${headerSize.toString()} != block header size ${blockHeaderSize.toString()} + 12`);
-    assert__default(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__default(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__default.inflateSync(buffer.subarray(1));
-      default:
-        throw new Error(`[BLTE]: Invalid block flag: ${flag.toString(16).padStart(2, "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")}`;
+};
+
+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];
   }
-  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__default.createHash("md5").update(blockBuffer).digest("hex");
-        assert__default(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__default(
-            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__default(
-          buffer.byteLength === block.decompressedSize,
-          `[BLTE]: Invalid decompressed size: expected ${block.decompressedSize.toString()}, got ${buffer.byteLength.toString()}`
-        );
-        this.buffer = Buffer.concat([this.buffer, buffer]);
+  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__default(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__default.createHash("md5").update(footer).digest("hex");
+  assert__default(hash === cKey, `Invalid footer hash in ${cKey}: expected ${cKey}, got ${hash}`);
+  const footerHash = crypto__default.createHash("md5").update(footerCheckBuffer).digest("hex").slice(0, checksumSize * 2);
+  assert__default(footerHash === footerChecksum, `Invalid footer checksum in ${cKey}: expected ${footerChecksum}, got ${footerHash}`);
+  const tocHash = crypto__default.createHash("md5").update(toc).digest("hex").slice(0, checksumSize * 2);
+  assert__default(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__default.createHash("md5").update(buffer.subarray(i * blockSize, (i + 1) * blockSize)).digest("hex").slice(0, checksumSize * 2);
+    assert__default(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;
       }
-      this.processedBlock += 1;
-      this.processedOffset += block.compressedSize;
     }
-    return allowMissingKey ? missingKeyBlocks : void 0;
   }
-}
+  assert__default(result.size === numElements, `Invalid number of elements: ${result.size.toString()} != ${numElements.toString()} in ${cKey}`);
+  return result;
+};
+
+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 = /([^\s]+)\s?=\s?(.*)/.exec(line);
+    assert__default(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 ENC_MAGIC = 17742;
 const MAGIC_OFFSET = 0;
@@ -681,6 +821,22 @@ const parseEncodingFile = (inputBuffer, eKey, cKey) => {
   };
 };
 
+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 MFST_MAGIC = 1296454484;
 const ContentFlags = {
   Install: 4,
@@ -806,99 +962,66 @@ const parseRootFile = (inputBuffer, eKey, cKey) => {
   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);
+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;
     }
-    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;
+    result[1] = JEDEC[exponent];
   }
-  return [c >>> 0, b >>> 0];
+  if (isNegative)
+    result[0] = -result[0];
+  return result.join(" ");
 };
-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")}`;
+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}`);
 };
 
-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);
+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;
@@ -921,17 +1044,17 @@ const readBitpackedValue = (buffer, fieldOffsetBits, fieldSizeBits, signed = fal
 };
 class WDCReader {
   constructor(buffer, blocks = [], adb) {
-    __publicField$3(this, "tableHash");
-    __publicField$3(this, "layoutHash");
-    __publicField$3(this, "locale");
-    __publicField$3(this, "isNormal");
-    __publicField$3(this, "hasRelationshipData");
-    __publicField$3(this, "fields");
-    __publicField$3(this, "fieldsInfo");
-    __publicField$3(this, "rows", /* @__PURE__ */ new Map());
-    __publicField$3(this, "relationships", /* @__PURE__ */ new Map());
-    __publicField$3(this, "copyTable", /* @__PURE__ */ new Map());
-    __publicField$3(this, "hotfixes", /* @__PURE__ */ new Map());
+    __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());
+    __publicField$2(this, "hotfixes", /* @__PURE__ */ new Map());
     const magic = buffer.readUInt32BE(0);
     const fieldCount = buffer.readUInt32LE(140);
     const recordSize = buffer.readUInt32LE(144);
@@ -1257,7 +1380,7 @@ class WDCReader {
                     data: value
                   };
                 }
-                if (!recordID && fieldIndex === idIndex) {
+                if (recordID === void 0 && fieldIndex === idIndex) {
                   recordID = value;
                 }
                 const fieldOffset = fieldInfo.fieldOffsetBits >>> 3;
@@ -1269,7 +1392,7 @@ class WDCReader {
                 };
               }
               case "commonData": {
-                const value = (recordID ? commonData.get(fieldIndex)?.get(recordID) : void 0) ?? fieldInfo.defaultValue;
+                const value = (recordID !== void 0 ? commonData.get(fieldIndex)?.get(recordID) : void 0) ?? fieldInfo.defaultValue;
                 return {
                   type: "commonData",
                   data: value
@@ -1304,7 +1427,7 @@ class WDCReader {
                   assert__default(fieldPalletData, `No pallet data for field ${fieldIndex.toString()}`);
                   value = fieldPalletData[value];
                 }
-                if (!recordID && fieldIndex === idIndex) {
+                if (recordID === void 0 && fieldIndex === idIndex) {
                   recordID = value;
                 }
                 return {
@@ -1319,7 +1442,7 @@ class WDCReader {
           assert__default(recordID !== void 0, "No record ID found");
           this.rows.set(recordID, recordData);
           const foreignID = relationshipMap.get(recordIndex);
-          if (foreignID) {
+          if (foreignID !== void 0) {
             this.relationships.set(recordID, foreignID);
           }
         } else {
@@ -1330,7 +1453,7 @@ class WDCReader {
           assert__default(recordID !== void 0, "No record ID found");
           this.rows.set(recordID, recordData);
           const foreignID = relationshipMap.get(recordIndex);
-          if (foreignID) {
+          if (foreignID !== void 0) {
             this.relationships.set(recordID, foreignID);
           }
         }
@@ -1374,70 +1497,24 @@ class WDCReader {
       }
     }
     const dst = this.copyTable.get(id);
-    if (dst) {
+    if (dst !== void 0) {
       return this.rows.get(dst);
     }
     return this.rows.get(id);
   }
   getRowRelationship(id) {
     const dst = this.copyTable.get(id);
-    if (dst) {
+    if (dst !== void 0) {
       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 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$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);
+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) => {
@@ -1447,16 +1524,21 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["debug"] = 3] = "debug";
   return LogLevel2;
 })(LogLevel || {});
-const textLogLevel = ["ERROR", "WARN", "INFO", "DEBUG"];
+const textLogLevel = [
+  "ERROR",
+  "WARN",
+  "INFO",
+  "DEBUG"
+];
 class CASCClient {
   constructor(region, product, version, logLevel = 2 /* info */) {
-    __publicField$2(this, "region");
-    __publicField$2(this, "product");
-    __publicField$2(this, "version");
-    __publicField$2(this, "name2FileDataID", /* @__PURE__ */ new Map());
-    __publicField$2(this, "keys", /* @__PURE__ */ new Map());
-    __publicField$2(this, "preload");
-    __publicField$2(this, "logLevel");
+    __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;
@@ -1472,7 +1554,7 @@ class CASCClient {
       if (level <= 0 /* error */) {
         console.error(`${( new Date()).toISOString()} [${textLogLevel[level]}]:`, message);
       } else {
-        console.log(`${( new Date()).toISOString()} [${textLogLevel[level]}]:`, message);
+        console.info(`${( new Date()).toISOString()} [${textLogLevel[level]}]:`, message);
       }
     }
   }
@@ -1551,7 +1633,7 @@ class CASCClient {
     this.log(2 /* info */, "Loading root table...");
     const rootCKey = buildConfig.root;
     const rootEKeys = encoding.cKey2EKey.get(rootCKey);
-    assert__default(rootEKeys, "Failing to find EKey for root table.");
+    assert__default(rootEKeys !== void 0, "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, {
       name: "root",
@@ -1605,8 +1687,8 @@ class CASCClient {
       const lookupRow = lookupReader.rows.get(keyID);
       const keyRow = keysReader.rows.get(keyID);
       if (keyRow) {
-        assert__default(Array.isArray(lookupRow) && lookupRow[0], `Invalid TACTKeyLookup table row at id ${keyID.toString()}`);
-        assert__default(Array.isArray(keyRow) && keyRow[0], `Invalid TACTKey table row at id ${keyID.toString()}`);
+        assert__default(Array.isArray(lookupRow) && lookupRow.length > 0, `Invalid TACTKeyLookup table row at id ${keyID.toString()}`);
+        assert__default(Array.isArray(keyRow) && keyRow.length > 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__default(keyName.length === 16, `Invalid keyName length: ${keyName.length.toString()}`);
@@ -1658,7 +1740,7 @@ class CASCClient {
     assert__default(this.preload, "Client not initialized");
     const { prefixes, encoding, archives } = this.preload;
     const eKeys = encoding.cKey2EKey.get(cKey);
-    assert__default(eKeys, `Failing to find encoding key for ${cKey}`);
+    assert__default(eKeys !== void 0, `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, {
@@ -1674,9 +1756,12 @@ class CASCClient {
     const reader = new BLTEReader(blte, eKey, this.keys);
     if (!allowMissingKey) {
       reader.processBytes(allowMissingKey);
+      const hash = crypto__default.createHash("md5").update(reader.buffer).digest("hex");
+      assert__default(hash === cKey, `Invalid hash: expected ${cKey}, got ${hash}`);
       return {
         type: "full",
-        buffer: reader.buffer
+        buffer: reader.buffer,
+        blocks: void 0
       };
     }
     const blocks = reader.processBytes(allowMissingKey);
@@ -1685,7 +1770,8 @@ class CASCClient {
       assert__default(hash === cKey, `Invalid hash: expected ${cKey}, got ${hash}`);
       return {
         type: "full",
-        buffer: reader.buffer
+        buffer: reader.buffer,
+        blocks: void 0
       };
     }
     return {
@@ -1695,14 +1781,17 @@ class CASCClient {
     };
   }
 }
-__publicField$2(CASCClient, "LocaleFlags", LocaleFlags);
-__publicField$2(CASCClient, "ContentFlags", ContentFlags);
-__publicField$2(CASCClient, "LogLevel", LogLevel);
+// eslint-disable-next-line @typescript-eslint/naming-convention
+__publicField$1(CASCClient, "LocaleFlags", LocaleFlags);
+// eslint-disable-next-line @typescript-eslint/naming-convention
+__publicField$1(CASCClient, "ContentFlags", ContentFlags);
+// eslint-disable-next-line @typescript-eslint/naming-convention
+__publicField$1(CASCClient, "LogLevel", LogLevel);
 
-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);
+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]+)/;
@@ -1747,10 +1836,10 @@ const getCastBuffer = (value, srcSize, dstSize) => {
 };
 class DBDParser {
   constructor(wdc) {
-    __publicField$1(this, "wdc");
-    __publicField$1(this, "definitions", /* @__PURE__ */ new Map());
-    __publicField$1(this, "columns", []);
-    __publicField$1(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "wdc");
+    __publicField(this, "definitions", /* @__PURE__ */ new Map());
+    __publicField(this, "columns", []);
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
     this.wdc = wdc;
   }
   async init() {
@@ -1758,7 +1847,7 @@ class DBDParser {
     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__default(manifest?.tableName, `No manifest found for table hash ${tableHashHex}`);
+    assert__default(manifest?.tableName !== void 0, `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());
@@ -1774,7 +1863,7 @@ class DBDParser {
     assert__default(columnsChunk?.[0] === "COLUMNS", "No column definitions found");
     columnsChunk.shift();
     columnsChunk.forEach((line) => {
-      const match = line.match(PATTERN_COLUMN);
+      const match = PATTERN_COLUMN.exec(line);
       if (match) {
         const [, type, , name] = match;
         this.definitions.set(name.replace("?", ""), type);
@@ -1782,7 +1871,7 @@ class DBDParser {
     });
     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 layoutsMatch = PATTERN_LAYOUT.exec(line);
       const layouts = layoutsMatch?.[1].split(",").map((v) => v.trim().toLowerCase());
       return layouts?.includes(layoutHashHex);
     }));
@@ -1791,17 +1880,27 @@ class DBDParser {
       if (line.startsWith("LAYOUT") || line.startsWith("BUILD") || line.startsWith("COMMENT")) {
         return;
       }
-      const match = line.match(PATTERN_FIELD);
+      const match = PATTERN_FIELD.exec(line);
       if (match) {
-        const [, , annotationsText, name, , unsigned, sizeText, , arraySizeText] = match;
+        const [
+          ,
+          ,
+          annotationsText,
+          name,
+          ,
+          unsigned,
+          sizeText,
+          ,
+          arraySizeText
+        ] = match;
         const type = this.definitions.get(name);
-        assert__default(type, `No type found for column ${name}`);
-        const annotations = annotationsText ? annotationsText.split(",").map((v) => v.trim()) : void 0;
+        assert__default(type !== void 0, `No type found for column ${name}`);
+        const annotations = annotationsText ? annotationsText.split(",").map((v) => v.trim()) : [];
         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 isID = !!annotations.includes("id");
+        const isInline = !annotations.includes("noninline");
+        const isRelation = !!annotations.includes("relation");
         const isSigned = !unsigned;
         this.columns.push({
           name,
@@ -1842,18 +1941,18 @@ class DBDParser {
             fieldIndex += 1;
           }
         } else if (column.isInline) {
+          assert__default(row.length > fieldIndex, `No value found for column ${column.name}`);
           const cell = row[fieldIndex];
-          assert__default(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;
+          const dstSize = column.size !== void 0 ? 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) {
+              if (dstSize !== void 0) {
                 return castIntegerBySize(
                   v,
                   srcSize,
@@ -1871,7 +1970,7 @@ class DBDParser {
               data[column.name] = cell.string;
             }
           } else if (column.type === "float") {
-            if (column.arraySize) {
+            if (column.arraySize !== void 0) {
               const castBuffer = getCastBuffer(
                 typeof cell.data === "number" ? BigInt(cell.data) : cell.data,
                 srcSize,
@@ -1888,8 +1987,8 @@ class DBDParser {
               data[column.name] = castFloat(cell.data, srcSize, srcSigned);
             }
           } else if (column.type === "int") {
-            if (column.arraySize) {
-              assert__default(dstSize, `Missing size for int array column ${column.name}`);
+            if (column.arraySize !== void 0) {
+              assert__default(dstSize !== void 0, `Missing size for int array column ${column.name}`);
               const castBuffer = getCastBuffer(
                 typeof cell.data === "number" ? BigInt(cell.data) : cell.data,
                 srcSize,
@@ -1917,7 +2016,7 @@ class DBDParser {
                 column.isSigned
               );
             } else {
-              assert__default(!column.size || column.size === 64, `Unexpected size ${column.size?.toString() ?? ""} for column ${column.name}`);
+              assert__default(column.size === void 0 || column.size === 64, `Unexpected size ${column.size?.toString() ?? ""} for column ${column.name}`);
               if (srcSigned !== column.isSigned) {
                 data[column.name] = castBigInt64(
                   cell.data,
@@ -1971,7 +2070,7 @@ class DBDParser {
             if (fieldIndex + 1 < this.wdc.fields.length) {
               count = Math.max((nextField.position - currField.position) / size, 1);
             } else {
-              count = column.arraySize ? (buffer.byteLength - offset) / size : 1;
+              count = column.arraySize !== void 0 ? (buffer.byteLength - offset) / size : 1;
             }
             for (let i = 0; i < count; i += 1) {
               if (column.type === "float") {
@@ -2003,57 +2102,6 @@ class DBDParser {
   }
 }
 
-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 ADB_MAGIC = 1481004104;
-class ADBReader {
-  constructor(buffer) {
-    __publicField(this, "build");
-    __publicField(this, "entries", []);
-    __publicField(this, "tableEntries", /* @__PURE__ */ new Map());
-    const magic = buffer.readUInt32BE(0);
-    assert__default(magic === ADB_MAGIC, `[ADB]: Invalid magic: ${magic.toString(16).padStart(8, "0")}`);
-    const version = buffer.readUInt32LE(4);
-    assert__default(version === 9, `[ADB]: Invalid version: ${version.toString()}`);
-    const build = buffer.readUInt32LE(8);
-    this.build = build;
-    let pointer = 44;
-    while (pointer < buffer.byteLength) {
-      const offset = pointer;
-      const entryMagic = buffer.readUInt32BE(offset);
-      assert__default(entryMagic === ADB_MAGIC, `[ADB]: Invalid entry magic: ${magic.toString(16).padStart(8, "0")}`);
-      const regionID = buffer.readInt32LE(offset + 4);
-      const pushID = buffer.readInt32LE(offset + 8);
-      const uniqueID = buffer.readUInt32LE(offset + 12);
-      const tableHash = buffer.readUInt32LE(offset + 16);
-      const recordID = buffer.readUInt32LE(offset + 20);
-      const dataSize = buffer.readUInt32LE(offset + 24);
-      const recordState = buffer.readUInt32LE(offset + 28);
-      const data = buffer.subarray(offset + 32, offset + 32 + dataSize);
-      const entry = {
-        regionID,
-        pushID,
-        uniqueID,
-        tableHash,
-        recordID,
-        dataSize,
-        recordState,
-        data
-      };
-      this.entries.push(entry);
-      if (!this.tableEntries.has(tableHash)) {
-        this.tableEntries.set(tableHash, []);
-      }
-      this.tableEntries.get(tableHash)?.push(entry);
-      pointer += 32 + dataSize;
-    }
-  }
-}
-
 exports.ADBReader = ADBReader;
 exports.CASCClient = CASCClient;
 exports.DBDParser = DBDParser;