data-of-loathing 1.0.0

package/dist/entityTypes/effects.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEffects = exports.EffectQuality = void 0;
+const utils_1 = require("../utils");
+var EffectQuality;
+(function (EffectQuality) {
+    EffectQuality["Good"] = "good";
+    EffectQuality["Neutral"] = "neutral";
+    EffectQuality["Bad"] = "bad";
+})(EffectQuality || (exports.EffectQuality = EffectQuality = {}));
+const isValidQuality = (0, utils_1.isMemberOfEnum)(EffectQuality);
+const parseEffect = (parts) => ({
+    id: Number(parts[0]),
+    name: parts[1],
+    image: parts[2],
+    descid: parts[3],
+    quality: isValidQuality(parts[4]) ? parts[4] : EffectQuality.Neutral,
+    attributes: parts[5]
+        .split(",")
+        .map((p) => p.trim())
+        .filter((p) => p !== "none"),
+    actions: parts[6].split("|"),
+});
+const loadEffects = (lastKnownSize) => __awaiter(void 0, void 0, void 0, function* () {
+    const raw = yield (0, utils_1.loadMafiaData)("statuseffects", lastKnownSize);
+    if (raw === null)
+        return null;
+    return Object.assign(Object.assign({}, raw), { data: raw.data.filter((p) => p.length > 2).map(parseEffect) });
+});
+exports.loadEffects = loadEffects;

package/dist/entityTypes/effects.test.js

@@ -0,0 +1,31 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const effects_1 = require("./effects");
+const testUtils_1 = require("../testUtils");
+global.fetch = vitest_1.vi.fn();
+(0, vitest_1.test)("Can read effects", () => __awaiter(void 0, void 0, void 0, function* () {
+    vitest_1.vi.mocked(fetch).mockResolvedValue((0, testUtils_1.createFetchResponse)("1\n5\tFar Out\tfarout.gif\t5ad503e9df2df73bfbbb5377b622c8c4\tgood\tnone\tuse 1 patchouli incense stick"));
+    const effects = yield (0, effects_1.loadEffects)();
+    (0, testUtils_1.expectNotNull)(effects);
+    (0, vitest_1.expect)(effects.data.length).toBe(1);
+    const effect = effects.data[0];
+    (0, vitest_1.expect)(effect).toMatchObject({
+        id: 5,
+        name: "Far Out",
+        image: "farout.gif",
+        descid: "5ad503e9df2df73bfbbb5377b622c8c4",
+        attributes: [],
+        quality: "good",
+        actions: ["use 1 patchouli incense stick"],
+    });
+}));

package/dist/entityTypes/familiars.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFamiliars = exports.isOwnable = exports.FamiliarType = void 0;
+const utils_1 = require("../utils");
+var FamiliarType;
+(function (FamiliarType) {
+    FamiliarType["Stat0"] = "stat0";
+    FamiliarType["Stat1"] = "stat1";
+    FamiliarType["Item0"] = "item0";
+    FamiliarType["Item1"] = "item1";
+    FamiliarType["Item2"] = "item2";
+    FamiliarType["Item3"] = "item3";
+    FamiliarType["Meat0"] = "meat0";
+    FamiliarType["Combat0"] = "combat0";
+    FamiliarType["Combat1"] = "combat1";
+    FamiliarType["Drop"] = "drop";
+    FamiliarType["Block"] = "block";
+    FamiliarType["Delevel"] = "delevel";
+    FamiliarType["Hp0"] = "hp0";
+    FamiliarType["Mp0"] = "mp0";
+    FamiliarType["Meat1"] = "meat1";
+    FamiliarType["Stat2"] = "stat2";
+    FamiliarType["Other0"] = "other0";
+    FamiliarType["Hp1"] = "hp1";
+    FamiliarType["Mp1"] = "mp1";
+    FamiliarType["Stat3"] = "stat3";
+    FamiliarType["Other1"] = "other1";
+    FamiliarType["Passive"] = "passive";
+    FamiliarType["Underwater"] = "underwater";
+    FamiliarType["Variable"] = "variable";
+})(FamiliarType || (exports.FamiliarType = FamiliarType = {}));
+const isValidType = (0, utils_1.isMemberOfEnum)(FamiliarType);
+const isOwnable = ({ id }) => {
+    // April Fools familiars
+    if (id >= 125 && id < 134)
+        return false;
+    // Pokefams
+    if (id >= 215 && id < 260)
+        return false;
+    return true;
+};
+exports.isOwnable = isOwnable;
+const parseFamiliar = (parts) => {
+    var _a, _b;
+    return ({
+        id: Number(parts[0]),
+        name: parts[1],
+        image: parts[2],
+        types: parts[3]
+            .split(",")
+            .map((p) => p.trim())
+            .filter(isValidType),
+        larva: parts[4],
+        equipment: parts[5] || null,
+        arenaStats: {
+            cageMatch: Number(parts[6]),
+            scavengerHunt: Number(parts[7]),
+            obstacleCourse: Number(parts[8]),
+            hideAndSeek: Number(parts[9]),
+        },
+        attributes: (_b = (_a = parts[10]) === null || _a === void 0 ? void 0 : _a.split(",")) !== null && _b !== void 0 ? _b : [],
+    });
+};
+const loadFamiliars = (lastKnownSize) => __awaiter(void 0, void 0, void 0, function* () {
+    const raw = yield (0, utils_1.loadMafiaData)("familiars", lastKnownSize);
+    if (raw === null)
+        return null;
+    return Object.assign(Object.assign({}, raw), { data: raw.data.filter((p) => p.length > 2).map(parseFamiliar) });
+});
+exports.loadFamiliars = loadFamiliars;

package/dist/entityTypes/familiars.test.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const testUtils_1 = require("../testUtils");
+const familiars_1 = require("./familiars");
+global.fetch = vitest_1.vi.fn();
+(0, vitest_1.test)("Can read familiars", () => __awaiter(void 0, void 0, void 0, function* () {
+    vitest_1.vi.mocked(fetch).mockResolvedValue((0, testUtils_1.createFetchResponse)("1\n7\tSpooky Pirate Skeleton\tfamiliar7.gif\tcombat1,delevel\tspooky pirate skeleton\tblundarrrbus\t2\t3\t1\t0\thashands,haseyes,undead,cantalk"));
+    const familiars = yield (0, familiars_1.loadFamiliars)();
+    (0, testUtils_1.expectNotNull)(familiars);
+    (0, vitest_1.expect)(familiars.data.length).toBe(1);
+    const familiar = familiars.data[0];
+    (0, vitest_1.expect)(familiar).toMatchObject({
+        id: 7,
+        name: "Spooky Pirate Skeleton",
+        image: "familiar7.gif",
+        types: [familiars_1.FamiliarType.Combat1, familiars_1.FamiliarType.Delevel],
+        larva: "spooky pirate skeleton",
+        equipment: "blundarrrbus",
+        arenaStats: {
+            cageMatch: 2,
+            hideAndSeek: 0,
+            obstacleCourse: 1,
+            scavengerHunt: 3,
+        },
+        attributes: ["hashands", "haseyes", "undead", "cantalk"],
+    });
+}));

package/dist/entityTypes/items.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadItems = exports.ItemUse = void 0;
+const utils_1 = require("../utils");
+var ItemUse;
+(function (ItemUse) {
+    // Primary
+    ItemUse["Food"] = "food";
+    ItemUse["Drink"] = "drink";
+    ItemUse["Spleen"] = "spleen";
+    ItemUse["Potion"] = "potion";
+    ItemUse["Avatar"] = "avatar";
+    ItemUse["Usable"] = "usable";
+    ItemUse["Multiple"] = "multiple";
+    ItemUse["Reusable"] = "reusable";
+    ItemUse["Message"] = "message";
+    ItemUse["Grow"] = "grow";
+    ItemUse["PokePill"] = "pokepill";
+    ItemUse["Hat"] = "hat";
+    ItemUse["Weapon"] = "weapon";
+    ItemUse["Sixgun"] = "sixgun";
+    ItemUse["Offhand"] = "offhand";
+    ItemUse["Container"] = "container";
+    ItemUse["Shirt"] = "shirt";
+    ItemUse["Pants"] = "pants";
+    ItemUse["Accessory"] = "accessory";
+    ItemUse["Familiar"] = "familiar";
+    ItemUse["Sticker"] = "sticker";
+    ItemUse["Card"] = "card";
+    ItemUse["Folder"] = "folder";
+    ItemUse["Bootspur"] = "bootspur";
+    ItemUse["Bootskin"] = "bootskin";
+    ItemUse["FoodHelper"] = "food helper";
+    ItemUse["DrinkHelper"] = "drink helper";
+    ItemUse["Zap"] = "zap";
+    ItemUse["Sphere"] = "sphere";
+    ItemUse["Guardian"] = "guardian";
+    // Secondary
+    ItemUse["Combat"] = "combat";
+    ItemUse["CombatReusable"] = "combat reusable";
+    ItemUse["Single"] = "single";
+    ItemUse["Solo"] = "solo";
+    ItemUse["Curse"] = "curse";
+    ItemUse["Bounty"] = "bounty";
+    ItemUse["Package"] = "package";
+    ItemUse["Candy"] = "candy";
+    ItemUse["Candy1"] = "candy1";
+    ItemUse["Candy2"] = "candy2";
+    ItemUse["Chocolate"] = "chocolate";
+    ItemUse["Fancy"] = "fancy";
+    ItemUse["Paste"] = "paste";
+    ItemUse["Smith"] = "smith";
+    ItemUse["Cook"] = "cook";
+    ItemUse["Mix"] = "mix";
+    ItemUse["Matchable"] = "matchable";
+})(ItemUse || (exports.ItemUse = ItemUse = {}));
+const isValidItemUse = (0, utils_1.isMemberOfEnum)(ItemUse);
+const parseAccess = (accessString) => {
+    const access = accessString.split(",").map((p) => p.trim());
+    return {
+        quest: access.includes("q"),
+        gift: access.includes("g"),
+        tradeable: access.includes("t"),
+        discardable: access.includes("d"),
+    };
+};
+const parseItem = (parts) => (Object.assign(Object.assign({ id: Number(parts[0]), name: parts[1], descid: parts[2], image: parts[3], uses: parts[4].split(", ").filter(isValidItemUse) }, parseAccess(parts[5])), { autosell: Number(parts[6]), plural: parts[7] }));
+const loadItems = (lastKnownSize) => __awaiter(void 0, void 0, void 0, function* () {
+    const raw = yield (0, utils_1.loadMafiaData)("items", lastKnownSize);
+    if (raw === null)
+        return null;
+    return Object.assign(Object.assign({}, raw), { data: raw.data.filter((p) => p.length > 2).map(parseItem) });
+});
+exports.loadItems = loadItems;

package/dist/entityTypes/items.test.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const testUtils_1 = require("../testUtils");
+const items_1 = require("./items");
+global.fetch = vitest_1.vi.fn();
+(0, vitest_1.test)("Can read items", () => __awaiter(void 0, void 0, void 0, function* () {
+    vitest_1.vi.mocked(fetch).mockResolvedValue((0, testUtils_1.createFetchResponse)("1\n87\tmeat from yesterday\t653772183\tmeat.gif\tnone, paste\tt,d\t5\tmeats from yesterday"));
+    const items = yield (0, items_1.loadItems)();
+    (0, testUtils_1.expectNotNull)(items);
+    (0, vitest_1.expect)(items.data.length).toBe(1);
+    const item = items.data[0];
+    (0, vitest_1.expect)(item).toMatchObject({
+        id: 87,
+        name: "meat from yesterday",
+        descid: "653772183",
+        image: "meat.gif",
+        uses: [items_1.ItemUse.Paste],
+        quest: false,
+        gift: false,
+        tradeable: true,
+        discardable: true,
+        autosell: 5,
+        plural: "meats from yesterday",
+    });
+}));

package/dist/entityTypes/outfits.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOutfits = void 0;
+const utils_1 = require("../utils");
+const parseEquipment = (equipmentList = "") => equipmentList.trim().split(", ");
+const parseTreats = (treatList = "") => treatList
+    .trim()
+    .split(", ")
+    .filter((t) => t !== "none")
+    .map((treat) => {
+    const m = treat.match(/^(.*?) \((\d*\.?\d+)\)$/);
+    if (!m)
+        return { item: treat, chance: 1 };
+    return { item: m[1], chance: Number(m[2]) };
+});
+const parseOutfit = (parts) => {
+    var _a, _b;
+    return ({
+        id: Number(parts[0]),
+        name: parts[1],
+        image: parts[2],
+        equipment: parseEquipment((_a = parts[3]) !== null && _a !== void 0 ? _a : ""),
+        treats: parseTreats(parts[0] === "80" ? "double-ice gum" : (_b = parts[4]) !== null && _b !== void 0 ? _b : ""),
+    });
+};
+const loadOutfits = (lastKnownSize) => __awaiter(void 0, void 0, void 0, function* () {
+    const raw = yield (0, utils_1.loadMafiaData)("outfits", lastKnownSize);
+    if (raw === null)
+        return null;
+    return Object.assign(Object.assign({}, raw), { data: raw.data.filter((p) => p.length > 2).map(parseOutfit) });
+});
+exports.loadOutfits = loadOutfits;

package/dist/entityTypes/outfits.test.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const testUtils_1 = require("../testUtils");
+const outfits_1 = require("./outfits");
+global.fetch = vitest_1.vi.fn();
+(0, vitest_1.test)("Can read items", () => __awaiter(void 0, void 0, void 0, function* () {
+    vitest_1.vi.mocked(fetch).mockResolvedValue((0, testUtils_1.createFetchResponse)("1\n35\tBlack Armaments\tblacktat.gif\tblack helmet, black sword, black shield, black greaves\tblack pudding (0.16), Blackfly Chardonnay (0.16), black & tan (0.16), black pepper (0.16), black forest cake (0.16), black forest ham (0.16)"));
+    const outfits = yield (0, outfits_1.loadOutfits)();
+    (0, testUtils_1.expectNotNull)(outfits);
+    (0, vitest_1.expect)(outfits.data.length).toBe(1);
+    const outfit = outfits.data[0];
+    (0, vitest_1.expect)(outfit).toMatchObject({
+        id: 35,
+        name: "Black Armaments",
+        image: "blacktat.gif",
+        equipment: ["black helmet", "black sword", "black shield", "black greaves"],
+        treats: [
+            { item: "black pudding", chance: 0.16 },
+            { item: "Blackfly Chardonnay", chance: 0.16 },
+            { item: "black & tan", chance: 0.16 },
+            { item: "black pepper", chance: 0.16 },
+            { item: "black forest cake", chance: 0.16 },
+            { item: "black forest ham", chance: 0.16 },
+        ],
+    });
+}));

package/dist/entityTypes/skills.js

@@ -0,0 +1,170 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSkills = exports.isPermable = exports.getMaxLevel = exports.SkillType = void 0;
+const utils_1 = require("../utils");
+var SkillType;
+(function (SkillType) {
+    SkillType[SkillType["Passive"] = 0] = "Passive";
+    SkillType[SkillType["NoncombatItemSummon"] = 1] = "NoncombatItemSummon";
+    SkillType[SkillType["NoncombatHealing"] = 2] = "NoncombatHealing";
+    SkillType[SkillType["NoncombatNonShruggableEffect"] = 3] = "NoncombatNonShruggableEffect";
+    SkillType[SkillType["NoncombatShruggableEffect"] = 4] = "NoncombatShruggableEffect";
+    SkillType[SkillType["Combat"] = 5] = "Combat";
+    SkillType[SkillType["OneAtATimeNoncombatSong"] = 6] = "OneAtATimeNoncombatSong";
+    SkillType[SkillType["CombatNoncombatHealing"] = 7] = "CombatNoncombatHealing";
+    SkillType[SkillType["CombatPassive"] = 8] = "CombatPassive";
+    SkillType[SkillType["OneAtATimeNoncombatExpression"] = 9] = "OneAtATimeNoncombatExpression";
+    SkillType[SkillType["OneAtATimeNoncombatWalk"] = 10] = "OneAtATimeNoncombatWalk";
+    SkillType[SkillType["NoncombatHealingPassive"] = 11] = "NoncombatHealingPassive";
+})(SkillType || (exports.SkillType = SkillType = {}));
+const isValidType = (0, utils_1.isMemberOfEnum)(SkillType);
+const getMaxLevel = ({ id }) => {
+    switch (id) {
+        // Will probably be this way forever
+        // Slimy Sinews
+        case 46:
+            return 10;
+        // Slimy Synapes
+        case 47:
+            return 10;
+        // Slimy Shoulders
+        case 48:
+            return 10;
+        // Summon Annoyance
+        case 107:
+            return 9;
+        // Belch The Rainbow
+        case 117:
+            return 11;
+        // Implode Universe
+        case 188:
+            return 13;
+        // Will change in future
+        // Pirate Bellow
+        case 118:
+            return 7;
+        // Summon Holiday Fun
+        case 121:
+            return 6;
+        // Summon Carrot
+        case 128:
+            return 6;
+        // Bear Essence
+        case 134:
+            return 6;
+        // Summon Kokomo Resort Pass
+        case 135:
+            return 2;
+        // Calculate the Universe
+        case 144:
+            return 5;
+        // Experience Safari
+        case 180:
+            return 4;
+        // Toggle Optimality
+        case 7254:
+            return 3;
+        default:
+            return 0;
+    }
+};
+exports.getMaxLevel = getMaxLevel;
+const isPermable = ({ id }) => {
+    // Random old skills
+    if (id < 10)
+        return false;
+    // Bad Moon
+    if (id > 20 && id <= 27)
+        return false;
+    // Way of the Surprising Fist skills
+    if (id > 63 && id <= 73)
+        return false;
+    // Spirit derived skills
+    if (id > 7175 && id < 7181)
+        return false;
+    switch (id) {
+        // VIP lounge skills
+        case 91: // Dog Tired
+        case 116: // Hollow Leg
+            return false;
+        // Nemesis skills
+        case 49: // Gothy Handwave
+        case 50: // Break It On Down
+        case 51: // Pop and Lock
+        case 52: // Run Like the Wind
+        case 3024: // Carboloading
+            return false;
+        case 6019: // Gemlli's March of Testery
+            return false;
+        // Other skills from this class are not permable
+        case 17047: // Mild Curs
+            return true;
+        // Avatar of West of Loathing skills
+        case 156: // Shoot
+            return false;
+        // Not permable but granted every ascension
+        case 174: // Incrdible Self-Estem
+            return false;
+        // S.I.T. Course certificate skills
+        case 218: // Cryptobotanist
+        case 219: // Insectologist
+        case 220: // Psychogeologist
+            return false;
+        // Replica skills
+        case 222: // Replica Emotionally Chipped
+            return false;
+        // Permable from PvP
+        case 7254: // Toggle Optimality
+            return true;
+    }
+    switch (Math.floor(id / 1000)) {
+        case 7: // Skills granted by items
+        case 8: // Mystical Bookshelf Skills
+        case 11: // Avatar of Boris skills
+        case 12: // Zombie Slayer skills
+        case 14: // Avatar of Jarlsberg skills
+        case 15: // Avatar of Sneaky Pete skills
+        case 16: // Heavy Rains skills
+        case 17: // Ed skills
+        case 18: // Cow Puncher skills
+        case 19: // Bean Slinger skills
+        case 20: // Snake Oiler skills
+        case 21: // The Source skills
+        case 22: // Nuclear Autumn skills
+        case 23: // Gelatinous Noob skills
+        case 24: // Vampyre skills
+        case 25: // Plumber skills
+        case 27: // Grey Goo skills
+        case 28: // AoSOL; Pig Skinner skills
+        case 29: // AoSOL; Cheese Wizard skills
+        case 30: // AoSOL; Jazz Agent skills
+            return false;
+    }
+    return true;
+};
+exports.isPermable = isPermable;
+const parseSkill = (parts) => ({
+    id: Number(parts[0]),
+    name: parts[1],
+    image: parts[2],
+    type: isValidType(Number(parts[3])) ? Number(parts[3]) : SkillType.Passive,
+    mpCost: Number(parts[4]),
+    duration: Number(parts[5]),
+    level: parts[6] ? Number(parts[6]) : 0,
+});
+const loadSkills = (lastKnownSize) => __awaiter(void 0, void 0, void 0, function* () {
+    const raw = yield (0, utils_1.loadMafiaData)("classskills", lastKnownSize);
+    if (raw === null)
+        return null;
+    return Object.assign(Object.assign({}, raw), { data: raw.data.filter((p) => p.length > 2).map(parseSkill) });
+});
+exports.loadSkills = loadSkills;

package/dist/entityTypes/skills.test.js

@@ -0,0 +1,31 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const testUtils_1 = require("../testUtils");
+const skills_1 = require("./skills");
+global.fetch = vitest_1.vi.fn();
+(0, vitest_1.test)("Can read items", () => __awaiter(void 0, void 0, void 0, function* () {
+    vitest_1.vi.mocked(fetch).mockResolvedValue((0, testUtils_1.createFetchResponse)("1\n3035\tBind Penne Dreadful\tt_dreadful.gif\t3\t150\t0\t11"));
+    const skills = yield (0, skills_1.loadSkills)();
+    (0, testUtils_1.expectNotNull)(skills);
+    (0, vitest_1.expect)(skills.data.length).toBe(1);
+    const skill = skills.data[0];
+    (0, vitest_1.expect)(skill).toMatchObject({
+        id: 3035,
+        name: "Bind Penne Dreadful",
+        image: "t_dreadful.gif",
+        type: skills_1.SkillType.NoncombatNonShruggableEffect,
+        mpCost: 150,
+        duration: 0,
+        level: 11,
+    });
+}));

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Skill = exports.Outfit = exports.Item = exports.Familiar = exports.Effect = void 0;
+exports.Effect = __importStar(require("./entityTypes/effects"));
+exports.Familiar = __importStar(require("./entityTypes/familiars"));
+exports.Item = __importStar(require("./entityTypes/items"));
+exports.Outfit = __importStar(require("./entityTypes/outfits"));
+exports.Skill = __importStar(require("./entityTypes/skills"));

package/dist/testUtils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectNotNull = exports.createFetchResponse = void 0;
+const vitest_1 = require("vitest");
+function createFetchResponse(data) {
+    return {
+        json: () => new Promise((resolve) => resolve(JSON.parse(data))),
+        text: () => new Promise((resolve) => resolve(data)),
+        headers: new Headers({ "Content-Length": String(data.length) }),
+    };
+}
+exports.createFetchResponse = createFetchResponse;
+function expectNotNull(val) {
+    (0, vitest_1.expect)(val).toBeDefined();
+}
+exports.expectNotNull = expectNotNull;

package/dist/utils.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMemberOfEnum = exports.arrayOf = exports.tuple = exports.loadMafiaData = void 0;
+const MAFIA_DATA_BASE = "https://raw.githubusercontent.com/kolmafia/kolmafia/main/src/data";
+function loadMafiaData(fileName, lastKnownSize = 0) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = `${MAFIA_DATA_BASE}/${fileName}.txt`;
+        if (lastKnownSize > 0) {
+            const sizeCheck = yield fetch(url, { method: "HEAD" });
+            const newSize = Number((_a = sizeCheck.headers.get("Content-Length")) !== null && _a !== void 0 ? _a : 1);
+            if (newSize === lastKnownSize)
+                return null;
+        }
+        const request = yield fetch(url);
+        const raw = yield request.text();
+        return {
+            data: raw
+                .split("\n")
+                .slice(1)
+                .filter((r) => r !== "" && !r.startsWith("#"))
+                .map((r) => r.split("\t")),
+            size: Number(request.headers.get("Content-Length")),
+        };
+    });
+}
+exports.loadMafiaData = loadMafiaData;
+const tuple = (args) => args;
+exports.tuple = tuple;
+const arrayOf = (items) => Array.isArray(items) ? items : [items];
+exports.arrayOf = arrayOf;
+const isMemberOfEnum = (e) => (token) => Object.values(e).includes(token);
+exports.isMemberOfEnum = isMemberOfEnum;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "data-of-loathing",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "author": "Sam Gaus <sam@gaus.co.uk>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.8.7",
+    "@typescript-eslint/eslint-plugin": "^6.8.0",
+    "@typescript-eslint/parser": "^6.8.0",
+    "eslint": "^8.52.0",
+    "eslint-config-prettier": "^9.0.0",
+    "prettier": "^3.0.3",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.6"
+  },
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write .",
+    "prepack": "yarn run build",
+    "test": "vitest"
+  },
+  "packageManager": "yarn@4.0.0"
+}