libram 0.6.8 → 0.6.11

package/dist/ascend.d.ts

@@ -1,4 +1,4 @@
-import { Class, Item } from "kolmafia";
+import { Skill, Class, Item } from "kolmafia";
 import { Path } from "./Path";
 import { Ceiling, Desk, Nightstand } from "./resources/2015/ChateauMantegna";
 export declare enum Lifestyle {
@@ -7,6 +7,10 @@ export declare enum Lifestyle {
     normal = 2,
     hardcore = 3
 }
+export declare class AscendError extends Error {
+    cause?: Skill | Item | Class | Path;
+    constructor(cause?: Skill | Item | Class | Path);
+}
 declare type MoonSign = number | "mongoose" | "wallaby" | "vole" | "platypus" | "opossum" | "marmot" | "wombat" | "blender" | "packrat" | "degrassi" | "degrassi knoll" | "friendly degrassi knoll" | "knoll" | "canada" | "canadia" | "little canadia" | "gnomads" | "gnomish" | "gnomish gnomads camp";
 /**
  * Hops the gash, perming no skills
@@ -17,7 +21,7 @@ declare type MoonSign = number | "mongoose" | "wallaby" | "vole" | "platypus" |
  * @param consumable From the astral deli. Pick the container item, not the product.
  * @param pet From the astral pet store.
  */
-export declare function ascend(path: Path, playerClass: Class, lifestyle: Lifestyle, moon: MoonSign, consumable?: Item | undefined, pet?: Item | undefined): void;
+export declare function ascend(path: Path, playerClass: Class, lifestyle: Lifestyle, moon: MoonSign, consumable?: Item | undefined, pet?: Item | undefined, permSkills?: Map<Skill, Lifestyle> | undefined): void;
 declare const worksheds: readonly ["warbear LP-ROM burner", "warbear jackhammer drill press", "warbear induction oven", "warbear high-efficiency still", "warbear chemistry lab", "warbear auto-anvil", "spinning wheel", "snow machine", "Little Geneticist DNA-Splicing Lab", "portable Mayo Clinic", "Asdon Martin keyfob", "diabolic pizza cube", "cold medicine cabinet"];
 declare type Workshed = typeof worksheds[number];
 declare const gardens: readonly ["packet of pumpkin seeds", "Peppermint Pip Packet", "packet of dragon's teeth", "packet of beer seeds", "packet of winter seeds", "packet of thanksgarden seeds", "packet of tall grass seeds", "packet of mushroom spores"];

package/dist/ascend.js

@@ -1,4 +1,4 @@
-import { containsText, eudoraItem, getCampground, getWorkshed, Item, toInt, use, visitUrl, xpath, } from "kolmafia";
+import { Skill, Class, containsText, eudoraItem, getCampground, getWorkshed, Item, toInt, use, visitUrl, xpath, haveSkill, } from "kolmafia";
 import { ChateauMantegna } from "./resources";
 import { $item, $items, $stat } from "./template-string";
 export var Lifestyle;
@@ -8,6 +8,32 @@ export var Lifestyle;
     Lifestyle[Lifestyle["normal"] = 2] = "normal";
     Lifestyle[Lifestyle["hardcore"] = 3] = "hardcore";
 })(Lifestyle || (Lifestyle = {}));
+export class AscendError extends Error {
+    cause;
+    constructor(cause) {
+        if (!cause) {
+            super("Failed to ascend--do you have a pending trade offer?");
+        }
+        else if (cause instanceof Skill) {
+            const reason = cause.permable
+                ? haveSkill(cause)
+                    ? "invalid for mysterious reasons"
+                    : "not a skill you currently know"
+                : "unpermable";
+            super(`Skill ${cause} is ${reason}!`);
+        }
+        else if (cause instanceof Item) {
+            super(`Invalid astral item: ${cause}!`);
+        }
+        else if (cause instanceof Class) {
+            super(`Invalid class ${cause} for this path!`);
+        }
+        else {
+            super(`Invalid path ${cause}!`);
+        }
+        this.cause = cause;
+    }
+}
 function toMoonId(moon, playerClass) {
     if (typeof moon === "number")
         return moon;
@@ -68,28 +94,34 @@ function toMoonId(moon, playerClass) {
  * @param consumable From the astral deli. Pick the container item, not the product.
  * @param pet From the astral pet store.
  */
-export function ascend(path, playerClass, lifestyle, moon, consumable = $item `astral six-pack`, pet = undefined) {
-    if (!containsText(visitUrl("charpane.php"), "Astral Spirit")) {
-        visitUrl("ascend.php?action=ascend&confirm=on&confirm2=on");
-    }
-    if (!containsText(visitUrl("charpane.php"), "Astral Spirit")) {
-        throw new Error("Failed to ascend.");
-    }
+export function ascend(path, playerClass, lifestyle, moon, consumable = $item `astral six-pack`, pet = undefined, permSkills = undefined) {
     if (!path.classes.includes(playerClass)) {
-        throw new Error(`Invalid class ${playerClass} for this path`);
+        throw new AscendError(playerClass);
     }
     if (path.id < 0)
-        throw new Error(`Invalid path ID ${path.id}`);
+        throw new AscendError(path);
     const moonId = toMoonId(moon, playerClass);
     if (moonId < 1 || moonId > 9)
         throw new Error(`Invalid moon ${moon}`);
     if (consumable &&
         !$items `astral six-pack, astral hot dog dinner, [10882]carton of astral energy drinks`.includes(consumable)) {
-        throw new Error(`Invalid consumable ${consumable}`);
+        throw new AscendError(consumable);
     }
     if (pet &&
         !$items `astral bludgeon, astral shield, astral chapeau, astral bracer, astral longbow, astral shorts, astral mace, astral ring, astral statuette, astral pistol, astral mask, astral pet sweater, astral shirt, astral belt`.includes(pet)) {
-        throw new Error(`Invalid astral item ${pet}`);
+        throw new AscendError(pet);
+    }
+    const illegalSkill = permSkills
+        ? Array.from(permSkills.keys()).find((skill) => !skill.permable || !haveSkill(skill))
+        : undefined;
+    if (illegalSkill) {
+        throw new AscendError(illegalSkill);
+    }
+    if (!containsText(visitUrl("charpane.php"), "Astral Spirit")) {
+        visitUrl("ascend.php?action=ascend&confirm=on&confirm2=on");
+    }
+    if (!containsText(visitUrl("charpane.php"), "Astral Spirit")) {
+        throw new AscendError();
     }
     visitUrl("afterlife.php?action=pearlygates");
     if (consumable) {
@@ -97,6 +129,14 @@ export function ascend(path, playerClass, lifestyle, moon, consumable = $item `a
     }
     if (pet)
         visitUrl(`afterlife.php?action=buyarmory&whichitem=${toInt(pet)}`);
+    if (permSkills) {
+        for (const [skill, permLevel] of permSkills.entries()) {
+            if (permLevel !== Lifestyle.casual) {
+                const permText = permLevel === Lifestyle.hardcore ? "hcperm" : "scperm";
+                visitUrl(`afterlife.php?action=${permText}&whichskill=${toInt(skill)}`);
+            }
+        }
+    }
     visitUrl(`afterlife.php?action=ascend&confirmascend=1&whichsign=${moonId}&gender=2&whichclass=${toInt(playerClass)}&whichpath=${path.id}&asctype=${lifestyle}&nopetok=1&noskillsok=1&lamepathok=1&lamesignok=1&pwd`, true);
 }
 const worksheds = [

package/dist/challengePaths/2015/CommunityService.d.ts

@@ -1,12 +1,14 @@
 import { Requirement } from "../../maximize";
 export default class CommunityService {
     private choice;
+    private stat;
     private property;
     private predictor;
     private maximizeRequirements;
     /**
      * Class to store properties of various CS tests.
      * @param id The id the game HTML uses to identify the test; this is used primarily in runChoice.
+     * @param stat The principle stat the test measures, often used as more easily memorable shorthand for the specific tests
      * @param property The name of the test as a string, often used as part of the string property "csServicesPerformed".
      * @param predictor A function that returns an estimate for the number of turns that the test will take given your character's current state.
      * @param maximizeRequirements A Requirement object, if applicable, that aligns with the things needed to maximize for this particular test.
@@ -16,6 +18,10 @@ export default class CommunityService {
      * @returns The id number of the test, used primarily in runChoice.
      */
     get id(): number;
+    /**
+     * @returns The primary stat the test measures, used primarily as memorable shorthand in place of test names.
+     */
+    get statName(): string;
     /**
      * @returns The name of the test, used primarily as part of the string property "csServicesPerformed"
      */
@@ -28,6 +34,7 @@ export default class CommunityService {
      * @returns A Requirement object, if applicable, that aligns with the things needed to maximize for this particular test.
      */
     get requirement(): Requirement | null;
+    static logTask(name: string, action: () => number | void): void;
     /**
      * Checks the "csServicesPerformed" property to see whether mafia currently believes this test is complete.
      * @returns Whether mafia currently believes this test is complete.
@@ -45,16 +52,22 @@ export default class CommunityService {
     /**
      * Wrapper function that prepares for a test and then completes it, adding time and turn details to the log.
      * @param prepare A function that does all necessary preparations for this CS test, including choosing your outfit. Optionally returns the number of turns you expect to spend preparing for the test.
-     * @param beCertain Whether we should check council.php instead of mafia to determine whether the test is complete.
-     * @param maxTurns We will run the test iff the predicted turns is less than or equal to this parameter.
+     * @param maxTurns We will run the test iff the predicted/actual turns is less than or equal to this parameter.
      * @returns "completed", "failed", or "already completed".
      */
-    run(prepare: () => void | number, beCertain?: boolean, maxTurns?: number): "completed" | "failed" | "already completed";
+    run(prepare: () => void | number, maxTurns?: number): "completed" | "failed" | "already completed";
+    private _verifyIsDone;
     /**
      * Checks council.php to verify that a test is complete; more reliable than isDone, but requires an additional pagehit.
      * @returns Whether council.php suggests that the test is complete.
      */
     verifyIsDone(): boolean;
+    private _actualCost;
+    /**
+     * Checks council.php for the number of turns this test will take; more reliable than prediction, but requires an additional pagehit.
+     * @returns The number of turns to complete this test according to council.php.
+     */
+    actualCost(): number;
     /**
      * A log of the predicted turns, actual turns, and duration of each CS test performed.
      */
@@ -63,6 +76,7 @@ export default class CommunityService {
             predictedTurns: number;
             turnCost: number;
             seconds: number;
+            type: "test" | "task";
         };
     };
     /**

package/dist/challengePaths/2015/CommunityService.js

@@ -1,4 +1,4 @@
-import { equippedItem, familiarWeight, getPower, haveEquipped, myBasestat, myBuffedstat, myFamiliar, myMaxhp, myThrall, myTurncount, numericModifier, print, runChoice, toSlot, visitUrl, weightAdjustment, } from "kolmafia";
+import { equippedItem, familiarWeight, getPower, haveEquipped, myAdventures, myBasestat, myBuffedstat, myFamiliar, myMaxhp, myThrall, myTurncount, numericModifier, print, runChoice, toSlot, visitUrl, weightAdjustment, } from "kolmafia";
 import { have } from "../../lib";
 import { Requirement } from "../../maximize";
 import { get as getModifier } from "../../modifier";
@@ -16,20 +16,24 @@ const statCommunityServicePredictor = (stat) => {
             (myBuffedstat(stat) -
                 myBasestat(thralls.get(stat) === myThrall() ? $stat `mysticality` : stat)));
 };
+const visitCouncil = () => visitUrl("council.php");
 export default class CommunityService {
     choice;
+    stat;
     property;
     predictor;
     maximizeRequirements;
     /**
      * Class to store properties of various CS tests.
      * @param id The id the game HTML uses to identify the test; this is used primarily in runChoice.
+     * @param stat The principle stat the test measures, often used as more easily memorable shorthand for the specific tests
      * @param property The name of the test as a string, often used as part of the string property "csServicesPerformed".
      * @param predictor A function that returns an estimate for the number of turns that the test will take given your character's current state.
      * @param maximizeRequirements A Requirement object, if applicable, that aligns with the things needed to maximize for this particular test.
      */
-    constructor(id, property, predictor, maximizeRequirements) {
+    constructor(id, stat, property, predictor, maximizeRequirements) {
         this.choice = id;
+        this.stat = stat;
         this.property = property;
         this.predictor = predictor;
         this.maximizeRequirements = maximizeRequirements;
@@ -40,6 +44,12 @@ export default class CommunityService {
     get id() {
         return this.choice;
     }
+    /**
+     * @returns The primary stat the test measures, used primarily as memorable shorthand in place of test names.
+     */
+    get statName() {
+        return this.stat;
+    }
     /**
      * @returns The name of the test, used primarily as part of the string property "csServicesPerformed"
      */
@@ -58,6 +68,17 @@ export default class CommunityService {
     get requirement() {
         return this.maximizeRequirements;
     }
+    static logTask(name, action) {
+        const startTime = Date.now();
+        const startTurns = myTurncount();
+        const estimatedTurns = action() ?? 0;
+        CommunityService.log[name] = {
+            type: "task",
+            turnCost: myTurncount() - startTurns,
+            predictedTurns: estimatedTurns,
+            seconds: (Date.now() - startTime) / 1000,
+        };
+    }
     /**
      * Checks the "csServicesPerformed" property to see whether mafia currently believes this test is complete.
      * @returns Whether mafia currently believes this test is complete.
@@ -78,21 +99,19 @@ export default class CommunityService {
      */
     do() {
         if (get("csServicesPerformed").trim().length === 0)
-            visitUrl("council.php");
-        visitUrl("council.php");
-        runChoice(this.choice);
-        return this.isDone();
+            visitCouncil();
+        visitCouncil();
+        const councilText = runChoice(this.choice);
+        return this._verifyIsDone(councilText);
     }
     /**
      * Wrapper function that prepares for a test and then completes it, adding time and turn details to the log.
      * @param prepare A function that does all necessary preparations for this CS test, including choosing your outfit. Optionally returns the number of turns you expect to spend preparing for the test.
-     * @param beCertain Whether we should check council.php instead of mafia to determine whether the test is complete.
-     * @param maxTurns We will run the test iff the predicted turns is less than or equal to this parameter.
+     * @param maxTurns We will run the test iff the predicted/actual turns is less than or equal to this parameter.
      * @returns "completed", "failed", or "already completed".
      */
-    run(prepare, beCertain = false, maxTurns = Infinity) {
-        const finishedFunction = () => beCertain ? this.verifyIsDone() : this.isDone();
-        if (finishedFunction())
+    run(prepare, maxTurns = Infinity) {
+        if (this.isDone())
             return "already completed";
         const startTime = Date.now();
         const startTurns = myTurncount();
@@ -104,25 +123,43 @@ export default class CommunityService {
             return "failed";
         }
         const prediction = this.predictor();
-        if (prediction <= maxTurns) {
-            this.do();
-        }
-        if (finishedFunction()) {
-            CommunityService.log[this.property] = {
-                predictedTurns: prediction + additionalTurns,
-                turnCost: myTurncount() - startTurns,
-                seconds: (Date.now() - startTime) / 1000,
-            };
-            return "completed";
+        const council = visitCouncil();
+        const turns = this._actualCost(council);
+        if (!turns)
+            return "already completed";
+        if (turns > Math.min(maxTurns, myAdventures())) {
+            return "failed";
         }
-        return "failed";
+        if (!this.do())
+            return "failed";
+        CommunityService.log[this.property] = {
+            predictedTurns: prediction + additionalTurns,
+            turnCost: myTurncount() - startTurns,
+            seconds: (Date.now() - startTime) / 1000,
+            type: "test",
+        };
+        return "completed";
+    }
+    _verifyIsDone(councilText) {
+        return !councilText.includes(`<input type=hidden name=option value=${this.choice}>`);
     }
     /**
      * Checks council.php to verify that a test is complete; more reliable than isDone, but requires an additional pagehit.
      * @returns Whether council.php suggests that the test is complete.
      */
     verifyIsDone() {
-        return !visitUrl("council.php").includes(`<input type=hidden name=option value=${this.choice}>`);
+        return this._verifyIsDone(visitCouncil());
+    }
+    _actualCost(councilText) {
+        const match = councilText.match(`<input type=hidden name=option value=${this.id}>.*?Perform Service \\((\\d+) Adventures\\)`);
+        return match ? parseInt(match[1]) : 0;
+    }
+    /**
+     * Checks council.php for the number of turns this test will take; more reliable than prediction, but requires an additional pagehit.
+     * @returns The number of turns to complete this test according to council.php.
+     */
+    actualCost() {
+        return this._actualCost(visitCouncil());
     }
     /**
      * A log of the predicted turns, actual turns, and duration of each CS test performed.
@@ -135,19 +172,28 @@ export default class CommunityService {
     static printLog(colour = "blue") {
         const logEntries = Object.entries(CommunityService.log);
         for (const [testName, testEntry] of logEntries) {
-            const { predictedTurns, turnCost, seconds } = testEntry;
-            print(`We predicted the ${testName} test would take ${predictedTurns} turns, ${predictedTurns === turnCost ? "and" : "but"} it took ${turnCost} turns`, colour);
-            print(`${testName} took ${seconds} seconds`, colour);
+            const { type, predictedTurns, turnCost, seconds } = testEntry;
+            if (type === "test") {
+                print(`We predicted the ${testName} test would take ${predictedTurns} turns, ${predictedTurns === turnCost ? "and" : "but"} it took ${turnCost} turns.`, colour);
+                print(`${testName} took ${seconds.toFixed(1)} seconds.`, colour);
+            }
+            else {
+                if (!(predictedTurns === 0 && turnCost === 0)) {
+                    print(`We predicted the task ${testName} would take ${predictedTurns} turns, ${predictedTurns === turnCost ? "and" : "but"} it took ${turnCost} turns.`, colour);
+                }
+                print(`The task ${testName} took ${seconds.toFixed(1)} seconds.`, colour);
+            }
         }
-        print(`All together, you have spent ${sum(logEntries, ([, testEntry]) => testEntry.seconds)} seconds during this Community Service run`, colour);
+        const totalTime = sum(logEntries, ([, testEntry]) => testEntry.seconds);
+        print(`All together, you have spent ${totalTime.toFixed(1)} seconds during this Community Service run`, colour);
     }
     // Below, we have the tests themselves.
-    static HP = new CommunityService(1, "Donate Blood", () => 60 - Math.floor((myMaxhp() - myBuffedstat($stat `muscle`) - 3) / 30), new Requirement(["HP"], {}));
-    static Muscle = new CommunityService(2, "Feed The Children", statCommunityServicePredictor($stat `Muscle`), new Requirement(["Muscle"], {}));
-    static Mysticality = new CommunityService(3, "Build Playground Mazes", statCommunityServicePredictor($stat `Mysticality`), new Requirement(["Mysticality"], {}));
-    static Moxie = new CommunityService(4, "Feed Conspirators", statCommunityServicePredictor($stat `Moxie`), new Requirement(["Moxie"], {}));
-    static FamiliarWeight = new CommunityService(5, "Breed More Collies", () => 60 - Math.floor((familiarWeight(myFamiliar()) + weightAdjustment()) / 5), new Requirement(["Familiar Weight"], {}));
-    static WeaponDamage = new CommunityService(6, "Reduce Gazelle Population", () => {
+    static HP = new CommunityService(1, "HP", "Donate Blood", () => 60 - Math.floor((myMaxhp() - myBuffedstat($stat `muscle`) - 3) / 30), new Requirement(["HP"], {}));
+    static Muscle = new CommunityService(2, "Muscle", "Feed The Children", statCommunityServicePredictor($stat `Muscle`), new Requirement(["Muscle"], {}));
+    static Mysticality = new CommunityService(3, "Mysticality", "Build Playground Mazes", statCommunityServicePredictor($stat `Mysticality`), new Requirement(["Mysticality"], {}));
+    static Moxie = new CommunityService(4, "Moxie", "Feed Conspirators", statCommunityServicePredictor($stat `Moxie`), new Requirement(["Moxie"], {}));
+    static FamiliarWeight = new CommunityService(5, "Familiar Weight", "Breed More Collies", () => 60 - Math.floor((familiarWeight(myFamiliar()) + weightAdjustment()) / 5), new Requirement(["Familiar Weight"], {}));
+    static WeaponDamage = new CommunityService(6, "Weapon Damage", "Reduce Gazelle Population", () => {
         const weaponPower = getPower(equippedItem($slot `weapon`));
         const offhandPower = toSlot(equippedItem($slot `off-hand`)) === $slot `weapon`
             ? getPower(equippedItem($slot `off-hand`))
@@ -166,7 +212,7 @@ export default class CommunityService {
                 0.001) -
             Math.floor((multiplier * getModifier("Weapon Damage Percent")) / 50 + 0.001));
     }, new Requirement(["Weapon Damage", "Weapon Damage Percent"], {}));
-    static SpellDamage = new CommunityService(7, "Make Sausage", () => {
+    static SpellDamage = new CommunityService(7, "Spell Damage", "Make Sausage", () => {
         const dragonfishDamage = myFamiliar() === $familiar `Magic Dragonfish`
             ? numericModifier($familiar `Magic Dragonfish`, "Spell Damage Percent", familiarWeight($familiar `Magic Dragonfish`) + weightAdjustment(), $item `none`)
             : 0;
@@ -175,12 +221,12 @@ export default class CommunityService {
             Math.floor(getModifier("Spell Damage") / 50 + 0.001) -
             Math.floor((getModifier("Spell Damage Percent") - dragonfishDamage) / 50 + 0.001));
     }, new Requirement(["Spell Damage", "Spell Damage Percent"], {}));
-    static Noncombat = new CommunityService(8, "Be a Living Statue", () => {
+    static Noncombat = new CommunityService(8, "Non-Combat", "Be a Living Statue", () => {
         const noncombatRate = -1 * getModifier("Combat Rate");
         const unsoftcappedRate = noncombatRate > 25 ? 25 + (noncombatRate - 25) * 5 : noncombatRate;
         return 60 - 3 * Math.floor(unsoftcappedRate / 5);
     }, new Requirement(["-combat"], {}));
-    static BoozeDrop = new CommunityService(9, "Make Margaritas", () => {
+    static BoozeDrop = new CommunityService(9, "Item Drop", "Make Margaritas", () => {
         const mummingCostume = MummingTrunk.currentCostumes().get(myFamiliar());
         const mummingBuff = mummingCostume && mummingCostume[0] === "Item Drop"
             ? mummingCostume[1]
@@ -202,10 +248,10 @@ export default class CommunityService {
     }, new Requirement(["Item Drop", "2 Booze Drop"], {
         preventEquip: $items `broken champagne bottle`,
     }));
-    static HotRes = new CommunityService(10, "Clean Steam Tunnels", () => 60 - getModifier("Hot Resistance"), new Requirement(["Hot Resistance"], {}));
-    static CoilWire = new CommunityService(11, "Coil Wire", () => 60, new Requirement([], {}));
+    static HotRes = new CommunityService(10, "Hot Resistance", "Clean Steam Tunnels", () => 60 - getModifier("Hot Resistance"), new Requirement(["Hot Resistance"], {}));
+    static CoilWire = new CommunityService(11, "Coil Wire", "Coil Wire", () => 60, new Requirement([], {}));
     static donate = () => {
-        visitUrl("council.php");
+        visitCouncil();
         visitUrl("choice.php?whichchoice=1089&option=30");
     };
 }

package/dist/combat.d.ts

@@ -103,7 +103,7 @@ export declare class Macro {
      * @param ifTrue Continuation if the condition is true.
      * @returns {Macro} This object itself.
      */
-    if_(condition: string | Monster | Effect | Skill | Item | Location | Class | Stat, ifTrue: string | Macro): this;
+    if_(condition: string | Monster | Monster[] | Effect | Skill | Item | Location | Class | Stat, ifTrue: string | Macro): this;
     /**
      * Create a new macro with an "if" statement.
      * @param condition The BALLS condition for the if statement.

package/dist/combat.js

@@ -211,6 +211,12 @@ export class Macro {
         if (condition instanceof Monster) {
             ballsCondition = `monsterid ${condition.id}`;
         }
+        else if (condition instanceof Array) {
+            ballsCondition = condition
+                .map((mon) => `monsterid ${mon.id}`)
+                .join(" || ");
+            ballsCondition = `(${ballsCondition})`;
+        }
         else if (condition instanceof Effect) {
             ballsCondition = `haseffect ${toInt(condition)}`;
         }

package/dist/counter.d.ts

@@ -1,9 +1,15 @@
 /**
- * Returns null for counters that do not exist, and otherwise returns the duration of the counter
+ * Returns Infinity for counters that do not exist, and otherwise returns the duration of the counter
  * @param counter The name of the counter in question
- * @returns null if the counter does not exist; otherwise returns the duration of the counter
+ * @returns Infinity if the counter does not exist; otherwise returns the duration of the counter
  */
-export declare function get(counter: string): number | null;
+export declare function get(counter: string): number;
+/**
+ * The world is everything that is the case. This determines which counters are the case.
+ * @param counter The name of the counter in question
+ * @returns True for counters which currently exist; false for those which do not
+ */
+export declare function exists(counter: string): boolean;
 /**
  * Creates a manual counter with specified name and duration
  * @param counter Name of the counter to manually create

package/dist/counter.js

@@ -1,19 +1,27 @@
 import { cliExecute, getCounter, getCounters } from "kolmafia";
 /**
- * Returns null for counters that do not exist, and otherwise returns the duration of the counter
+ * Returns Infinity for counters that do not exist, and otherwise returns the duration of the counter
  * @param counter The name of the counter in question
- * @returns null if the counter does not exist; otherwise returns the duration of the counter
+ * @returns Infinity if the counter does not exist; otherwise returns the duration of the counter
  */
 export function get(counter) {
     const value = getCounter(counter);
-    //getCounter returns -1 for counters that don't exist, but it also returns -1 for counters whose value is -1
+    // getCounter returns -1 for counters that don't exist, but it also returns -1 for counters whose value is -1
     if (value === -1) {
-        //if we have a counter with value -1, we check to see if that counter exists via getCounters()
-        //We return null if it doesn't exist
-        return getCounters(counter, -1, -1).trim() === "" ? null : -1;
+        // if we have a counter with value -1, we check to see if that counter exists via getCounters()
+        // We return null if it doesn't exist
+        return getCounters(counter, -1, -1).trim() === "" ? Infinity : -1;
     }
     return value;
 }
+/**
+ * The world is everything that is the case. This determines which counters are the case.
+ * @param counter The name of the counter in question
+ * @returns True for counters which currently exist; false for those which do not
+ */
+export function exists(counter) {
+    return (getCounter(counter) !== -1 || getCounters(counter, -1, -1).trim() !== "");
+}
 /**
  * Creates a manual counter with specified name and duration
  * @param counter Name of the counter to manually create

package/dist/diet/index.d.ts

@@ -10,6 +10,7 @@ declare type MenuItemOptions<T> = {
     priceOverride?: number;
     mayo?: Item;
     data?: T;
+    useRetrievePrice?: boolean;
 };
 export declare class MenuItem<T> {
     item: Item;
@@ -21,6 +22,7 @@ export declare class MenuItem<T> {
     priceOverride?: number;
     mayo?: Item;
     data?: T;
+    static defaultPriceFunction: (item: Item) => number;
     static defaultOptions<T>(): Map<Item, MenuItemOptions<T>>;
     /**
      * Construct a new menu item, possibly with extra properties. Items in MenuItem.defaultOptions have intelligent defaults.

package/dist/diet/index.js

@@ -60,6 +60,7 @@ export class MenuItem {
     priceOverride;
     mayo;
     data;
+    static defaultPriceFunction = (item) => npcPrice(item) > 0 ? npcPrice(item) : mallPrice(item);
     static defaultOptions() {
         return new Map([
             [
@@ -159,8 +160,7 @@ export class MenuItem {
         return this.item.toString();
     }
     price() {
-        return (this.priceOverride ??
-            (npcPrice(this.item) > 0 ? npcPrice(this.item) : mallPrice(this.item)));
+        return this.priceOverride ?? MenuItem.defaultPriceFunction?.(this.item);
     }
 }
 const organs = ["food", "booze", "spleen item"];

package/dist/lib.js

@@ -3,7 +3,7 @@ import "core-js/modules/es.object.entries";
 import "core-js/features/array/flat";
 import { appearanceRates, autosellPrice, availableAmount, booleanModifier, cliExecute, Effect, Familiar, fullnessLimit, getCampground, getCounters, getPlayerId, getPlayerName, getRelated, haveEffect, haveFamiliar, haveServant, haveSkill, holiday, inebrietyLimit, Item, Location, mallPrice, Monster, myEffects, myFamiliar, myFullness, myInebriety, myPath, mySpleenUse, myThrall, myTurncount, numericModifier, Servant, Skill, spleenLimit, Thrall, toItem, toSkill, totalTurnsPlayed, } from "kolmafia";
 import { get } from "./property";
-import { $class, $familiar, $item, $items, $monsters } from "./template-string";
+import { $class, $familiar, $item, $items, $monsters, $skill, } from "./template-string";
 import { chunk } from "./utils";
 /**
  * Returns the current maximum Accordion Thief songs the player can have in their head
@@ -323,10 +323,25 @@ export function getBanishedMonsters() {
             break;
         // toItem doesn"t error if the item doesn"t exist, so we have to use that.
         const banisherItem = toItem(banisher);
-        const banisherObject = [Item.get("none"), null].includes(banisherItem)
-            ? Skill.get(banisher)
-            : banisherItem;
-        result.set(banisherObject, Monster.get(foe));
+        if (banisher.toLowerCase() === "saber force") {
+            result.set($skill `Use the Force`, Monster.get(foe));
+        }
+        else if ([
+            Item.get("none"),
+            Item.get(`training scroll:  Snokebomb`),
+            Item.get(`tomayohawk-style reflex hammer`),
+            null,
+        ].includes(banisherItem)) {
+            if (Skill.get(banisher) === $skill `none`) {
+                break;
+            }
+            else {
+                result.set(Skill.get(banisher), Monster.get(foe));
+            }
+        }
+        else {
+            result.set(banisherItem, Monster.get(foe));
+        }
     }
     return result;
 }