libram 0.7.11 → 0.7.14

package/dist/resources/2022/CombatLoversLocket.js

@@ -3,13 +3,16 @@ import { have as haveItem } from "../../lib";
 import { get } from "../../property";
 import { $item } from "../../template-string";
 import { clamp } from "../../utils";
-// eslint-disable-next-line libram/verify-constants
-export const locket = $item `Combat Lover's Locket`;
+export const locket = $item `combat lover's locket`;
+/**
+ * @returns Whether you `have` the Combat Lover's Locket
+ */
 export function have() {
     return haveItem(locket);
 }
 /**
  * Filters the set of all unlocked locket monsters to only the ones available to be locketed right now.
+ *
  * @returns An array consisting of all Monsters you can fight with your locket right now.
  */
 export function availableLocketMonsters() {
@@ -21,6 +24,7 @@ export function availableLocketMonsters() {
 }
 /**
  * Parses getLocketMonsters and returns the collection of all Monsters as an Array.
+ *
  * @returns An array consisting of all Monsters you can hypothetically fight, regardless of whether they've been fought today.
  */
 export function unlockedLocketMonsters() {
@@ -33,6 +37,7 @@ function parseLocketProperty() {
 }
 /**
  * Determines how many reminisces remain by parsing the _locketMonstersFought property.
+ *
  * @returns The number of reminisces a player has available; 0 if they lack the Locket.
  */
 export function reminiscesLeft() {
@@ -40,6 +45,7 @@ export function reminiscesLeft() {
 }
 /**
  * Determines which monsters were reminisced today by parsing the _locketMonstersFought property.
+ *
  * @returns An array consisting of the Monsters reminisced today.
  */
 export function monstersReminisced() {
@@ -47,6 +53,7 @@ export function monstersReminisced() {
 }
 /**
  * Fight a Monster using the Combat Lover's Locket
+ *
  * @param monster The Monster to fight
  * @returns false if we are unable to reminisce about this monster. Else, returns whether, at the end of all things, we have reminisced about this monster.
  */
@@ -60,6 +67,7 @@ export function reminisce(monster) {
 }
 /**
  * This function efficiently evaluates all of an adventurer's possibly reminiscable monsters, placing them through a filtering criteria and evaluating them based on a passed function.
+ *
  * @param criteria A filtering function for delineating which monsters are "fair game" for the search, such as "is this monster free".
  * @param value A function for deciding which monsters are "better" than others.
  * @returns A singular monster that fulfills the criteria function and maximizes the value function.

package/dist/resources/2022/GreyGoose.d.ts

@@ -1,14 +1,60 @@
 export declare const goose: import("kolmafia").Familiar;
+/**
+ * Determines whether you `have` the Grey Goose
+ *
+ * @returns Whether you `have` the Grey Goose
+ */
 export declare function have(): boolean;
+/**
+ * Determines your expected Grey Goose experience, were you to make it your active familiar
+ *
+ * @returns Your current expected Grey Goose experience, paying attention to potential experience from the Shorter-Order Cook
+ */
 export declare function currentExperience(): number;
+/**
+ * Determines the current expected weight of your goose, were you to make it your active familiar
+ *
+ * @returns Your current expected Grey Goose weight, paying attention to potential experience from the Shorter-Order Cook
+ */
 export declare function currentWeight(): number;
+/**
+ * Determines the number of drones emitted for a given weight
+ *
+ * @param weight The weight to test; defaults to current weight
+ * @returns The nubmer of drones expected to be emitted for the weight in question
+ */
 export declare function expectedDrones(weight?: number): number;
 /**
+ * Determines the experience (or, in Grey You, fullstats) you'd get from using the appropriate Grey Goose skill for a given weight
+ *
  * @param weight The goose weight you care about; defaults to current weight
  * @returns In Grey You, returns the fullstats you'll gain from goose levelling; outside Grey You, returns substats
  */
 export declare function expectedExperience(weight?: number): number;
+/**
+ * Determines the meat you'd expect to get from using Meatify Matter at the given weight
+ *
+ * @param weight The weight in question (defaults to current)
+ * @returns The expected meat from Meatify Matter
+ */
 export declare function expectedMeat(weight?: number): number;
+/**
+ * Determines whether you've used Meatify Matter today
+ *
+ * @returns Whether you've used Meatify Matter today
+ */
 export declare function hasMeatified(): boolean;
+/**
+ * Calculates the number of fights you need to reach a particular weight
+ *
+ * @param target The weight you want to reach
+ * @param bonusExperience The amount of bonus exdperience you'll be running--defaults to the current value
+ * @returns Number of fights needed
+ */
 export declare function fightsUntil(target: number, bonusExperience?: number): number;
+/**
+ * Determines how many matter-duplicating drones are currently hovering around you
+ *
+ * @returns The number of matter-duplicating drones currently hovering around you
+ */
 export declare function currentDrones(): number;

package/dist/resources/2022/GreyGoose.js

@@ -4,41 +4,87 @@ import { get as getModifier } from "../../modifier";
 import { get } from "../../property";
 import { $familiar, $item, $skill } from "../../template-string";
 export const goose = $familiar `Grey Goose`;
+/**
+ * Determines whether you `have` the Grey Goose
+ *
+ * @returns Whether you `have` the Grey Goose
+ */
 export function have() {
     return have_(goose);
 }
+/**
+ * Determines your expected Grey Goose experience, were you to make it your active familiar
+ *
+ * @returns Your current expected Grey Goose experience, paying attention to potential experience from the Shorter-Order Cook
+ */
 export function currentExperience() {
     return goose.experience ||
         (have_($familiar `Shorter-Order Cook`) && !get("gooseReprocessed"))
         ? 81 + (have_($item `blue plate`) ? 19 : 0)
         : 0;
 }
+/**
+ * Determines the current expected weight of your goose, were you to make it your active familiar
+ *
+ * @returns Your current expected Grey Goose weight, paying attention to potential experience from the Shorter-Order Cook
+ */
 export function currentWeight() {
     return Math.min(Math.floor(Math.sqrt(currentExperience())), 20);
 }
+/**
+ * Determines the number of drones emitted for a given weight
+ *
+ * @param weight The weight to test; defaults to current weight
+ * @returns The nubmer of drones expected to be emitted for the weight in question
+ */
 export function expectedDrones(weight = currentWeight()) {
     return Math.max(0, weight - 5);
 }
 /**
+ * Determines the experience (or, in Grey You, fullstats) you'd get from using the appropriate Grey Goose skill for a given weight
+ *
  * @param weight The goose weight you care about; defaults to current weight
  * @returns In Grey You, returns the fullstats you'll gain from goose levelling; outside Grey You, returns substats
  */
 export function expectedExperience(weight = currentWeight()) {
     return Math.pow(Math.max(weight - 5, 0), toInt(myClass()) === 27 ? 2 : 3);
 }
+/**
+ * Determines the meat you'd expect to get from using Meatify Matter at the given weight
+ *
+ * @param weight The weight in question (defaults to current)
+ * @returns The expected meat from Meatify Matter
+ */
 export function expectedMeat(weight = currentWeight()) {
     return Math.pow(Math.max(weight - 5, 0), 4);
 }
+/**
+ * Determines whether you've used Meatify Matter today
+ *
+ * @returns Whether you've used Meatify Matter today
+ */
 export function hasMeatified() {
     return get("_meatifyMatterUsed");
 }
+/**
+ * Calculates the number of fights you need to reach a particular weight
+ *
+ * @param target The weight you want to reach
+ * @param bonusExperience The amount of bonus exdperience you'll be running--defaults to the current value
+ * @returns Number of fights needed
+ */
 export function fightsUntil(target, bonusExperience = getModifier("Familiar Experience")) {
-    const diff = target - currentWeight();
+    const diff = Math.pow(target, 2) - currentExperience();
     if (diff <= 0)
         return 0;
     return Math.ceil(diff /
         (1 + bonusExperience + (have_($skill `Testudinal Teachings`) ? 1 / 6 : 0)));
 }
+/**
+ * Determines how many matter-duplicating drones are currently hovering around you
+ *
+ * @returns The number of matter-duplicating drones currently hovering around you
+ */
 export function currentDrones() {
     return get("gooseDronesRemaining");
 }

package/dist/resources/2022/JuneCleaver.d.ts

@@ -1,27 +1,47 @@
 export declare const cleaver: import("kolmafia").Item;
+/**
+ * Determines whether you currently `have` the June cleaver
+ *
+ * @returns Whether you currently `have` the June cleaver
+ */
 export declare function have(): boolean;
 /**
+ * Determines the number of cleaver-combats it takes to get a particular encounter number.
+ *
+ * @param encounters The ordinal value of the June cleaver encounter you're asking about
  * @returns The number of cleaver-combats it takes to get a particular encounter number--this is agnostic of your current fights.
  */
 export declare function getInterval(encounters?: number): number;
 /**
+ * Determines the number of cleaver-combats it takes to get a particular encounter number, when a skip is in the mix
+ *
+ * @param encounters The ordinal value of the June cleaver encounter you're asking about, assuming you've skipped
  * @returns The number of cleaver-combats it would take to get a particular encounter after skipping.
  */
 export declare function getSkippedInterval(encounters?: number): number;
 /**
+ * Determines the amount of bonus elemental damage your cleaver currently grants
+ *
+ * @param element The element in question
  * @returns The bonus damage your cleaver currently gives for a given element.
  */
 export declare function damage(element: "Hot" | "Stench" | "Sleaze" | "Spooky" | "Cold"): number;
 /**
+ * Determines the number of times today you can skip a june cleaver choice
+ *
  * @returns The number of additional times you can select option 4 in a cleaver choice today.
  */
 export declare function skipsRemaining(): number;
 export declare const choices: readonly [1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475];
 /**
+ * Returns the current June cleaver queue; you are not currently able to encounter any June cleaver choice adventure in this list
+ *
  * @returns An array consisting of the cleaver choice adventures currently in the queue.
  */
 export declare function queue(): typeof choices[number][];
 /**
+ * Determines which choices are currently eligible to be encountered with your June cleaver
+ *
  * @returns An array consisting of the cleaver choice adventures not currently in the queue.
  */
 export declare function choicesAvailable(): typeof choices[number][];

package/dist/resources/2022/JuneCleaver.js

@@ -1,28 +1,44 @@
 import { toItem, availableAmount } from "kolmafia";
 import { get } from "../../property";
 export const cleaver = toItem("June cleaver");
+/**
+ * Determines whether you currently `have` the June cleaver
+ *
+ * @returns Whether you currently `have` the June cleaver
+ */
 export function have() {
     return availableAmount(cleaver) > 0;
 }
 /**
+ * Determines the number of cleaver-combats it takes to get a particular encounter number.
+ *
+ * @param encounters The ordinal value of the June cleaver encounter you're asking about
  * @returns The number of cleaver-combats it takes to get a particular encounter number--this is agnostic of your current fights.
  */
 export function getInterval(encounters = get("_juneCleaverEncounters")) {
     return [1, 6, 10, 12, 15, 20][encounters] ?? 30;
 }
 /**
+ * Determines the number of cleaver-combats it takes to get a particular encounter number, when a skip is in the mix
+ *
+ * @param encounters The ordinal value of the June cleaver encounter you're asking about, assuming you've skipped
  * @returns The number of cleaver-combats it would take to get a particular encounter after skipping.
  */
 export function getSkippedInterval(encounters = get("_juneCleaverEncounters")) {
     return [1, 2, 3, 3, 4, 5][encounters] ?? 8;
 }
 /**
+ * Determines the amount of bonus elemental damage your cleaver currently grants
+ *
+ * @param element The element in question
  * @returns The bonus damage your cleaver currently gives for a given element.
  */
 export function damage(element) {
     return get(`_juneCleaver${element}`);
 }
 /**
+ * Determines the number of times today you can skip a june cleaver choice
+ *
  * @returns The number of additional times you can select option 4 in a cleaver choice today.
  */
 export function skipsRemaining() {
@@ -32,6 +48,8 @@ export const choices = [
     1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475,
 ];
 /**
+ * Returns the current June cleaver queue; you are not currently able to encounter any June cleaver choice adventure in this list
+ *
  * @returns An array consisting of the cleaver choice adventures currently in the queue.
  */
 export function queue() {
@@ -41,6 +59,8 @@ export function queue() {
         .map((x) => parseInt(x));
 }
 /**
+ * Determines which choices are currently eligible to be encountered with your June cleaver
+ *
  * @returns An array consisting of the cleaver choice adventures not currently in the queue.
  */
 export function choicesAvailable() {

package/dist/resources/2022/TrainSet.d.ts

@@ -1,7 +1,17 @@
 import { Effect } from "kolmafia";
 import { Tuple } from "../../utils";
 export declare const item: import("kolmafia").Item;
+/**
+ * Determines whether the Model Train Set is your current workshed
+ *
+ * @returns Whether the Model Train Set is your current workshed
+ */
 export declare function installed(): boolean;
+/**
+ * Determines whether you `have` the model train set (or if it is installed)
+ *
+ * @returns Whether you `have` the model train set or it's installed
+ */
 export declare function have(): boolean;
 export declare enum Station {
     /**
@@ -89,11 +99,49 @@ export declare enum Station {
      */
     ORE_HOPPER = "ore_hopper"
 }
+/**
+ * Returns an effect--if one exists--for a given train station
+ *
+ * @param station The train station to check the effect of
+ * @returns The effect associated with the given station
+ */
 export declare function effect(station: Station): Effect | null;
+/**
+ * Returns an effect--if one exists--for a given train station, assuming it's been primed by the coal station
+ *
+ * @param station The train station to check the doubled effect of
+ * @returns The effect associated with given station, under the influence of coal
+ */
 export declare function doubledEffect(station: Station): Effect | null;
 export declare type Cycle = Tuple<Station, 8>;
+/**
+ * Determines the current configuration of train stations
+ *
+ * @returns An 8-tuple consisting of the stations currently installed in your Model Train Set; this functions even if the Model Train Set isn't your active workshed
+ */
 export declare function cycle(): Cycle;
+/**
+ * Determines how many turns until you can next configure the Model Train Set
+ *
+ * @returns How many turns until you can next configure the Model Train Set
+ */
 export declare function nextConfigurable(): number;
+/**
+ * Determines whether you can currently configure your Model Train Set
+ *
+ * @returns Whether you can currently configure your Model Train Set
+ */
 export declare function canConfigure(): boolean;
+/**
+ * Sets your model train station to the given configuration, if able
+ *
+ * @param configuration The cycle to try to set your model train station to
+ * @returns Whether your model train station matches the given configuration
+ */
 export declare function setConfiguration(configuration: Cycle): boolean;
+/**
+ * Determines the next station you expect to encounter when the Model Train Station is active
+ *
+ * @returns The next station you expect to encounter when the Model Train Station is active
+ */
 export declare function next(): Station;

package/dist/resources/2022/TrainSet.js

@@ -4,9 +4,19 @@ import { get } from "../../property";
 import { $item } from "../../template-string";
 import { clamp } from "../../utils";
 export const item = $item `model train set`;
+/**
+ * Determines whether the Model Train Set is your current workshed
+ *
+ * @returns Whether the Model Train Set is your current workshed
+ */
 export function installed() {
     return getWorkshed() === item;
 }
+/**
+ * Determines whether you `have` the model train set (or if it is installed)
+ *
+ * @returns Whether you `have` the model train set or it's installed
+ */
 export function have() {
     return installed() || have_(item);
 }
@@ -117,18 +127,45 @@ const trainsetEffectsDoubled = new Map([
     [Station.WATER_BRIDGE, Effect.get("Doubly Troubled Waters")],
     [Station.PRAWN_SILO, Effect.get("Doubly Craving Prawns")],
 ]);
+/**
+ * Returns an effect--if one exists--for a given train station
+ *
+ * @param station The train station to check the effect of
+ * @returns The effect associated with the given station
+ */
 export function effect(station) {
     return trainsetEffects.get(station) ?? null;
 }
+/**
+ * Returns an effect--if one exists--for a given train station, assuming it's been primed by the coal station
+ *
+ * @param station The train station to check the doubled effect of
+ * @returns The effect associated with given station, under the influence of coal
+ */
 export function doubledEffect(station) {
     return trainsetEffectsDoubled.get(station) ?? null;
 }
+/**
+ * Determines the current configuration of train stations
+ *
+ * @returns An 8-tuple consisting of the stations currently installed in your Model Train Set; this functions even if the Model Train Set isn't your active workshed
+ */
 export function cycle() {
     return get("trainsetConfiguration").split(",");
 }
+/**
+ * Determines how many turns until you can next configure the Model Train Set
+ *
+ * @returns How many turns until you can next configure the Model Train Set
+ */
 export function nextConfigurable() {
     return clamp(get("lastTrainsetConfiguration") + 40 - get("trainsetPosition"), 0, 40);
 }
+/**
+ * Determines whether you can currently configure your Model Train Set
+ *
+ * @returns Whether you can currently configure your Model Train Set
+ */
 export function canConfigure() {
     return installed() && !nextConfigurable();
 }
@@ -155,9 +192,21 @@ const pieces = [
     Station.TRACKSIDE_DINER,
     Station.ORE_HOPPER,
 ];
+/**
+ * Converts a given station to the integer value KoL associates with them
+ *
+ * @param station The station in question
+ * @returns The integer value KoL assigns the train station in question
+ */
 function stationToInt(station) {
     return pieces.indexOf(station);
 }
+/**
+ * Sets your model train station to the given configuration, if able
+ *
+ * @param configuration The cycle to try to set your model train station to
+ * @returns Whether your model train station matches the given configuration
+ */
 export function setConfiguration(configuration) {
     if (!canConfigure())
         return false;
@@ -169,6 +218,11 @@ export function setConfiguration(configuration) {
     const currentConfiguration = cycle();
     return configuration.every((station, index) => station === currentConfiguration[index]);
 }
+/**
+ * Determines the next station you expect to encounter when the Model Train Station is active
+ *
+ * @returns The next station you expect to encounter when the Model Train Station is active
+ */
 export function next() {
     return cycle()[get("trainsetPosition") % 8];
 }

package/dist/resources/2023/ClosedCircuitPayphone.d.ts

@@ -0,0 +1,75 @@
+import { Monster, Item, Location } from "kolmafia";
+export declare const item: Item;
+/**
+ * @returns Whether we currently have the closed-circuit pay phone
+ */
+export declare function have(): boolean;
+/**
+ * @returns Rufus's currently expected quest target, if he has one
+ */
+export declare function rufusTarget(): Monster | Item | string | null;
+declare const INGRESS_RIFTS: {
+    readonly desertbeach: Location;
+    readonly forestvillage: Location;
+    readonly mclargehuge: Location;
+    readonly beanstalk: Location;
+    readonly manor3: Location;
+    readonly "8bit": Location;
+    readonly pyramid: Location;
+    readonly giantcastle: Location;
+    readonly woods: Location;
+    readonly hiddencity: Location;
+    readonly cemetery: Location;
+    readonly plains: Location;
+    readonly town_right: Location;
+};
+export declare type Ingress = "" | keyof typeof INGRESS_RIFTS;
+/**
+ * @returns Your current `shadowRiftIngress`; `null` if none is set this ascension
+ */
+export declare function currentIngress(): Ingress;
+/**
+ * @returns The current shadow rift that Mafia thinks KoL thinks you're in.
+ */
+export declare function currentRift(): Location | null;
+/**
+ * Choose a shadow rift to suit your needs
+ *
+ * @param options An object of various requirements you might have for the rift you want
+ * @param options.canAdventure Set to `true` if you want to only select a rift that you can currently access
+ * @param options.monsters Set to an array of Shadow Monsters you want to be available in the rift
+ * @param options.drops Set to an array of item drops you want to come from monsters in the rift
+ * @param options.otherFilter Set an optional additional filtering function not covered by the above logic
+ * @param options.sortBy Set a function used to compare valid rifts between eachother; bigger numbers are better
+ * @returns A rift that meets the criteria you specify, if one exists
+ */
+export declare function chooseRift(options: {
+    canAdventure?: boolean;
+    monsters?: Monster[];
+    drops?: Item[];
+    otherFilter?: (l: Location) => boolean;
+    sortBy?: (l: Location) => number;
+}): Location | null;
+/**
+ * Choose a quest based on the options available to us
+ *
+ * @param chooser A function that maps quest-options to a choice
+ * @returns Whether we successfully accepted a quest
+ */
+export declare function chooseQuest(chooser: ({ entity, artifact, items, }: {
+    entity: Monster;
+    artifact: Item;
+    items: Item;
+}) => 1 | 2 | 3 | 4): boolean;
+/**
+ * @returns Array containing all shadow rift locations
+ */
+export declare function rifts(): Location[];
+/**
+ * Picks an option based on your current shadow rift ingress
+ *
+ * @param options An object keyed by shadow rift ingress; it must either contain all possible ingresses, or have a `default` parameter.
+ * @returns The option corresponding to your current shadow rift ingress.
+ */
+export declare const byIngress: <S>(options: import("../../utils").Switch<Ingress, S>) => S;
+export {};

package/dist/resources/2023/ClosedCircuitPayphone.js

@@ -0,0 +1,117 @@
+import { Monster, Item, getMonsters, itemDrops, canAdventure, use, runChoice, toItem, toMonster, } from "kolmafia";
+import { have as have_ } from "../../lib";
+import { get, withChoice } from "../../property";
+import { $item, $location } from "../../template-string";
+import { makeByXFunction, maxBy } from "../../utils";
+export const item = $item `closed-circuit pay phone`;
+/**
+ * @returns Whether we currently have the closed-circuit pay phone
+ */
+export function have() {
+    return have_(item);
+}
+/**
+ * @returns Rufus's currently expected quest target, if he has one
+ */
+export function rufusTarget() {
+    const target = get("rufusQuestTarget");
+    switch (get("rufusQuestType")) {
+        case "entity":
+            return Monster.get(target);
+        case "artifact":
+        case "items":
+            return Item.get(target);
+        default:
+            return null;
+    }
+}
+const INGRESS_RIFTS = {
+    desertbeach: $location `Shadow Rift (Desert Beach)`,
+    forestvillage: $location `Shadow Rift (Forest Village)`,
+    mclargehuge: $location `Shadow Rift (Mt. McLargeHuge)`,
+    beanstalk: $location `Shadow Rift (Somewhere Over the Beanstalk)`,
+    manor3: $location `Shadow Rift (Spookyraven Manor Third Floor)`,
+    "8bit": $location `Shadow Rift (The 8-Bit Realm)`,
+    pyramid: $location `Shadow Rift (The Ancient Buried Pyramid)`,
+    giantcastle: $location `Shadow Rift (The Castle in the Clouds in the Sky)`,
+    woods: $location `Shadow Rift (The Distant Woods)`,
+    hiddencity: $location `Shadow Rift (The Hidden City)`,
+    cemetery: $location `Shadow Rift (The Misspelled Cemetary)`,
+    plains: $location `Shadow Rift (The Nearby Plains)`,
+    town_right: $location `Shadow Rift (The Right Side of the Tracks)`,
+};
+/**
+ * @returns Your current `shadowRiftIngress`; `null` if none is set this ascension
+ */
+export function currentIngress() {
+    return get("shadowRiftIngress");
+}
+/**
+ * @returns The current shadow rift that Mafia thinks KoL thinks you're in.
+ */
+export function currentRift() {
+    const ingress = currentIngress();
+    return ingress ? INGRESS_RIFTS[ingress] : null;
+}
+const RIFTS = Array.from(Object.values(INGRESS_RIFTS));
+/**
+ * Choose a shadow rift to suit your needs
+ *
+ * @param options An object of various requirements you might have for the rift you want
+ * @param options.canAdventure Set to `true` if you want to only select a rift that you can currently access
+ * @param options.monsters Set to an array of Shadow Monsters you want to be available in the rift
+ * @param options.drops Set to an array of item drops you want to come from monsters in the rift
+ * @param options.otherFilter Set an optional additional filtering function not covered by the above logic
+ * @param options.sortBy Set a function used to compare valid rifts between eachother; bigger numbers are better
+ * @returns A rift that meets the criteria you specify, if one exists
+ */
+export function chooseRift(options) {
+    const filterFunction = (l) => {
+        const monsters = getMonsters(l);
+        if (options.canAdventure && !canAdventure(l))
+            return false;
+        if (options.monsters?.some((m) => !monsters.includes(m)))
+            return false;
+        if (options.drops?.every((i) => !monsters.some((m) => i.name in itemDrops(m))))
+            return false;
+        return options.otherFilter?.(l) ?? true;
+    };
+    const validRifts = [...RIFTS].filter(filterFunction);
+    if (!validRifts.length)
+        return null;
+    return options.sortBy ? maxBy(validRifts, options.sortBy) : validRifts[0];
+}
+/**
+ * Choose a quest based on the options available to us
+ *
+ * @param chooser A function that maps quest-options to a choice
+ * @returns Whether we successfully accepted a quest
+ */
+export function chooseQuest(chooser) {
+    if (get("questRufus") !== "unstarted")
+        return false;
+    if (!have())
+        return false;
+    withChoice(1497, "", () => {
+        use(item);
+        runChoice(chooser({
+            artifact: toItem(get("rufusDesiredArtifact")),
+            entity: toMonster(get("rufusDesiredEntity")),
+            items: toItem(get("rufusDesiredItems")),
+        }));
+    });
+    return get("questRufus") !== "unstarted";
+}
+/**
+ * @returns Array containing all shadow rift locations
+ */
+export function rifts() {
+    return [...RIFTS];
+}
+/**
+ * Picks an option based on your current shadow rift ingress
+ *
+ * @param options An object keyed by shadow rift ingress; it must either contain all possible ingresses, or have a `default` parameter.
+ * @returns The option corresponding to your current shadow rift ingress.
+ */
+export const byIngress = makeByXFunction(currentIngress);